@reportportal/ui-kit 0.0.1-alpha.17 → 0.0.1-alpha.170

package/dist/chip.js

@@ -0,0 +1,72 @@
+import { jsxs as k, Fragment as w, jsx as n } from "react/jsx-runtime";
+import { c as N } from "./bind-06a7ff84.js";
+import "react";
+import { S as x } from "./close-4d480ef7.js";
+const D = "_chip_a59ru_16", j = "_clickable_a59ru_34", K = "_disabled_a59ru_40", S = "_label_a59ru_51", v = "_error_a59ru_82", E = "_warning_a59ru_87", F = "_link_a59ru_91", I = {
+  chip: D,
+  clickable: j,
+  disabled: K,
+  label: S,
+  "remove-button": "_remove-button_a59ru_57",
+  error: v,
+  warning: E,
+  link: F
+}, c = N.bind(I), A = ({
+  children: u,
+  variant: b = "default",
+  link: s,
+  onClick: t,
+  onRemove: e,
+  className: p,
+  maxWidth: l,
+  title: f,
+  disabled: a = !1
+}) => {
+  const o = !!t && !a, h = o ? "button" : void 0, m = o ? 0 : void 0, i = c("chip", b, p, {
+    disabled: a,
+    clickable: !!t || !!s,
+    removable: !!e
+  }), d = (r) => {
+    r.stopPropagation(), r.preventDefault(), e == null || e(r);
+  }, g = (r) => {
+    a || t == null || t(r);
+  }, y = (r) => {
+    a || (r.key === "Enter" || r.key === " ") && (r.preventDefault(), r.currentTarget.click());
+  }, _ = /* @__PURE__ */ k(w, { children: [
+    /* @__PURE__ */ n("span", { className: c("label"), style: l ? { maxWidth: l } : void 0, title: f, children: u }),
+    e && !a && /* @__PURE__ */ n(
+      "button",
+      {
+        type: "button",
+        className: c("remove-button"),
+        onClick: d,
+        "aria-label": "Remove",
+        children: /* @__PURE__ */ n(x, {})
+      }
+    )
+  ] });
+  return s && !a ? /* @__PURE__ */ n(
+    "a",
+    {
+      href: s,
+      className: i,
+      onClick: t,
+      target: "_blank",
+      rel: "noopener noreferrer",
+      children: _
+    }
+  ) : /* @__PURE__ */ n(
+    "span",
+    {
+      className: i,
+      onClick: g,
+      onKeyDown: y,
+      role: h,
+      tabIndex: m,
+      children: _
+    }
+  );
+};
+export {
+  A as Chip
+};

package/dist/clear-53660571.js

@@ -0,0 +1,5 @@
+import * as e from "react";
+const t = (l) => /* @__PURE__ */ e.createElement("svg", { width: 16, height: 16, viewBox: "0 0 16 16", fill: "none", xmlns: "http://www.w3.org/2000/svg", ...l }, /* @__PURE__ */ e.createElement("path", { fillRule: "evenodd", clipRule: "evenodd", d: "M1 8C1 4.14001 4.14001 1 8 1C11.86 1 15 4.14001 15 8C15 11.8595 11.86 15 8 15C4.14001 15 1 11.8595 1 8ZM5 5.54545L5.54545 5L8 7.45455L10.4545 5L11 5.54545L8.54545 8L11 10.4545L10.4545 11L8 8.54545L5.54545 11L5 10.4545L7.45455 8L5 5.54545Z", fill: "#A2AAB5" }));
+export {
+  t as S
+};

package/dist/close-4d480ef7.js

@@ -0,0 +1,5 @@
+import * as e from "react";
+const t = (l) => /* @__PURE__ */ e.createElement("svg", { width: 16, height: 16, viewBox: "0 0 16 16", fill: "none", xmlns: "http://www.w3.org/2000/svg", ...l }, /* @__PURE__ */ e.createElement("path", { fillRule: "evenodd", clipRule: "evenodd", d: "M0.732184 15.2698C0.330645 14.8683 0.330646 14.2172 0.732185 13.8157L6.54859 7.99928L0.732185 2.18288C0.330646 1.78134 0.330645 1.13031 0.732184 0.728774C1.13372 0.327235 1.78475 0.327235 2.18629 0.728774L8.00269 6.54518L13.8191 0.728767C14.2206 0.327229 14.8717 0.327228 15.2732 0.728767C15.6747 1.13031 15.6747 1.78133 15.2732 2.18287L9.45679 7.99928L15.2732 13.8157C15.6747 14.2172 15.6747 14.8683 15.2732 15.2698C14.8717 15.6713 14.2206 15.6713 13.8191 15.2698L8.00269 9.45338L2.18629 15.2698C1.78475 15.6713 1.13372 15.6713 0.732184 15.2698Z", fill: "#A2AAB5" }));
+export {
+  t as S
+};

package/dist/common/constants/floatingUi.d.ts

@@ -0,0 +1,8 @@
+import { Placement } from '@floating-ui/react';
+
+export declare const TRIANGLE_WIDTH = 16;
+export declare const TRIANGLE_HEIGHT = 8;
+export declare const ARROW_OFFSET = 16;
+export declare const middlePlacements: Placement[];
+export declare const verticalPlacements: Placement[];
+export declare const allPlacements: Placement[];

package/dist/common/constants/sortable.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_SORTABLE_TYPE = "SORTABLE_ITEM";

package/dist/common/hooks/index.d.ts

@@ -1,2 +1,5 @@
 export { useOnClickOutside } from './useOnClickOutside';
+export { useSortable } from './useSortable';
+export { useTreeSortable } from './useTreeSortable';
+export { useTreeDropValidation } from './useTreeDropValidation';
 export { useWindowResize } from './useWindowResize';

package/dist/common/hooks/useOnClickOutside.d.ts

@@ -1,2 +1,6 @@
 import { RefObject } from 'react';
-export declare function useOnClickOutside<T extends HTMLElement = HTMLDivElement>(ref: RefObject<T>, handler?: (e?: MouseEvent) => void): void;
+
+export interface UseOnClickOutsideOptions {
+    ignoreSelectors?: string[];
+}
+export declare function useOnClickOutside<T extends HTMLElement = HTMLDivElement>(ref: RefObject<T>, handler?: (e?: MouseEvent) => void, options?: UseOnClickOutsideOptions): void;

package/dist/common/hooks/useSortable.d.ts

@@ -0,0 +1,3 @@
+import { UseSortableOptions, UseSortableReturn } from '../types';
+
+export declare const useSortable: ({ id, index, type, isDisabled, isLast, onDrop, hideDefaultPreview, dropDetectionMode, }: UseSortableOptions) => UseSortableReturn;

package/dist/common/hooks/useTreeDropValidation.d.ts

@@ -0,0 +1,5 @@
+import { TreeDragItem, TreeItem, UseTreeDropValidationOptions } from '../types';
+
+export declare const useTreeDropValidation: <T extends TreeItem<T>>({ items, childrenKey, }: UseTreeDropValidationOptions<T>) => {
+    canDropOn: (draggedItem: TreeDragItem, targetId: string | number) => boolean;
+};

package/dist/common/hooks/useTreeSortable.d.ts

@@ -0,0 +1,3 @@
+import { UseTreeSortableOptions, UseTreeSortableReturn } from '../types';
+
+export declare const useTreeSortable: ({ id, index, parentId, type, isDisabled, acceptDrop, canDropOn, onDrop, hideDefaultPreview, }: UseTreeSortableOptions) => UseTreeSortableReturn;

package/dist/common/hooks.js

@@ -0,0 +1,67 @@
+import { u as w } from "../useOnClickOutside-8f7d68a1.js";
+import { u as E, a as R } from "../useTreeSortable-70a9c8f5.js";
+import { useCallback as x } from "react";
+import { i as z } from "../isEmpty-ccacb5ff.js";
+import { u as W } from "../useWindowResize-a7e1ac92.js";
+import "react-dnd";
+import "react-dnd-html5-backend";
+import "../common.js";
+/*!
+ * Copyright 2026 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.
+ */
+const o = (r) => String(r), I = (r, e, f, n = "children") => {
+  const s = o(r), u = o(e), i = (c, a) => {
+    for (const t of a) {
+      if (o(t.id) === c)
+        return t;
+      const m = t[n] || [];
+      if (!z(m)) {
+        const p = i(c, m);
+        if (p)
+          return p;
+      }
+    }
+    return null;
+  }, d = i(s, f);
+  if (!d)
+    return !1;
+  const l = (c) => {
+    for (const a of c) {
+      if (o(a.id) === u)
+        return !0;
+      const t = a[n] || [];
+      if (!z(t) && l(t))
+        return !0;
+    }
+    return !1;
+  }, D = d[n] || [];
+  return l(D);
+}, S = ({
+  items: r,
+  childrenKey: e = "children"
+}) => ({ canDropOn: x(
+  (n, s) => {
+    const u = o(n.id), i = o(s);
+    return u === i ? !1 : !I(n.id, s, r, e);
+  },
+  [r, e]
+) });
+export {
+  w as useOnClickOutside,
+  E as useSortable,
+  S as useTreeDropValidation,
+  R as useTreeSortable,
+  W as useWindowResize
+};

package/dist/common/types/commonTypes.d.ts

@@ -0,0 +1,4 @@
+export type ShapeWithClassName<P = Record<string, unknown>> = P & {
+    className?: string;
+};
+export type VoidFn = () => void;

package/dist/common/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './commonTypes';
+export * from './sortableTypes';

package/dist/common/types/sortableTypes.d.ts

@@ -0,0 +1,168 @@
+import { ReactNode, Ref } from 'react';
+import { XYCoord, ConnectDragSource, ConnectDropTarget, ConnectDragPreview } from 'react-dnd';
+
+export interface SortableItemData {
+    id: string | number;
+    index: number;
+}
+export interface DragItem extends SortableItemData {
+    type: string;
+}
+export declare const DROP_POSITIONS: {
+    readonly TOP: "top";
+    readonly BOTTOM: "bottom";
+};
+export type DropPositionValue = (typeof DROP_POSITIONS)[keyof typeof DROP_POSITIONS];
+export declare const DROP_DETECTION_MODE: {
+    readonly INDEX_BASED: "indexBased";
+    readonly HOVER: "hover";
+};
+export type DropDetectionMode = (typeof DROP_DETECTION_MODE)[keyof typeof DROP_DETECTION_MODE];
+export interface UseSortableOptions {
+    id: string | number;
+    index: number;
+    type?: string;
+    isDisabled?: boolean;
+    isLast?: boolean;
+    onDrop?: (fromIndex: number, toIndex: number) => void;
+    hideDefaultPreview?: boolean;
+    dropDetectionMode?: DropDetectionMode;
+}
+export interface UseSortableReturn {
+    isDragging: boolean;
+    isOver: boolean;
+    draggedItemIndex: number | null;
+    dropPosition: DropPosition;
+    dragRef: ConnectDragSource;
+    dropRef: ConnectDropTarget;
+    previewRef: ConnectDragPreview;
+}
+export interface SortableItemRenderProps {
+    isDragging: boolean;
+    isOver: boolean;
+    dragRef: Ref<HTMLElement>;
+}
+export interface SortableItemProps {
+    id: string | number;
+    index: number;
+    type?: string;
+    isDisabled?: boolean;
+    isLast?: boolean;
+    className?: string;
+    draggingClassName?: string;
+    dropTargetClassName?: string;
+    onDrop?: (fromIndex: number, toIndex: number) => void;
+    hideDefaultPreview?: boolean;
+    dropDetectionMode?: DropDetectionMode;
+    children: ReactNode | ((props: SortableItemRenderProps) => ReactNode);
+}
+export interface SortableListProps<T extends {
+    id: string | number;
+}> {
+    items: T[];
+    type?: string;
+    isDisabled?: boolean;
+    className?: string;
+    itemClassName?: string;
+    onReorder: (reorderedItems: T[]) => void;
+    renderItem: (item: T, index: number, dragRef: Ref<HTMLElement>, isDragging: boolean) => ReactNode;
+    keyExtractor?: (item: T) => string | number;
+}
+export interface DragLayerProps {
+    type: string;
+    renderPreview: (item: DragItem) => ReactNode;
+    className?: string;
+    previewClassName?: string;
+    portalTarget?: Element | null;
+}
+export interface DragLayerCollectedProps {
+    item: DragItem | null;
+    itemType: string | symbol | null;
+    clientOffset: XYCoord | null;
+    isDragging: boolean;
+}
+export type DropPosition = 'top' | 'bottom' | null;
+export declare const TREE_DROP_POSITIONS: {
+    readonly BEFORE: "before";
+    readonly INSIDE: "inside";
+    readonly AFTER: "after";
+};
+export type TreeDropPositionValue = (typeof TREE_DROP_POSITIONS)[keyof typeof TREE_DROP_POSITIONS];
+export type TreeDropPosition = TreeDropPositionValue | null;
+export interface TreeDragItem extends DragItem {
+    parentId?: string | number | null;
+    depth?: number;
+}
+export type TreeDropHandler = (draggedItem: TreeDragItem, targetId: string | number, position: TreeDropPosition) => void;
+export interface UseTreeSortableOptions {
+    id: string | number;
+    index: number;
+    parentId?: string | number | null;
+    type?: string;
+    isDisabled?: boolean;
+    acceptDrop?: boolean;
+    canDropOn?: (draggedItem: TreeDragItem, targetId: string | number) => boolean;
+    onDrop?: TreeDropHandler;
+    hideDefaultPreview?: boolean;
+}
+export interface TreeSortableState {
+    isDragging: boolean;
+    isOver: boolean;
+    dropPosition: TreeDropPosition;
+    dragRef: ConnectDragSource;
+}
+export interface UseTreeSortableReturn extends TreeSortableState {
+    dropRef: (node: HTMLElement | null) => void;
+    previewRef: ConnectDragPreview;
+    elementRef: React.RefObject<HTMLElement | null>;
+}
+export type TreeSortableItemRenderProps = TreeSortableState;
+export interface TreeSortableItemProps {
+    id: string | number;
+    index: number;
+    parentId?: string | number | null;
+    type?: string;
+    isDisabled?: boolean;
+    acceptDrop?: boolean;
+    isLast?: boolean;
+    canDropOn?: (draggedItem: TreeDragItem, targetId: string | number) => boolean;
+    depth?: number;
+    className?: string;
+    draggingClassName?: string;
+    dropBeforeClassName?: string;
+    dropInsideClassName?: string;
+    dropAfterClassName?: string;
+    onDrop?: TreeDropHandler;
+    hideDefaultPreview?: boolean;
+    children: ReactNode | ((props: TreeSortableItemRenderProps) => ReactNode);
+}
+export interface TreeItem<T = unknown> {
+    id: string | number;
+    children?: T[];
+    folders?: T[];
+}
+export interface UseTreeDropValidationOptions<T extends TreeItem<T>> {
+    items: T[];
+    childrenKey?: 'children' | 'folders';
+}
+export declare const DROP_ACTIONS: {
+    readonly MOVE: "move";
+    readonly DUPLICATE: "duplicate";
+    readonly CANCEL: "cancel";
+};
+export type DropAction = (typeof DROP_ACTIONS)[keyof typeof DROP_ACTIONS];
+export interface PendingDropInfo {
+    draggedItem: TreeDragItem;
+    targetId: string | number;
+    position: TreeDropPosition;
+}
+export type DropConfirmationLabels = Partial<Record<DropAction, string>>;
+export interface TreeSortableContainerProps {
+    children: ReactNode;
+    showDropConfirmation?: boolean;
+    confirmationLabels?: DropConfirmationLabels;
+    portalTarget?: Element | null;
+    onMove?: TreeDropHandler;
+    onDuplicate?: TreeDropHandler;
+    onCancel?: () => void;
+}

package/dist/common/utils/floatingUi.d.ts

@@ -0,0 +1,3 @@
+import { Placement, ElementRects } from '@floating-ui/react';
+
+export declare const getAlignmentAxisOffset: (rects: ElementRects, currentPlacement: Placement, arrowOffset?: number, isCentered?: boolean) => number;

package/dist/common/utils/getFileExtension.d.ts

@@ -0,0 +1 @@
+export declare const getFileExtension: (fileName: string) => string;

package/dist/common/utils/htmlAttributes.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Splits object properties into HTML attributes and remaining props.
+ * Transforms camelCase data-* and aria-* attributes to kebab-case format
+ * as required by HTML specification.
+ *
+ * @param attrs - Object containing properties to split
+ * @returns Object with two properties:
+ *   - transformed: data-* and aria-* attributes converted to kebab-case
+ *   - remaining: all other properties unchanged
+ *
+ * @example
+ * const props = { dataTestId: 'test', ariaLabel: 'Label', className: 'container' };
+ * const { transformed, remaining } = splitHtmlAttributes(props);
+ * // transformed: { 'data-test-id': 'test', 'aria-label': 'Label' }
+ * // remaining: { className: 'container' }
+ */
+export declare const splitHtmlAttributes: (attrs: Record<string, unknown>) => {
+    transformed: Record<string, unknown>;
+    remaining: Record<string, unknown>;
+};

package/dist/common/utils/index.d.ts

@@ -0,0 +1,4 @@
+export { getFileExtension } from './getFileExtension';
+export { isString } from './isString';
+export { getAlignmentAxisOffset } from './floatingUi';
+export { splitHtmlAttributes } from './htmlAttributes';

package/dist/common/utils/isString.d.ts

@@ -0,0 +1 @@
+export declare const isString: (value: unknown) => value is string;

package/dist/common/utils/testUtils.d.ts

@@ -0,0 +1,3 @@
+import { ReactElement } from 'react';
+
+export declare const renderWithDnd: (ui: ReactElement) => import('@testing-library/react').RenderResult<typeof import("@testing-library/dom/types/queries"), HTMLElement, HTMLElement>;

package/dist/common.js

@@ -0,0 +1,21 @@
+const O = {
+  TOP: "top",
+  BOTTOM: "bottom"
+}, E = {
+  INDEX_BASED: "indexBased",
+  HOVER: "hover"
+}, e = {
+  BEFORE: "before",
+  INSIDE: "inside",
+  AFTER: "after"
+}, o = {
+  MOVE: "move",
+  DUPLICATE: "duplicate",
+  CANCEL: "cancel"
+};
+export {
+  o as DROP_ACTIONS,
+  E as DROP_DETECTION_MODE,
+  O as DROP_POSITIONS,
+  e as TREE_DROP_POSITIONS
+};

package/dist/components/actionMenu/actionMenu.d.ts

@@ -0,0 +1,33 @@
+import { ReactNode, MouseEvent, ReactElement } from 'react';
+import { PopoverProps } from '../popover/popover';
+
+export interface ActionItem {
+    id?: string;
+    label: string;
+    onClick?: (event?: MouseEvent<HTMLButtonElement>) => void;
+    hasPermission?: boolean;
+    disabled?: boolean;
+    className?: string;
+}
+export interface DividerItem {
+    type: 'divider';
+}
+export type MenuItem = ActionItem | DividerItem | ReactNode;
+export declare const ActionMenuItem: ({ className, children, ...props }: {
+    [key: string]: unknown;
+    className?: string | undefined;
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export interface ActionMenuProps extends Pick<PopoverProps, 'placement'> {
+    items?: MenuItem[];
+    cleanupDividers?: boolean;
+    className?: string;
+    contentClassName?: string;
+    buttonClassName?: string;
+    popoverClassName?: string;
+    menuClassName?: string;
+    ariaLabel?: string;
+    trigger?: ReactNode;
+    disabled?: boolean;
+}
+export declare const ActionMenu: ({ placement, items, cleanupDividers, className, contentClassName, buttonClassName, popoverClassName, menuClassName, ariaLabel, trigger, disabled, }: ActionMenuProps) => ReactElement | null;

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

@@ -0,0 +1,3 @@
+import { DividerItem } from './actionMenu';
+
+export declare const ACTION_MENU_DIVIDER: DividerItem;

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

@@ -0,0 +1,18 @@
+/*!
+ * Copyright 2026 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 { ActionMenu, ActionMenuItem } from './actionMenu';
+export { ACTION_MENU_DIVIDER } from './constants';
+export type { ActionMenuProps, ActionItem, DividerItem, MenuItem } from './actionMenu';

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,14 @@
+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;
+}
+export declare const AttachedFile: ({ fileName, size, uploadingProgress, isUploadFailed, uploadFailedMessage, isUploading, isFullWidth, onDownload, onRemove, }: 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,10 @@
+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;
+} & 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,19 @@
+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;
+}
+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';