@reportportal/ui-kit 0.0.1-alpha.2 → 0.0.1-alpha.200

package/dist/components/adaptiveTagList/adaptiveTagList.d.ts

@@ -0,0 +1,11 @@
+export interface AdaptiveTagListProps {
+    tags: string[];
+    isShowAllView?: boolean;
+    defaultVisibleLines?: number;
+    onRemoveTag?: (tag: string) => void;
+    noTagsMessage?: string;
+    showAllText?: string;
+    hideAllText?: string;
+    showLessText?: string;
+}
+export declare const AdaptiveTagList: ({ tags, isShowAllView, defaultVisibleLines, onRemoveTag, noTagsMessage, showAllText, hideAllText, showLessText, }: AdaptiveTagListProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,6 @@
+export declare const DEFAULT_VISIBLE_LINES = 3;
+export declare const TAG_LINE_HEIGHT = 22;
+export declare const TAG_GAP_HEIGHT = 8;
+export declare const IMMEDIATE_DELAY = 0;
+export declare const FONT_LOADING_DELAY = 100;
+export declare const OFFSET_TOLERANCE = 20;

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

@@ -0,0 +1,2 @@
+export { AdaptiveTagList } from './adaptiveTagList';
+export type { AdaptiveTagListProps } from './adaptiveTagList';

package/dist/components/attachedFile/attachedFile.d.ts

@@ -0,0 +1,17 @@
+import { VoidFn } from '../../common/types';
+
+export interface AttachedFileProps {
+    fileName: string;
+    size: number;
+    isFullWidth?: boolean;
+    uploadingProgress?: number;
+    isUploading?: boolean;
+    isUploadFailed?: boolean;
+    uploadFailedMessage?: string;
+    onRemove?: VoidFn;
+    onDownload?: VoidFn;
+    withPreview?: boolean;
+    textPosition?: 'bottom' | 'right';
+    imageSrc?: string;
+}
+export declare const AttachedFile: ({ fileName, size, uploadingProgress, isUploadFailed, uploadFailedMessage, isUploading, isFullWidth, onDownload, onRemove, withPreview, textPosition, imageSrc, }: AttachedFileProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,2 @@
+export { AttachedFile } from './attachedFile';
+export type { AttachedFileProps } from './attachedFile';

package/dist/components/autocompletes/common/autocompleteMenu/autocompleteMenu.d.ts

@@ -0,0 +1,12 @@
+import { AutocompleteOptionsProps } from '../autocompleteOptions';
+
+export declare const AutocompleteMenu: <T>(props: {
+    isOpen?: boolean | undefined;
+    style?: import('react').CSSProperties | undefined;
+    isDropdownMode?: boolean | undefined;
+    minLength?: number | null | undefined;
+    inputValue?: string | undefined;
+    className?: string | undefined;
+    optionsLimit?: number | undefined;
+    limitationText?: string | undefined;
+} & AutocompleteOptionsProps<T> & import('react').RefAttributes<HTMLUListElement>) => import('react').ReactElement<any, string | import('react').JSXElementConstructor<any>> | null;

package/dist/components/autocompletes/common/autocompleteMenu/index.d.ts

@@ -0,0 +1 @@
+export { AutocompleteMenu } from './autocompleteMenu';

package/dist/components/autocompletes/common/autocompleteOption/autocompleteOption.d.ts

@@ -0,0 +1,13 @@
+import { HTMLAttributes, ReactNode } from 'react';
+
+type AutocompleteOptionProps = {
+    isActive?: boolean;
+    isSelected?: boolean;
+    isNew?: boolean;
+    children?: ReactNode;
+    disabled?: boolean;
+    optionVariant?: 'key-variant' | 'value-variant' | '';
+    newItemButtonText?: string;
+} & HTMLAttributes<HTMLLIElement | HTMLButtonElement>;
+export declare const AutocompleteOption: ({ isActive, isSelected, isNew, children, disabled, optionVariant, newItemButtonText, ...props }: AutocompleteOptionProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/autocompletes/common/autocompleteOption/index.d.ts

@@ -0,0 +1 @@
+export { AutocompleteOption } from './autocompleteOption';

package/dist/components/autocompletes/common/autocompleteOptions.d.ts

@@ -0,0 +1,21 @@
+import { ReactNode } from 'react';
+import { GetItemPropsT } from '../types';
+
+export interface AutocompleteOptionsProps<T> {
+    options: T[];
+    loading?: boolean;
+    inputValue: string;
+    parseValueToString: (value: T | null) => string;
+    getItemProps: GetItemPropsT<T>;
+    renderOption?: (item: T, index: number, isNew: boolean, getItemProps: GetItemPropsT<T>) => ReactNode;
+    async?: boolean;
+    optionVariant: 'key-variant' | 'value-variant' | '';
+    createWithoutConfirmation: boolean;
+    customEmptyListMessage?: string;
+    customNoMatchesMessage?: string;
+    getUniqKey?: (item: T) => string;
+    newItemButtonText: string;
+    limitationText?: string;
+    optionsLimit?: number;
+}
+export declare const AutocompleteOptions: <T>(props: AutocompleteOptionsProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/autocompletes/common/autocompletePrompt/autocompletePrompt.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+
+interface AutocompletePromptProps {
+    children: ReactNode;
+}
+export declare const AutocompletePrompt: ({ children }: AutocompletePromptProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/autocompletes/common/autocompletePrompt/index.d.ts

@@ -0,0 +1 @@
+export { AutocompletePrompt } from './autocompletePrompt';

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

@@ -0,0 +1,19 @@
+/*!
+ * Copyright 2025 EPAM Systems
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export { AutocompleteMenu } from './autocompleteMenu';
+export { AutocompletePrompt } from './autocompletePrompt';
+export { AutocompleteOption } from './autocompleteOption';
+export { AutocompleteOptions } from './autocompleteOptions';

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

@@ -0,0 +1,2 @@
+export declare const ENTER_KEY_NAME = "Enter";
+export declare const TAB_KEY_NAME = "Tab";

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

@@ -0,0 +1,3 @@
+export * from './common';
+export { SingleAutocomplete } from './singleAutocomplete';
+export { MultipleAutocomplete } from './multipleAutocomplete';

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

@@ -0,0 +1,17 @@
+/*!
+ * Copyright 2025 EPAM Systems
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export { SelectedItems } from './selectedItems';
+export { MultipleAutocomplete } from './multipleAutocomplete';

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

@@ -0,0 +1,55 @@
+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;
+    menuClassName?: string;
+    selectedItemSingleLine?: boolean;
+    selectedItemClassName?: string;
+    selectedItemTextClassName?: string;
+    optionsLimit?: number;
+    limitationText?: 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,41 @@
+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;
+    singleLine?: boolean;
+    className?: string;
+    textClassName?: string;
+}
+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;
+    selectedItemSingleLine?: boolean;
+    selectedItemClassName?: string;
+    selectedItemTextClassName?: string;
+};
+export declare const SelectedItems: <T>({ items, parseValueToString, getItemValidationErrorType, storedItemsMap, highlightUnStoredItem, renderCustomSelectedItem, selectedItemSingleLine, selectedItemClassName, selectedItemTextClassName, ...props }: SelectedItemsProps<T>) => (string | number | boolean | Iterable<ReactNode> | import("react/jsx-runtime").JSX.Element | 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,45 @@
+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;
+    dropdownMatchInputWidth?: boolean;
+    getUniqKey?: (item: T) => string;
+    customEmptyListMessage?: string;
+    customNoMatchesMessage?: string;
+    newItemButtonText?: string;
+    optionsLimit?: number;
+    limitationText?: 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/baseIconButton/baseIconButton.d.ts

@@ -0,0 +1,9 @@
+import { FC, MouseEventHandler, ReactNode, HTMLAttributes } from 'react';
+
+export interface BaseIconButtonProps extends HTMLAttributes<HTMLButtonElement> {
+    children: ReactNode;
+    className?: string;
+    disabled?: boolean;
+    onClick?: MouseEventHandler<HTMLButtonElement>;
+}
+export declare const BaseIconButton: FC<BaseIconButtonProps>;

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

@@ -0,0 +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, isLastClickable, isSingleItemClickable, maxShownDescriptors, titleTailNumChars: customTitleTailNumChars, className, }: 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,29 @@
+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;
+    isLastClickable?: boolean;
+    isSingleItemClickable?: boolean;
+    maxShownDescriptors?: number;
+    titleTailNumChars?: number;
+    className?: string;
+}

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

@@ -0,0 +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

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

package/dist/components/bulkPanel/bulkPanel.d.ts

@@ -0,0 +1,3 @@
+import { BulkPanelProps } from './types';
+
+export declare const BulkPanel: ({ items, actions, captions: captionsProp, infoMessage, className, portalRoot, zIndex, onRemoveItem, onClearSelection, }: BulkPanelProps) => import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,2 @@
+export { BulkPanel } from './bulkPanel';
+export type { BulkPanelProps, BulkPanelItem, BulkPanelAction, BulkPanelCaptions } from './types';

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

@@ -0,0 +1,47 @@
+import { ReactNode } from 'react';
+import { ButtonProps } from '../button';
+
+export interface BulkPanelItem {
+    id: string | number;
+    label?: string;
+    name?: string;
+    tooltipContent?: ReactNode;
+}
+export interface BulkPanelAction {
+    label: string;
+    variant?: ButtonProps['variant'];
+    disabled?: boolean;
+    onClick?: () => void;
+    /**
+     * Called to validate items. May be called multiple times if items change.
+     * Should return INELIGIBLE items array.
+     * If not provided or returns empty array - all items are eligible and onProceed is called immediately.
+     */
+    onValidate?: (items: BulkPanelItem[]) => BulkPanelItem[];
+    /**
+     * @param direct - true if all items were eligible and proceed was called directly, false if called via Proceed button
+     */
+    onProceed: (eligibleItems: BulkPanelItem[], direct?: boolean) => void;
+    onCancel?: () => void;
+}
+export interface BulkPanelCaptions {
+    selected?: string;
+    clearSelection?: string;
+    selectedItems?: string;
+    eligibleTab?: string;
+    ineligibleTab?: string;
+    ineligibleInfoMessage?: (ineligibleCount: number) => ReactNode | string;
+    cancelButton?: (actionLabel: string) => ReactNode | string;
+    proceedButton?: (eligibleCount: number) => ReactNode | string;
+}
+export interface BulkPanelProps {
+    items: BulkPanelItem[];
+    actions?: BulkPanelAction[];
+    captions?: BulkPanelCaptions;
+    infoMessage?: ReactNode;
+    className?: string;
+    portalRoot?: Element;
+    zIndex?: number;
+    onRemoveItem: (id: string | number) => void;
+    onClearSelection: () => void;
+}

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

@@ -1,19 +1,19 @@
-import { FC, ReactNode } from 'react';
+import { ReactNode, ComponentPropsWithRef, MouseEventHandler } from 'react';
+
 type IconPlace = 'start' | 'end';
-type ButtonVariant = 'primary' | 'ghost' | 'danger' | 'text';
-interface ButtonProps {
+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?: string;
+    icon?: ReactNode;
     iconPlace?: IconPlace;
-    dataAutomationId?: string;
-    wide?: boolean;
+    adjustWidthOn?: ButtonWidth;
     disabled?: boolean;
     type?: 'submit' | 'reset' | 'button';
-    onClick?: () => void;
-    form?: string;
+    onClick?: MouseEventHandler<HTMLButtonElement>;
     title?: string;
     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,3 +1,5 @@
-import { Button } from './button';
+import { Button, ButtonProps } from './button';
+
 export { Button };
+export type { ButtonProps };
 export default Button;

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

@@ -1,14 +1,13 @@
-import { FC, ReactNode } from 'react';
-interface CheckboxProps {
-    value: boolean;
+import { FC, ReactNode, ChangeEventHandler, HTMLAttributes } from 'react';
+
+interface CheckboxProps extends HTMLAttributes<HTMLInputElement> {
+    value?: boolean;
     children?: ReactNode;
     disabled?: boolean;
     className?: string;
-    dataAutomationId?: string;
-    onChange?: () => void;
-    onFocus?: () => void;
-    onBlur?: () => void;
-    form?: string;
+    onChange?: ChangeEventHandler<HTMLInputElement>;
+    partiallyChecked?: boolean;
+    title?: string;
 }
 export declare const Checkbox: FC<CheckboxProps>;
 export {};

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

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