@cloudscape-design/components 3.0.1012 → 3.0.1014

package/internal/components/panel-resize-handle/index.d.ts

@@ -1,15 +1,14 @@
 import React from 'react';
 import { DragHandleProps } from '../drag-handle';
 interface ResizeHandleProps {
-    className?: string;
-    ariaLabel: string | undefined;
-    tooltipText?: string | undefined;
-    position: 'side' | 'bottom';
-    ariaValuenow: number;
-    onDirectionClick: DragHandleProps['onDirectionClick'];
-    onKeyDown: (event: React.KeyboardEvent<HTMLElement>) => void;
-    onPointerDown: (event: React.PointerEvent<HTMLElement>) => void;
+  className?: string;
+  ariaLabel: string | undefined;
+  tooltipText?: string | undefined;
+  position: 'side' | 'bottom';
+  ariaValuenow: number;
+  onDirectionClick: DragHandleProps['onDirectionClick'];
+  onKeyDown: (event: React.KeyboardEvent<HTMLElement>) => void;
+  onPointerDown: (event: React.PointerEvent<HTMLElement>) => void;
 }
 declare const _default: React.ForwardRefExoticComponent<ResizeHandleProps & React.RefAttributes<HTMLDivElement>>;
-export default _default;
-//# sourceMappingURL=index.d.ts.map
+export default _default;

package/internal/components/responsive-text/index.d.ts

@@ -1,13 +1,18 @@
 import React from 'react';
 interface ResponsiveTextProps {
-    x: number;
-    y: number;
-    className?: string;
-    children: string;
-    maxWidth: number;
+  x: number;
+  y: number;
+  className?: string;
+  children: string;
+  maxWidth: number;
 }
 declare const _default: React.MemoExoticComponent<typeof ResponsiveText>;
 export default _default;
-declare function ResponsiveText({ x, y, className, children, maxWidth }: ResponsiveTextProps): JSX.Element;
-export declare function renderTextContent(textNode: SVGTextElement, text: string, maxWidth: number, isRtl: boolean): void;
-//# sourceMappingURL=index.d.ts.map
+declare function ResponsiveText({
+  x,
+  y,
+  className,
+  children,
+  maxWidth
+}: ResponsiveTextProps): JSX.Element;
+export declare function renderTextContent(textNode: SVGTextElement, text: string, maxWidth: number, isRtl: boolean): void;

package/internal/components/responsive-text/responsive-text-utils.d.ts

@@ -1,2 +1 @@
-export declare function getTextWidth(textNode: SVGTextElement): number;
-//# sourceMappingURL=responsive-text-utils.d.ts.map
+export declare function getTextWidth(textNode: SVGTextElement): number;

package/internal/components/screenreader-only/index.d.ts

@@ -1,8 +1,8 @@
 import React from 'react';
 interface ScreenreaderOnlyProps {
-    id?: string;
-    className?: string;
-    children?: React.ReactNode;
+  id?: string;
+  className?: string;
+  children?: React.ReactNode;
 }
 /**
  * Makes content now shown on a screen but still announced by screen-reader users.
@@ -19,5 +19,4 @@ interface ScreenreaderOnlyProps {
  * ```
  */
 export default function ScreenreaderOnly(props: ScreenreaderOnlyProps): JSX.Element;
-export {};
-//# sourceMappingURL=index.d.ts.map
+export {};

package/internal/components/selectable-item/analytics-metadata/interfaces.d.ts

@@ -1,11 +1,10 @@
 import { LabelIdentifier } from '@cloudscape-design/component-toolkit/internal/analytics-metadata';
 export interface GeneratedAnalyticsMetadataSelectableItemSelect {
-    action: 'select';
-    detail: {
-        label: string | LabelIdentifier;
-        position?: string;
-        value?: string;
-        groupLabel?: string | LabelIdentifier;
-    };
-}
-//# sourceMappingURL=interfaces.d.ts.map
+  action: 'select';
+  detail: {
+    label: string | LabelIdentifier;
+    position?: string;
+    value?: string;
+    groupLabel?: string | LabelIdentifier;
+  };
+}

package/internal/components/selectable-item/analytics-metadata/utils.d.ts

@@ -1,4 +1,7 @@
 import { SelectableItemProps } from '../interfaces';
 import { GeneratedAnalyticsMetadataSelectableItemSelect } from './interfaces';
-export declare const getAnalyticsSelectActionMetadata: ({ isChild, value, ...restProps }: Partial<SelectableItemProps>) => GeneratedAnalyticsMetadataSelectableItemSelect;
-//# sourceMappingURL=utils.d.ts.map
+export declare const getAnalyticsSelectActionMetadata: ({
+  isChild,
+  value,
+  ...restProps
+}: Partial<SelectableItemProps>) => GeneratedAnalyticsMetadataSelectableItemSelect;

package/internal/components/selectable-item/index.d.ts

@@ -2,5 +2,4 @@ import React from 'react';
 import { SelectableItemProps } from './interfaces';
 export { SelectableItemProps };
 declare const _default: React.ForwardRefExoticComponent<SelectableItemProps & React.RefAttributes<HTMLDivElement>>;
-export default _default;
-//# sourceMappingURL=index.d.ts.map
+export default _default;

package/internal/components/selectable-item/interfaces.d.ts

@@ -2,38 +2,37 @@
 import { BaseComponentProps } from '../../base-component';
 import { HighlightType } from '../options-list/utils/use-highlight-option';
 export type SelectableItemProps = BaseComponentProps & {
-    children: React.ReactNode;
-    selected?: boolean;
-    highlighted?: boolean;
-    disabled?: boolean;
-    hasBackground?: boolean;
-    isParent?: boolean;
-    isChild?: boolean;
-    isSelectAll?: boolean;
-    virtualPosition?: number;
-    padBottom?: boolean;
-    isNextSelected?: boolean;
-    useInteractiveGroups?: boolean;
-    screenReaderContent?: string;
-    ariaPosinset?: number;
-    ariaSetsize?: number;
-    highlightType?: HighlightType['type'];
-    ariaDescribedby?: string;
-    value?: string;
-    sticky?: boolean;
-    afterHeader?: boolean;
-    withScrollbar?: boolean;
+  children: React.ReactNode;
+  selected?: boolean;
+  highlighted?: boolean;
+  disabled?: boolean;
+  hasBackground?: boolean;
+  isParent?: boolean;
+  isChild?: boolean;
+  isSelectAll?: boolean;
+  virtualPosition?: number;
+  padBottom?: boolean;
+  isNextSelected?: boolean;
+  useInteractiveGroups?: boolean;
+  screenReaderContent?: string;
+  ariaPosinset?: number;
+  ariaSetsize?: number;
+  highlightType?: HighlightType['type'];
+  ariaDescribedby?: string;
+  value?: string;
+  sticky?: boolean;
+  afterHeader?: boolean;
+  withScrollbar?: boolean;
 } & ({
-    ariaSelected?: boolean;
-    ariaChecked?: never;
+  ariaSelected?: boolean;
+  ariaChecked?: never;
 } | {
-    ariaSelected?: never;
-    ariaChecked?: boolean | 'mixed';
+  ariaSelected?: never;
+  ariaChecked?: boolean | 'mixed';
 });
 export interface ItemDataAttributes {
-    'data-group-index'?: string;
-    'data-child-index'?: string;
-    'data-in-group-index'?: string;
-    'data-test-index'?: string;
-}
-//# sourceMappingURL=interfaces.d.ts.map
+  'data-group-index'?: string;
+  'data-child-index'?: string;
+  'data-in-group-index'?: string;
+  'data-test-index'?: string;
+}

package/internal/components/sortable-area/index.d.ts

@@ -1,6 +1,12 @@
 /// <reference types="react" />
 import { SortableAreaProps } from './interfaces';
 export { SortableAreaProps };
-export default function SortableArea<Item>({ items, itemDefinition, renderItem, onItemsChange, disableReorder, i18nStrings, }: SortableAreaProps<Item>): JSX.Element;
-export declare function getBorderRadiusVariant(itemDefinition: SortableAreaProps.ItemDefinition<any>): SortableAreaProps.BorderRadiusVariant;
-//# sourceMappingURL=index.d.ts.map
+export default function SortableArea<Item>({
+  items,
+  itemDefinition,
+  renderItem,
+  onItemsChange,
+  disableReorder,
+  i18nStrings
+}: SortableAreaProps<Item>): JSX.Element;
+export declare function getBorderRadiusVariant(itemDefinition: SortableAreaProps.ItemDefinition<any>): SortableAreaProps.BorderRadiusVariant;

package/internal/components/sortable-area/interfaces.d.ts

@@ -2,41 +2,40 @@
 import { NonCancelableEventHandler } from '../../events';
 import { DragHandleProps } from '../drag-handle/interfaces';
 export interface SortableAreaProps<Item> {
-    items: readonly Item[];
-    itemDefinition: SortableAreaProps.ItemDefinition<Item>;
-    renderItem: (props: SortableAreaProps.RenderItemProps<Item>) => React.ReactNode;
-    onItemsChange?: NonCancelableEventHandler<SortableAreaProps.ItemsChangeDetail<Item>>;
-    i18nStrings?: SortableAreaProps.DndAreaI18nStrings;
-    disableReorder?: boolean;
+  items: readonly Item[];
+  itemDefinition: SortableAreaProps.ItemDefinition<Item>;
+  renderItem: (props: SortableAreaProps.RenderItemProps<Item>) => React.ReactNode;
+  onItemsChange?: NonCancelableEventHandler<SortableAreaProps.ItemsChangeDetail<Item>>;
+  i18nStrings?: SortableAreaProps.DndAreaI18nStrings;
+  disableReorder?: boolean;
 }
 export declare namespace SortableAreaProps {
-    interface ItemDefinition<Item> {
-        id: (item: Item) => string;
-        label: (item: Item) => string;
-        borderRadius?: BorderRadiusVariant;
-    }
-    type BorderRadiusVariant = 'item' | 'container';
-    interface RenderItemProps<Item> {
-        ref?: React.RefCallback<HTMLElement>;
-        item: Item;
-        style: React.CSSProperties;
-        className?: string;
-        isDropPlaceholder: boolean;
-        isSortingActive: boolean;
-        isDragGhost: boolean;
-        dragHandleProps: DragHandleProps;
-    }
-    interface ItemsChangeDetail<Item> {
-        items: Item[];
-        movedItem: Item;
-    }
-    interface DndAreaI18nStrings {
-        liveAnnouncementDndStarted?: (position: number, total: number) => string;
-        liveAnnouncementDndItemReordered?: (initialPosition: number, currentPosition: number, total: number) => string;
-        liveAnnouncementDndItemCommitted?: (initialPosition: number, finalPosition: number, total: number) => string;
-        liveAnnouncementDndDiscarded?: string;
-        dragHandleAriaLabel?: string;
-        dragHandleAriaDescription?: string;
-    }
-}
-//# sourceMappingURL=interfaces.d.ts.map
+  interface ItemDefinition<Item> {
+    id: (item: Item) => string;
+    label: (item: Item) => string;
+    borderRadius?: BorderRadiusVariant;
+  }
+  type BorderRadiusVariant = 'item' | 'container';
+  interface RenderItemProps<Item> {
+    ref?: React.RefCallback<HTMLElement>;
+    item: Item;
+    style: React.CSSProperties;
+    className?: string;
+    isDropPlaceholder: boolean;
+    isSortingActive: boolean;
+    isDragGhost: boolean;
+    dragHandleProps: DragHandleProps;
+  }
+  interface ItemsChangeDetail<Item> {
+    items: Item[];
+    movedItem: Item;
+  }
+  interface DndAreaI18nStrings {
+    liveAnnouncementDndStarted?: (position: number, total: number) => string;
+    liveAnnouncementDndItemReordered?: (initialPosition: number, currentPosition: number, total: number) => string;
+    liveAnnouncementDndItemCommitted?: (initialPosition: number, finalPosition: number, total: number) => string;
+    liveAnnouncementDndDiscarded?: string;
+    dragHandleAriaLabel?: string;
+    dragHandleAriaDescription?: string;
+  }
+}

package/internal/components/sortable-area/keyboard-sensor/defaults.d.ts

@@ -1,3 +1,2 @@
 import { KeyboardCodes } from '@dnd-kit/core';
-export declare const defaultKeyboardCodes: KeyboardCodes;
-//# sourceMappingURL=defaults.d.ts.map
+export declare const defaultKeyboardCodes: KeyboardCodes;

package/internal/components/sortable-area/keyboard-sensor/index.d.ts

@@ -1,19 +1,18 @@
 import type { Activators, SensorInstance } from '@dnd-kit/core';
 import { KeyboardSensorOptions, KeyboardSensorProps } from '@dnd-kit/core';
 export declare class KeyboardSensor implements SensorInstance {
-    private props;
-    autoScrollEnabled: boolean;
-    private referenceCoordinates;
-    private listeners;
-    private windowListeners;
-    constructor(props: KeyboardSensorProps);
-    private attach;
-    private handleStart;
-    private handleKeyDown;
-    private handleMove;
-    private handleEnd;
-    private handleCancel;
-    private detach;
-    static activators: Activators<KeyboardSensorOptions>;
-}
-//# sourceMappingURL=index.d.ts.map
+  private props;
+  autoScrollEnabled: boolean;
+  private referenceCoordinates;
+  private listeners;
+  private windowListeners;
+  constructor(props: KeyboardSensorProps);
+  private attach;
+  private handleStart;
+  private handleKeyDown;
+  private handleMove;
+  private handleEnd;
+  private handleCancel;
+  private detach;
+  static activators: Activators<KeyboardSensorOptions>;
+}

package/internal/components/sortable-area/keyboard-sensor/utilities/events.d.ts

@@ -1,7 +1,6 @@
 export declare enum EventName {
-    Blur = "blur",
-    Keydown = "keydown",
-    Resize = "resize",
-    VisibilityChange = "visibilitychange"
-}
-//# sourceMappingURL=events.d.ts.map
+  Blur = "blur",
+  Keydown = "keydown",
+  Resize = "resize",
+  VisibilityChange = "visibilitychange",
+}

package/internal/components/sortable-area/keyboard-sensor/utilities/listeners.d.ts

@@ -1,8 +1,7 @@
 export declare class Listeners {
-    private target;
-    private listeners;
-    constructor(target: EventTarget | null);
-    add<T extends Event>(eventName: string, handler: (event: T) => void, options?: AddEventListenerOptions | boolean): void;
-    removeAll: () => void;
-}
-//# sourceMappingURL=listeners.d.ts.map
+  private target;
+  private listeners;
+  constructor(target: EventTarget | null);
+  add<T extends Event>(eventName: string, handler: (event: T) => void, options?: AddEventListenerOptions | boolean): void;
+  removeAll: () => void;
+}

package/internal/components/sortable-area/keyboard-sensor/utilities/scroll.d.ts

@@ -1,8 +1,12 @@
 import { Coordinates } from '@dnd-kit/utilities';
-export declare function applyScroll({ currentCoordinates, direction, newCoordinates, scrollableAncestors, }: {
-    currentCoordinates: Coordinates;
-    direction: string;
-    newCoordinates: Coordinates;
-    scrollableAncestors: Element[];
-}): boolean;
-//# sourceMappingURL=scroll.d.ts.map
+export declare function applyScroll({
+  currentCoordinates,
+  direction,
+  newCoordinates,
+  scrollableAncestors
+}: {
+  currentCoordinates: Coordinates;
+  direction: string;
+  newCoordinates: Coordinates;
+  scrollableAncestors: Element[];
+}): boolean;

package/internal/components/sortable-area/use-drag-and-drop-reorder.d.ts

@@ -1,15 +1,17 @@
 import React from 'react';
 import { CollisionDetection, KeyboardCoordinateGetter, UniqueIdentifier } from '@dnd-kit/core';
 import { SortableAreaProps } from './interfaces';
-export default function useDragAndDropReorder<Item>({ items, itemDefinition, }: {
-    items: readonly Item[];
-    itemDefinition: SortableAreaProps.ItemDefinition<Item>;
+export default function useDragAndDropReorder<Item>({
+  items,
+  itemDefinition
+}: {
+  items: readonly Item[];
+  itemDefinition: SortableAreaProps.ItemDefinition<Item>;
 }): {
-    activeItemId: UniqueIdentifier | null;
-    setActiveItemId: (id: UniqueIdentifier | null) => void;
-    collisionDetection: CollisionDetection;
-    coordinateGetter: KeyboardCoordinateGetter;
-    handleKeyDown: (event: React.KeyboardEvent) => void;
-    sensors: import("@dnd-kit/core").SensorDescriptor<import("@dnd-kit/core").SensorOptions>[];
-};
-//# sourceMappingURL=use-drag-and-drop-reorder.d.ts.map
+  activeItemId: UniqueIdentifier | null;
+  setActiveItemId: (id: UniqueIdentifier | null) => void;
+  collisionDetection: CollisionDetection;
+  coordinateGetter: KeyboardCoordinateGetter;
+  handleKeyDown: (event: React.KeyboardEvent) => void;
+  sensors: import("@dnd-kit/core").SensorDescriptor<import("@dnd-kit/core").SensorOptions>[];
+};

package/internal/components/sortable-area/use-live-announcements.d.ts

@@ -1,13 +1,28 @@
 import { DragEndEvent, DragOverEvent, DragStartEvent } from '@dnd-kit/core';
 import { SortableAreaProps } from './interfaces';
-export default function useLiveAnnouncements<Item>({ items, itemDefinition, isDragging, liveAnnouncementDndStarted, liveAnnouncementDndItemReordered, liveAnnouncementDndItemCommitted, liveAnnouncementDndDiscarded, }: {
-    items: readonly Item[];
-    itemDefinition: SortableAreaProps.ItemDefinition<Item>;
-    isDragging: boolean;
+export default function useLiveAnnouncements<Item>({
+  items,
+  itemDefinition,
+  isDragging,
+  liveAnnouncementDndStarted,
+  liveAnnouncementDndItemReordered,
+  liveAnnouncementDndItemCommitted,
+  liveAnnouncementDndDiscarded
+}: {
+  items: readonly Item[];
+  itemDefinition: SortableAreaProps.ItemDefinition<Item>;
+  isDragging: boolean;
 } & SortableAreaProps.DndAreaI18nStrings): {
-    onDragStart({ active }: DragStartEvent): string | undefined;
-    onDragOver({ active, over }: DragOverEvent): string | undefined;
-    onDragEnd({ active, over }: DragEndEvent): string | undefined;
-    onDragCancel(): string | undefined;
-};
-//# sourceMappingURL=use-live-announcements.d.ts.map
+  onDragStart({
+    active
+  }: DragStartEvent): string | undefined;
+  onDragOver({
+    active,
+    over
+  }: DragOverEvent): string | undefined;
+  onDragEnd({
+    active,
+    over
+  }: DragEndEvent): string | undefined;
+  onDragCancel(): string | undefined;
+};

package/internal/components/tab-trap/index.d.ts

@@ -1,13 +1,15 @@
 import React from 'react';
 interface TabTrapProps {
-    focusNextCallback: (event: React.FocusEvent) => void;
-    disabled?: boolean;
+  focusNextCallback: (event: React.FocusEvent) => void;
+  disabled?: boolean;
 }
 /**
  * This component handles focus-forwarding when using keyboard tab navigation.
  * When the user focuses this component, the `focusNextCallback` function is called
  * which can forward the focus to another element.
  */
-export default function TabTrap({ focusNextCallback, disabled }: TabTrapProps): JSX.Element;
-export {};
-//# sourceMappingURL=index.d.ts.map
+export default function TabTrap({
+  focusNextCallback,
+  disabled
+}: TabTrapProps): JSX.Element;
+export {};

package/internal/components/token-list/analytics-metadata/interfaces.d.ts

@@ -1,14 +1,13 @@
 import { LabelIdentifier } from '@cloudscape-design/component-toolkit/internal/analytics-metadata';
 export interface GeneratedAnalyticsMetadataTokenListShowMore {
-    action: 'showMore';
-    detail: {
-        label: string | LabelIdentifier;
-    };
+  action: 'showMore';
+  detail: {
+    label: string | LabelIdentifier;
+  };
 }
 export interface GeneratedAnalyticsMetadataTokenListShowLess {
-    action: 'showLess';
-    detail: {
-        label: string | LabelIdentifier;
-    };
-}
-//# sourceMappingURL=interfaces.d.ts.map
+  action: 'showLess';
+  detail: {
+    label: string | LabelIdentifier;
+  };
+}

package/internal/components/token-list/index.d.ts

@@ -1,5 +1,14 @@
 /// <reference types="react" />
 import { TokenListProps } from './interfaces';
 export { TokenListProps };
-export default function TokenList<Item>({ items, alignment, renderItem, limit, after, i18nStrings, limitShowFewerAriaLabel, limitShowMoreAriaLabel, onExpandedClick, }: TokenListProps<Item>): JSX.Element;
-//# sourceMappingURL=index.d.ts.map
+export default function TokenList<Item>({
+  items,
+  alignment,
+  renderItem,
+  limit,
+  after,
+  i18nStrings,
+  limitShowFewerAriaLabel,
+  limitShowMoreAriaLabel,
+  onExpandedClick
+}: TokenListProps<Item>): JSX.Element;

package/internal/components/token-list/interfaces.d.ts

@@ -1,17 +1,16 @@
 import React from 'react';
 export interface TokenListProps<Item> {
-    alignment: 'vertical' | 'horizontal' | 'inline' | 'horizontal-grid';
-    items: readonly Item[];
-    limit?: number;
-    after?: React.ReactNode;
-    renderItem: (item: Item, itemIndex: number) => React.ReactNode;
-    i18nStrings?: I18nStrings;
-    onExpandedClick?: (isExpanded: boolean) => void;
-    limitShowFewerAriaLabel?: string;
-    limitShowMoreAriaLabel?: string;
+  alignment: 'vertical' | 'horizontal' | 'inline' | 'horizontal-grid';
+  items: readonly Item[];
+  limit?: number;
+  after?: React.ReactNode;
+  renderItem: (item: Item, itemIndex: number) => React.ReactNode;
+  i18nStrings?: I18nStrings;
+  onExpandedClick?: (isExpanded: boolean) => void;
+  limitShowFewerAriaLabel?: string;
+  limitShowMoreAriaLabel?: string;
 }
 export interface I18nStrings {
-    limitShowFewer?: string;
-    limitShowMore?: string;
-}
-//# sourceMappingURL=interfaces.d.ts.map
+  limitShowFewer?: string;
+  limitShowMore?: string;
+}

package/internal/components/token-list/token-limit-toggle.d.ts

@@ -2,15 +2,23 @@
 import { NonCancelableEventHandler } from '../../events';
 import { I18nStrings } from './interfaces';
 interface TokenLimitToggleProps {
-    controlId?: string;
-    allHidden: boolean;
-    expanded: boolean;
-    numberOfHiddenOptions: number;
-    onClick?: NonCancelableEventHandler<null>;
-    i18nStrings?: I18nStrings;
-    limitShowFewerAriaLabel?: string;
-    limitShowMoreAriaLabel?: string;
+  controlId?: string;
+  allHidden: boolean;
+  expanded: boolean;
+  numberOfHiddenOptions: number;
+  onClick?: NonCancelableEventHandler<null>;
+  i18nStrings?: I18nStrings;
+  limitShowFewerAriaLabel?: string;
+  limitShowMoreAriaLabel?: string;
 }
-export default function TokenLimitToggle({ controlId, allHidden, expanded, numberOfHiddenOptions, onClick, i18nStrings, limitShowFewerAriaLabel, limitShowMoreAriaLabel, }: TokenLimitToggleProps): JSX.Element;
-export {};
-//# sourceMappingURL=token-limit-toggle.d.ts.map
+export default function TokenLimitToggle({
+  controlId,
+  allHidden,
+  expanded,
+  numberOfHiddenOptions,
+  onClick,
+  i18nStrings,
+  limitShowFewerAriaLabel,
+  limitShowMoreAriaLabel
+}: TokenLimitToggleProps): JSX.Element;
+export {};

package/internal/components/tooltip/index.d.ts

@@ -1,15 +1,24 @@
 import React from 'react';
 import { PopoverProps } from '../../../popover/interfaces';
 export interface TooltipProps {
-    value: React.ReactNode;
-    trackRef: React.RefObject<HTMLElement | SVGElement>;
-    trackKey?: string | number;
-    position?: 'top' | 'right' | 'bottom' | 'left';
-    className?: string;
-    contentAttributes?: React.HTMLAttributes<HTMLDivElement>;
-    size?: PopoverProps['size'];
-    hideOnOverscroll?: boolean;
-    onDismiss?: () => void;
+  value: React.ReactNode;
+  trackRef: React.RefObject<HTMLElement | SVGElement>;
+  trackKey?: string | number;
+  position?: 'top' | 'right' | 'bottom' | 'left';
+  className?: string;
+  contentAttributes?: React.HTMLAttributes<HTMLDivElement>;
+  size?: PopoverProps['size'];
+  hideOnOverscroll?: boolean;
+  onDismiss?: () => void;
 }
-export default function Tooltip({ value, trackRef, trackKey, className, contentAttributes, position, size, hideOnOverscroll, onDismiss, }: TooltipProps): JSX.Element;
-//# sourceMappingURL=index.d.ts.map
+export default function Tooltip({
+  value,
+  trackRef,
+  trackKey,
+  className,
+  contentAttributes,
+  position,
+  size,
+  hideOnOverscroll,
+  onDismiss
+}: TooltipProps): JSX.Element;