storybook/dist/components/index.d.ts

Storybook: Develop, document, and test UI components in isolation

import { r as StyledComponent } from "../chunk-CSYKg21N.js";
import { DecoratorFunction } from "storybook/internal/csf";
import * as React$2 from "react";
import React$1, { AnchorHTMLAttributes, ButtonHTMLAttributes, Component, ComponentProps, DOMAttributes, ElementType, FC, ForwardRefExoticComponent, HTMLAttributes, MouseEvent as MouseEvent$1, PropsWithChildren, ReactElement, ReactNode, RefAttributes, RefObject, SelectHTMLAttributes, SyntheticEvent } from "react";
import { Addon_RenderOptions } from "storybook/internal/types";
import { CSSObject, FunctionInterpolation, StorybookTheme } from "storybook/theming";
import { API_KeyCollection } from "storybook/manager-api";

//#region code/core/.dts-emit/code/core/src/components/components/typography/elements/A.d.ts
declare const A: StyledComponent<import("react").AnchorHTMLAttributes<HTMLAnchorElement> & {
  theme?: import("storybook/theming").Theme;
}, {}, {}>;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/typography/elements/Blockquote.d.ts
declare const Blockquote: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React.ElementType;
}, import("react").DetailedHTMLProps<import("react").BlockquoteHTMLAttributes<HTMLQuoteElement>, HTMLQuoteElement>, {}>;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/typography/elements/Code.d.ts
declare const DefaultCodeBlock: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React$1.ElementType;
}, React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement>, {}>;
declare const Code: ({
  className,
  children,
  ...props
}: ComponentProps<typeof DefaultCodeBlock>) => React$1.JSX.Element;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/typography/elements/Div.d.ts
declare const Div: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React.ElementType;
}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/typography/elements/DL.d.ts
declare const DL: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React.ElementType;
}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDListElement>, HTMLDListElement>, {}>;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/typography/elements/H1.d.ts
declare const H1: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React.ElementType;
}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, {}>;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/typography/elements/H2.d.ts
declare const H2: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React.ElementType;
}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, {}>;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/typography/elements/H3.d.ts
declare const H3: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React.ElementType;
}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, {}>;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/typography/elements/H4.d.ts
declare const H4: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React.ElementType;
}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, {}>;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/typography/elements/H5.d.ts
declare const H5: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React.ElementType;
}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, {}>;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/typography/elements/H6.d.ts
declare const H6: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React.ElementType;
}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, {}>;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/typography/elements/HR.d.ts
declare const HR: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React.ElementType;
}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHRElement>, HTMLHRElement>, {}>;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/typography/elements/Img.d.ts
declare const Img: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React.ElementType;
}, import("react").DetailedHTMLProps<import("react").ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, {}>;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/typography/elements/LI.d.ts
declare const LI: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React.ElementType;
}, import("react").DetailedHTMLProps<import("react").LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, {}>;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/typography/elements/OL.d.ts
declare const OL: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React.ElementType;
}, import("react").DetailedHTMLProps<import("react").OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>, {}>;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/typography/elements/P.d.ts
declare const P: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React.ElementType;
}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, {}>;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/typography/elements/Pre.d.ts
declare const Pre: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React.ElementType;
}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLPreElement>, HTMLPreElement>, {}>;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/typography/elements/Span.d.ts
declare const Span: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React.ElementType;
}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, {}>;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/typography/elements/Table.d.ts
declare const Table: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React.ElementType;
}, import("react").DetailedHTMLProps<import("react").TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>, {}>;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/typography/elements/TT.d.ts
declare const TT: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React.ElementType;
}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLTitleElement>, HTMLTitleElement>, {}>;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/typography/elements/UL.d.ts
declare const UL: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React.ElementType;
}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLUListElement>, HTMLUListElement>, {}>;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/Badge/Badge.d.ts
interface BadgeProps {
  compact?: boolean;
  status?: 'positive' | 'negative' | 'neutral' | 'warning' | 'critical' | 'active';
  children?: React$1.ReactNode;
}
declare const Badge: ({
  ...props
}: BadgeProps) => React$1.JSX.Element;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/typography/link/link.d.ts
interface LinkStylesProps {
  secondary?: boolean;
  tertiary?: boolean;
  nochrome?: boolean;
  inverse?: boolean;
  isButton?: boolean;
}
interface LinkInnerProps {
  withArrow?: boolean;
  containsIcon?: boolean;
}
type AProps = AnchorHTMLAttributes<HTMLAnchorElement>;
interface LinkProps extends LinkInnerProps, LinkStylesProps, AProps {
  cancel?: boolean;
  className?: string;
  style?: object;
  onClick?: (e: MouseEvent$1) => void;
  href?: string;
}
declare const Link: React$1.ForwardRefExoticComponent<LinkProps & React$1.RefAttributes<HTMLAnchorElement>>;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/typography/DocumentWrapper.d.ts
declare const DocumentWrapper: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React.ElementType;
}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/syntaxhighlighter/syntaxhighlighter.d.ts
declare const supportedLanguages: {
  jsextra: any;
  jsx: any;
  json: any;
  yml: any;
  md: any;
  bash: any;
  css: any;
  html: any;
  tsx: any;
  typescript: any;
  graphql: any;
};
declare function SyntaxHighlighter$1({
  children,
  language,
  copyable,
  bordered,
  padded,
  format,
  formatter,
  className,
  showLineNumbers,
  ...rest
}: SyntaxHighlighterProps): React$1.JSX.Element | null;
declare namespace SyntaxHighlighter$1 {
  var registerLanguage: (name: string, func: any) => void;
}
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/syntaxhighlighter/syntaxhighlighter-types.d.ts
interface SyntaxHighlighterRendererProps {
  rows: any[];
  stylesheet: string;
  useInlineStyles: boolean;
}
type SyntaxHighlighterRenderer = (props: SyntaxHighlighterRendererProps) => ReactNode;
interface SyntaxHighlighterCustomProps {
  language: string;
  copyable?: boolean;
  bordered?: boolean;
  padded?: boolean;
  format?: SyntaxHighlighterFormatTypes;
  formatter?: (type: SyntaxHighlighterFormatTypes, source: string) => Promise<string>;
  className?: string;
  renderer?: SyntaxHighlighterRenderer;
}
type SyntaxHighlighterFormatTypes = boolean | 'dedent';
type LineTagPropsFunction = (lineNumber: number) => React.HTMLProps<HTMLElement>;
type SupportedLanguage = 'text' | keyof typeof supportedLanguages;
interface SyntaxHighlighterBaseProps {
  children?: React.ReactNode;
  codeTagProps?: React.HTMLProps<HTMLElement>;
  customStyle?: any;
  language?: SupportedLanguage;
  lineNumberStyle?: any;
  lineProps?: LineTagPropsFunction | React.HTMLProps<HTMLElement>;
  showLineNumbers?: boolean;
  startingLineNumber?: number;
  wrapLongLines?: boolean;
  style?: any;
  useInlineStyles?: boolean;
}
type SyntaxHighlighterProps = SyntaxHighlighterBaseProps & SyntaxHighlighterCustomProps;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/syntaxhighlighter/lazy-syntaxhighlighter.d.ts
declare const LazySyntaxHighlighter: React$1.LazyExoticComponent<(props: ComponentProps<typeof SyntaxHighlighter$1>) => React$1.JSX.Element>;
declare const LazySyntaxHighlighterWithFormatter: React$1.LazyExoticComponent<(props: ComponentProps<typeof SyntaxHighlighter$1>) => React$1.JSX.Element>;
declare function SyntaxHighlighter(props: ComponentProps<typeof LazySyntaxHighlighter> | ComponentProps<typeof LazySyntaxHighlighterWithFormatter>): React$1.JSX.Element;
declare namespace SyntaxHighlighter {
  var registerLanguage: (name: string, func: any) => void;
}
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/syntaxhighlighter/clipboard.d.ts
declare function copyUsingClipboardAPI(text: string): Promise<void>;
declare function createCopyToClipboardFunction(): typeof copyUsingClipboardAPI;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/ActionBar/ActionBar.d.ts
interface ActionItem {
  title: string | ReactElement;
  ariaLabel?: string;
  className?: string;
  onClick: (e: MouseEvent$1<HTMLButtonElement>) => void;
  disabled?: boolean;
}
interface ActionBarProps {
  /** Items to render in this ActionBar. */
  actionItems: ActionItem[];
  /**
   * When true, ActionBar aligns to the flex end and inline end of a wrapping row flex container.
   * When false, ActionBar is positioned absolutely at the bottom right of its relative parent.
   */
  flexLayout?: boolean;
}
declare const ActionBar: ({
  actionItems,
  flexLayout,
  ...props
}: ActionBarProps) => React$1.JSX.Element;
//#endregion
//#region node_modules/@radix-ui/react-slot/dist/index.d.mts
declare module 'react' {
  interface ReactElement {
    $$typeof?: symbol | string;
  }
}
interface SlotProps extends React$2.HTMLAttributes<HTMLElement> {
  children?: React$2.ReactNode;
}
declare const Slot: React$2.ForwardRefExoticComponent<SlotProps & React$2.RefAttributes<HTMLElement>>;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/Button/Button.d.ts
interface ButtonProps extends Omit<ComponentProps<typeof StyledButton>, 'as'> {
  as?: ComponentProps<typeof StyledButton>['as'] | typeof Slot;
  asChild?: boolean;
  /**
   * A concise action label for the button announced by screen readers. Needed for buttons without
   * text or with text that relies on visual cues to be understood. Pass false to indicate that the
   * Button's content is already accessible to all. When a string is passed, it is also used as the
   * default tooltip text.
   */
  ariaLabel?: string | false;
  /**
   * An optional tooltip to display when the Button is hovered. If the Button has no text content,
   * consider making this the same as the aria-label.
   */
  tooltip?: string;
  /**
   * Only use this flag when tooltips on button interfere with other keyboard interactions, like
   * when building a custom select or menu button. Disables tooltips from the `tooltip`, `shortcut`
   * and `ariaLabel` props.
   */
  disableAllTooltips?: boolean;
  /**
   * A more thorough description of what the Button does, provided to non-sighted users through an
   * aria-describedby attribute. Use sparingly for buttons that trigger complex actions.
   */
  ariaDescription?: string;
  /**
   * An optional keyboard shortcut to enable the button. Will be displayed in the tooltip and passed
   * to aria-keyshortcuts for assistive technologies. The binding of the shortcut and action is
   * managed globally in the manager's shortcuts module.
   */
  shortcut?: API_KeyCollection;
}
declare const Button: React$1.ForwardRefExoticComponent<Omit<ButtonProps, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
declare const StyledButton: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React$1.ElementType;
} & {
  size?: 'small' | 'medium';
  padding?: 'small' | 'medium' | 'none';
  appearance?: 'default' | 'agentic';
  variant?: 'outline' | 'solid' | 'ghost';
  active?: boolean;
  $disabled?: boolean;
  readOnly?: boolean;
  animating?: boolean;
  animation?: 'none' | 'rotate360' | 'glow' | 'jiggle';
}, React$1.DetailedHTMLProps<React$1.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, {}>;
declare const IconButton: React$1.ForwardRefExoticComponent<Omit<ButtonProps, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/ToggleButton/ToggleButton.d.ts
interface ToggleButtonProps extends ButtonProps {
  /** Whether the ToggleButton is currently pressed or not. */
  pressed: boolean;
}
declare const ToggleButton: React$1.ForwardRefExoticComponent<Omit<ToggleButtonProps, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
//#endregion
//#region node_modules/react-transition-state/types/index.d.ts
type TransitionStatus = 'preEnter' | 'entering' | 'entered' | 'preExit' | 'exiting' | 'exited' | 'unmounted';
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/ActionList/ActionList.d.ts
declare const ActionListAction: StyledComponent<Omit<Omit<ButtonProps, "ref"> & React$1.RefAttributes<HTMLButtonElement> & {
  theme?: import("storybook/theming").Theme;
}, "ref"> & React$1.RefAttributes<HTMLButtonElement> & {
  theme?: import("storybook/theming").Theme;
}, {}, {}>;
declare const ActionListLink: (props: ComponentProps<typeof ActionListAction> & React$1.AnchorHTMLAttributes<HTMLAnchorElement>) => React$1.JSX.Element;
declare const ActionList: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React$1.ElementType;
}, React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, {}> & {
  Item: StyledComponent<{
    theme?: import("storybook/theming").Theme;
    as?: React$1.ElementType;
  } & {
    active?: boolean;
    transitionStatus?: TransitionStatus;
  }, React$1.DetailedHTMLProps<React$1.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, {}>;
  HoverItem: StyledComponent<{
    theme?: import("storybook/theming").Theme;
    as?: React$1.ElementType;
  } & {
    active?: boolean;
    transitionStatus?: TransitionStatus;
  } & React$1.ClassAttributes<HTMLLIElement> & React$1.LiHTMLAttributes<HTMLLIElement> & {
    theme?: import("storybook/theming").Theme;
  } & {
    targetId: string;
  }, {}, {}>;
  Button: React$1.ForwardRefExoticComponent<Omit<Omit<ButtonProps, "ref"> & React$1.RefAttributes<HTMLButtonElement> & {
    theme?: import("storybook/theming").Theme;
  }, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
  Toggle: React$1.ForwardRefExoticComponent<Omit<Omit<ToggleButtonProps, "ref"> & React$1.RefAttributes<HTMLButtonElement> & {
    theme?: import("storybook/theming").Theme;
  }, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
  Action: StyledComponent<Omit<Omit<ButtonProps, "ref"> & React$1.RefAttributes<HTMLButtonElement> & {
    theme?: import("storybook/theming").Theme;
  }, "ref"> & React$1.RefAttributes<HTMLButtonElement> & {
    theme?: import("storybook/theming").Theme;
  }, {}, {}>;
  Link: typeof ActionListLink;
  Text: StyledComponent<{
    theme?: import("storybook/theming").Theme;
    as?: React$1.ElementType;
  }, React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
  Icon: StyledComponent<{
    theme?: import("storybook/theming").Theme;
    as?: React$1.ElementType;
  }, React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
};
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/Collapsible/Collapsible.d.ts
declare const CollapsibleContent: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React$1.ElementType;
} & {
  collapsed?: boolean;
}, React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
declare const Collapsible: (({
  children,
  summary,
  collapsed,
  disabled,
  initialCollapsed,
  storageKey,
  state: providedState,
  ...props
}: {
  children: ReactNode | ((state: ReturnType<typeof useCollapsible>) => ReactNode);
  summary?: ReactNode | ((state: ReturnType<typeof useCollapsible>) => ReactNode);
  collapsed?: boolean;
  disabled?: boolean;
  initialCollapsed?: boolean;
  storageKey?: string;
  state?: ReturnType<typeof useCollapsible>;
} & ComponentProps<typeof CollapsibleContent>) => React$1.JSX.Element) & {
  Content: StyledComponent<{
    theme?: import("storybook/theming").Theme;
    as?: React$1.ElementType;
  } & {
    collapsed?: boolean;
  }, React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
};
declare const useCollapsible: ({
  collapsed,
  disabled,
  initialCollapsed,
  storageKey
}: {
  collapsed?: boolean;
  disabled?: boolean;
  initialCollapsed?: boolean;
  storageKey?: string;
}) => {
  contentId: string;
  isCollapsed: boolean;
  isDisabled: boolean;
  setCollapsed: React$1.Dispatch<React$1.SetStateAction<boolean>>;
  toggleCollapsed: (event?: SyntheticEvent<Element, Event>) => void;
  toggleProps: {
    readonly disabled: boolean | undefined;
    readonly onClick: (event?: SyntheticEvent<Element, Event>) => void;
    readonly 'aria-controls': string;
    readonly 'aria-expanded': boolean;
  };
};
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/Card/Card.d.ts
type ThemeColor = keyof StorybookTheme['color'] | keyof StorybookTheme['fgColor'];
declare const CardContent: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React$1.ElementType;
} & {
  color?: ThemeColor;
}, React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
interface CardProps extends ComponentProps<typeof CardContent> {
  outlineAnimation?: 'none' | 'rainbow' | 'spin';
  color?: ThemeColor;
  outlineColor?: ThemeColor;
  outlineAttrs?: DOMAttributes<HTMLDivElement>;
}
declare const Card: React$1.ForwardRefExoticComponent<Omit<CardProps, "ref"> & React$1.RefAttributes<HTMLDivElement>> & {
  Content: StyledComponent<{
    theme?: import("storybook/theming").Theme;
    as?: React$1.ElementType;
  } & {
    color?: ThemeColor;
  }, React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
  Outline: StyledComponent<{
    theme?: import("storybook/theming").Theme;
    as?: React$1.ElementType;
  } & {
    animation?: 'none' | 'rainbow' | 'spin';
    color?: ThemeColor;
    outlineColor?: ThemeColor;
  }, React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
};
//#endregion
//#region node_modules/@react-types/overlays/src/index.d.ts
type Placement$1 = 'bottom' | 'bottom left' | 'bottom right' | 'bottom start' | 'bottom end' | 'top' | 'top left' | 'top right' | 'top start' | 'top end' | 'left' | 'left top' | 'left bottom' | 'start' | 'start top' | 'start bottom' | 'right' | 'right top' | 'right bottom' | 'end' | 'end top' | 'end bottom';
interface PositionProps {
  /**
   * The placement of the element with respect to its anchor element.
   * @default 'bottom'
   */
  placement?: Placement$1;
  /**
   * The placement padding that should be applied between the element and its
   * surrounding container.
   * @default 12
   */
  containerPadding?: number;
  /**
   * The additional offset applied along the main axis between the element and its
   * anchor element.
   * @default 0
   */
  offset?: number;
  /**
   * The additional offset applied along the cross axis between the element and its
   * anchor element.
   * @default 0
   */
  crossOffset?: number;
  /**
   * Whether the element should flip its orientation (e.g. top to bottom or left to right) when
   * there is insufficient room for it to render completely.
   * @default true
   */
  shouldFlip?: boolean; // /**
  //  * The element that should be used as the bounding container when calculating container offset
  //  * or whether it should flip.
  //  */
  // boundaryElement?: Element,
  /** Whether the element is rendered. */
  isOpen?: boolean;
}
//#endregion
//#region node_modules/react-aria-components/dist/types.d.ts
interface TextProps extends HTMLAttributes<HTMLElement> {
  elementType?: string;
}
interface HeadingProps extends HTMLAttributes<HTMLElement> {
  level?: number;
}
declare namespace Modal_styled_d_exports {
  export { Actions, Close, CloseButton, Col, Container, Content, Description, Dialog, Error$1 as Error, ErrorWrapper, Header, Overlay, Row, Title };
}
declare const Overlay: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React$1.ElementType;
} & {
  $status?: TransitionStatus;
  $transitionDuration?: number;
}, React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
declare const Container: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React$1.ElementType;
} & {
  $variant: 'dialog' | 'bottom-drawer';
  $status?: TransitionStatus;
  $transitionDuration?: number;
  width?: number | string;
  height?: number | string;
}, React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
interface CloseProps {
  asChild?: boolean;
  children?: React$1.ReactElement<{
    onClick?: (event: React$1.MouseEvent) => void;
  }, string | React$1.JSXElementConstructor<{
    onClick?: (event: React$1.MouseEvent) => void;
  }>>;
  onClick?: (event: React$1.MouseEvent) => void;
}
declare const Close: ({
  asChild,
  children,
  onClick,
  ...props
}: CloseProps) => React$1.JSX.Element;
declare const Dialog: {
  Close: () => React$1.JSX.Element;
};
declare const CloseButton: ({
  ariaLabel,
  ...props
}: React$1.ComponentProps<typeof Button>) => React$1.JSX.Element;
declare const Content: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React$1.ElementType;
}, React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
declare const Row: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React$1.ElementType;
}, React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
declare const Col: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React$1.ElementType;
}, React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
declare const Header: ({
  hasClose,
  onClose,
  ...props
}: React$1.ComponentProps<typeof Col> & {
  hasClose?: boolean;
  onClose?: () => void;
}) => React$1.JSX.Element;
declare const Title: StyledComponent<HeadingProps & React$1.RefAttributes<HTMLHeadingElement> & {
  theme?: import("storybook/theming").Theme;
}, {}, {}>;
declare const Description: StyledComponent<TextProps & React$1.RefAttributes<HTMLElement> & {
  theme?: import("storybook/theming").Theme;
}, {}, {}>;
declare const Actions: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React$1.ElementType;
}, React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
declare const ErrorWrapper: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React$1.ElementType;
}, React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
declare const Error$1: ({
  children,
  ...props
}: {
  children: React$1.ReactNode;
} & ComponentProps<typeof ErrorWrapper>) => React$1.JSX.Element;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/Modal/Modal.d.ts
interface ModalProps extends HTMLAttributes<HTMLDivElement> {
  container?: HTMLElement;
  portalSelector?: string;
  /** Width of the Modal. Defaults to `740`. */
  width?: number | string;
  /** Height of the Modal. Defaults to `auto`. */
  height?: number | string;
  /** Modal content. */
  children: React$1.ReactNode;
  /** Additional class names for the Modal. */
  className?: string;
  /** Controlled state: whether the Modal is currently open. */
  open?: boolean;
  /** Uncontrolled state: whether the Modal is initially open on the first. */
  defaultOpen?: boolean;
  /** @deprecated Use `dismissOnEscape` instead. */
  onEscapeKeyDown?: (event: KeyboardEvent) => void;
  /** @deprecated Use `dismissOnInteractOutside` instead. */
  onInteractOutside?: (event: FocusEvent | MouseEvent | TouchEvent) => void;
  /** Handler called when visibility of the Modal changes. */
  onOpenChange?: (isOpen: boolean) => void;
  /** The accessible name for the modal. */
  ariaLabel?: string;
  /** Whether the modal can be dismissed by clicking outside. Defaults to `true`. */
  dismissOnClickOutside?: boolean;
  /** Whether the modal can be dismissed by pressing Escape. Defaults to `true`. */
  dismissOnEscape?: boolean;
  /** Transition duration, so we can slow down transitions on mobile. */
  transitionDuration?: number;
  /** The max dimensions, initial position and animations of the Modal. Defaults to 'dialog'. */
  variant?: 'dialog' | 'bottom-drawer';
}
declare function BaseModal({
  container,
  portalSelector,
  children,
  width,
  height,
  ariaLabel,
  dismissOnClickOutside,
  dismissOnEscape,
  className,
  open,
  onEscapeKeyDown,
  onInteractOutside,
  onOpenChange,
  defaultOpen,
  transitionDuration,
  variant,
  ...props
}: ModalProps): React$1.JSX.Element | null;
declare const Modal: typeof BaseModal & typeof Modal_styled_d_exports;
/**
 * Storybook decorator to help render Modals in stories with multiple theme layouts. Internal to
 * Storybook. Use at your own risk.
 */
declare const ModalDecorator: DecoratorFunction;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/spaced/Spaced.d.ts
interface SpacedProps {
  children?: React$1.ReactNode;
  col?: number;
  row?: number;
  outer?: number | boolean;
}
declare const Spaced: ({
  col,
  row,
  outer,
  children,
  ...rest
}: SpacedProps) => React$1.JSX.Element;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/placeholder/placeholder.d.ts
interface PlaceholderProps {
  children?: React$1.ReactNode;
}
declare const Placeholder: ({
  children,
  ...props
}: PlaceholderProps) => React$1.JSX.Element;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/ScrollArea/ScrollArea.d.ts
interface ScrollAreaProps {
  children?: React$1.ReactNode;
  horizontal?: boolean;
  vertical?: boolean;
  className?: string;
  offset?: number;
  scrollbarSize?: number;
  scrollPadding?: number | string;
  /**
   * Set this to define a tabIndex on the scrollable content; only needed when content has no
   * interactive elements.
   */
  focusable?: boolean;
}
declare const ScrollArea: React$1.ForwardRefExoticComponent<ScrollAreaProps & React$1.RefAttributes<HTMLDivElement>>;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/Zoom/ZoomElement.d.ts
type ZoomProps = {
  centered?: boolean;
  scale: number;
  children: ReactElement | ReactElement[];
};
declare function ZoomElement({
  centered,
  scale,
  children
}: ZoomProps): React$1.JSX.Element;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/Zoom/ZoomIFrame.d.ts
type IZoomIFrameProps = {
  scale: number;
  children: ReactElement<HTMLIFrameElement>;
  iFrameRef: RefObject<HTMLIFrameElement>;
  active?: boolean;
};
declare class ZoomIFrame extends Component<IZoomIFrameProps> {
  iframe: HTMLIFrameElement;
  componentDidMount(): void;
  shouldComponentUpdate(nextProps: IZoomIFrameProps): boolean;
  setIframeInnerZoom(scale: number): void;
  setIframeZoom(scale: number): void;
  render(): React$1.JSX.Element;
}
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/Zoom/Zoom.d.ts
declare const Zoom: {
  Element: typeof ZoomElement;
  IFrame: typeof ZoomIFrame;
};
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/ErrorFormatter/ErrorFormatter.d.ts
interface ErrorFormatterProps {
  error: Error;
}
declare const ErrorFormatter: ({
  error
}: ErrorFormatterProps) => React$1.JSX.Element;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/Select/helpers.d.ts
type Value = string | number | null | boolean | undefined;
interface Option {
  /** Optional rendering of the option. */
  children?: React$1.ReactNode;
  title: string;
  description?: string;
  icon?: React$1.ReactNode;
  aside?: React$1.ReactNode;
  value: Value;
}
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/Select/Select.d.ts
interface SelectProps$1 extends Omit<ButtonProps, 'onClick' | 'onChange' | 'onSelect' | 'variant'> {
  size?: 'small' | 'medium';
  padding?: 'small' | 'medium' | 'none';
  /**
   * Whether multiple options can be selected. In single select mode, this component acts like a
   * HTML select element where the selected option follows focus. In multi select mode, it acts like
   * a combobox and does not autoclose on select or autoselect the focused option.
   */
  multiSelect?: boolean;
  /**
   * Mandatory label that explains what is being selected. Do not include "change", "toggle" or
   * "select" verbs in the label. Instead, only describe the type of content with a noun.
   */
  ariaLabel: string;
  /**
   * Label for the Select component. In single-select mode, is replaced by the currently selected
   * option's title.
   */
  children?: React$1.ReactNode;
  /**
   * Icon shown next to the Select's children, still displayed when a value is selected and Select
   * shows that value instead of children.
   */
  icon?: React$1.ReactNode;
  /** Whether the Select is currently disabled. */
  disabled?: boolean;
  /** Options available in the select. */
  options: Option[];
  /** IDs of the preselected options. */
  defaultOptions?: Value | Value[];
  /** Whether the Select should render open. */
  defaultOpen?: boolean;
  /** When set, a reset option is rendered in the Select listbox. */
  onReset?: () => void;
  /** Custom text label for the reset option when it exists. */
  resetLabel?: string;
  onSelect?: (option: Value) => void;
  onDeselect?: (option: Value) => void;
  onChange?: (selected: Value[]) => void;
  /**
   * Legacy option for ToolbarMenuSelect. Do not use in new code. Controls whether to show the
   * selected option's title.
   *
   * @default true
   */
  showSelectedOptionTitle?: boolean;
}
declare const Select: React$1.ForwardRefExoticComponent<Omit<SelectProps$1, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/Form/styles.d.ts
type Sizes = '100%' | 'flex' | 'auto';
type Alignments = 'end' | 'center' | 'start';
type ValidationStates = 'valid' | 'error' | 'warn';
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/Form/Textarea.d.ts
/**
 * These types are copied from `react-textarea-autosize`. I copied them because of
 * https://github.com/storybookjs/storybook/issues/18734 Maybe there's some bug in `tsup` or
 * `react-textarea-autosize`?
 */
type TextareaPropsRaw = React$1.TextareaHTMLAttributes<HTMLTextAreaElement>;
type Style = Omit<NonNullable<TextareaPropsRaw['style']>, 'maxHeight' | 'minHeight'> & {
  height?: number;
};
type TextareaHeightChangeMeta = {
  rowHeight: number;
};
interface TextareaAutosizeProps extends Omit<TextareaPropsRaw, 'style'> {
  maxRows?: number;
  minRows?: number;
  onHeightChange?: (height: number, meta: TextareaHeightChangeMeta) => void;
  cacheMeasurements?: boolean;
  style?: Style;
}
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/Form/Checkbox.d.ts
declare const Checkbox: (props: React$1.InputHTMLAttributes<HTMLInputElement>) => React$1.JSX.Element;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/Form/Field.d.ts
interface FieldProps {
  children?: ReactNode;
  label?: ReactNode;
}
declare const Field: ({
  label,
  children,
  ...props
}: FieldProps) => React$1.JSX.Element;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/Form/Radio.d.ts
declare const Radio: (props: React$1.InputHTMLAttributes<HTMLInputElement>) => React$1.JSX.Element;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/Form/Select.d.ts
type SelectProps = Omit<SelectHTMLAttributes<HTMLSelectElement>, keyof {
  size?: Sizes;
  align?: Alignments;
  valid?: ValidationStates;
  height?: number;
}> & {
  size?: Sizes;
  align?: Alignments;
  valid?: ValidationStates;
  height?: number;
};
declare const Select$1: ({
  children,
  ...props
}: SelectProps) => React$1.JSX.Element;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/Form/Form.d.ts
declare const Form: StyledComponent<{
  theme?: import("storybook/theming").Theme;
  as?: React.ElementType;
}, import("react").DetailedHTMLProps<import("react").FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>, {}> & {
  Field: typeof Field;
  Input: StyledComponent<Omit<Omit<import("react").HTMLProps<HTMLInputElement>, "align" | "height" | "size" | "valid"> & {
    size?: Sizes;
    align?: Alignments;
    valid?: ValidationStates;
    height?: number;
    suffix?: string;
  }, "ref"> & import("react").RefAttributes<any> & {
    theme?: import("storybook/theming").Theme;
  } & Omit<import("react").HTMLProps<HTMLInputElement>, "align" | "height" | "size" | "valid"> & {
    size?: Sizes;
    align?: Alignments;
    valid?: ValidationStates;
    height?: number;
    suffix?: string;
  }, {}, {}> & {
    displayName: string;
  };
  Select: typeof Select$1;
  Textarea: StyledComponent<Omit<Omit<TextareaAutosizeProps, "align" | "height" | "size" | "valid"> & {
    size?: Sizes;
    align?: Alignments;
    valid?: ValidationStates;
    height?: number;
  } & import("react").RefAttributes<HTMLTextAreaElement>, "ref"> & import("react").RefAttributes<any> & {
    theme?: import("storybook/theming").Theme;
  } & Omit<TextareaAutosizeProps, "align" | "height" | "size" | "valid"> & {
    size?: Sizes;
    align?: Alignments;
    valid?: ValidationStates;
    height?: number;
  } & import("react").RefAttributes<HTMLTextAreaElement>, {}, {}> & {
    displayName: string;
  };
  Button: import("react").ForwardRefExoticComponent<Omit<ButtonProps, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
  Checkbox: typeof Checkbox;
  Radio: typeof Radio;
};
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/shared/overlayHelpers.d.ts
type BasicPlacement = 'top' | 'bottom' | 'left' | 'right';
type PlacementWithModifier = 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end' | 'left-start' | 'left-end' | 'right-start' | 'right-end';
type PopperPlacement = BasicPlacement | PlacementWithModifier;
declare const convertToReactAriaPlacement: (p: PopperPlacement) => NonNullable<PositionProps['placement']>;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/Popover/Popover.d.ts
interface PopoverProps extends HTMLAttributes<HTMLDivElement> {
  /** Content of the popover. */
  children: React$1.ReactNode;
  /** Preset popover color taken from the theme, affecting both bathground and foreground. */
  color?: 'default' | 'inverse' | 'positive' | 'negative' | 'warning' | 'none';
  /** Whether the popover is rendered with a decorative window-like appearance. */
  hasChrome: boolean;
  /** Optional callback connected to a close button. Then button is shown only when passed. */
  onHide?: () => void;
  /** Optional custom label for the close button, if there is one. */
  hideLabel?: string;
  /** Padding between the content and popover edge. */
  padding?: number | string;
}
declare const Popover: React$1.ForwardRefExoticComponent<PopoverProps & React$1.RefAttributes<HTMLDivElement>>;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/Popover/PopoverProvider.d.ts
interface PopoverProviderProps {
  /**
   * An accessible label for the popover dialog, announced by screen readers. This prop will become
   * mandatory in Storybook 11. Provide a concise description of the popover's purpose.
   */
  ariaLabel?: string;
  /** Whether to display the Popover in a prestyled container. True by default. */
  hasChrome?: boolean;
  /**
   * Whether to display a close button in the top right corner of the popover overlay. Can overlap
   * with overlay content, make sure to test your use case. False by default.
   */
  hasCloseButton?: boolean;
  /** Optional custom label for the close button, if there is one. */
  closeLabel?: string;
  /** Optional custom padding for the popover overlay. */
  padding?: number | string;
  /** Distance between the trigger and Popover. Customize only if you have a good reason to. */
  offset?: number;
  /**
   * Placement of the Popover. Start and End variants involve additional JS dimension calculations
   * and should be used sparingly. Left and Right get inverted in RTL.
   */
  placement?: PopperPlacement;
  /**
   * Popover content. Pass a function to receive a onHide callback to collect to your close button,
   * or if you want to wait for the popover to be opened to call your content component.
   */
  popover: ReactNode | ((props: {
    onHide: () => void;
  }) => ReactNode);
  /** Popover trigger, must be a single child with click/press events. Must forward refs. */
  children: ReactElement<DOMAttributes<Element>, string>;
  /** Uncontrolled state: whether the Popover is initially visible. */
  defaultVisible?: boolean;
  /** Controlled state: whether the Popover is visible. */
  visible?: boolean;
  /** Controlled state: fires when user interaction causes the Popover to change visibility. */
  onVisibleChange?: (isVisible: boolean) => void;
}
declare const PopoverProvider: ({
  ariaLabel,
  placement: placementProp,
  hasChrome,
  hasCloseButton,
  closeLabel,
  offset,
  padding,
  popover,
  children,
  defaultVisible,
  visible,
  onVisibleChange,
  ...props
}: PopoverProviderProps) => React$1.JSX.Element;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/tooltip/Tooltip.d.ts
type TooltipProps = Omit<PopoverProps, 'onHide' | 'hideLabel'>;
declare const Tooltip: React$1.ForwardRefExoticComponent<TooltipProps & React$1.RefAttributes<HTMLDivElement>>;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/tooltip/TooltipNote.d.ts
interface TooltipNoteProps {
  note: string;
}
declare const TooltipNote: ({
  note,
  ...props
}: TooltipNoteProps) => React$1.JSX.Element;
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/tooltip/TooltipProvider.d.ts
interface TooltipProviderProps {
  /** Tooltips trigger on hover and focus by default. To trigger on focus only, set this to `true`. */
  triggerOnFocusOnly?: boolean;
  /** Distance between the trigger and tooltip. Customize only if you have a good reason to. */
  offset?: number;
  /**
   * Placement of the tooltip. Start and End variants involve additional JS dimension calculations
   * and should be used sparingly. Left and Right get inverted in RTL.
   */
  placement?: PopperPlacement;
  /** Tooltip content */
  tooltip: ReactNode;
  /** Tooltip trigger, must be a single child that can receive focus and click/key events. */
  children: ReactElement<DOMAttributes<Element>, string>;
  /** Delay before showing the tooltip, defaults to 200ms. Always instant on focus. */
  delayShow?: number;
  /** Delay before hiding the tooltip, defaults to 400ms. */
  delayHide?: number;
  /** Uncontrolled state: whether the tooltip is visible by default. */
  defaultVisible?: boolean;
  /** Deprecated property - use defaultVisible instead. */
  startOpen?: boolean;
  /** Controlled state: whether the tooltip is visible. */
  visible?: boolean;
  /** Controlled state: fires when user interaction causes the tooltip to change visibility. */
  onVisibleChange?: (isVisible: boolean) => void;
}
declare const TooltipProvider: ({
  triggerOnFocusOnly,
  placement: placementProp,
  offset,
  tooltip,
  children,
  defaultVisible,
  startOpen,
  delayShow,
  delayHide,
  visible,
  onVisibleChange,
  ...props
}: TooltipProviderProps) => React$1.JSX.Element;
//#endregion
//#region node_modules/@popperjs/core/lib/enums.d.ts
declare const top: "top";
declare const bottom: "bottom";
declare const right: "right";
declare const left: "left";
declare type BasePlacement = typeof top | typeof bottom | typeof right | typeof left;
declare type VariationPlacement = "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end";
declare type AutoPlacement = "auto" | "auto-start" | "auto-end";
declare type Placement = AutoPlacement | BasePlacement | VariationPlacement;
declare const beforeRead: "beforeRead";
declare const read: "read";
declare const afterRead: "afterRead";
declare const beforeMain: "beforeMain";
declare const main: "main";
declare const afterMain: "afterMain";
declare const beforeWrite: "beforeWrite";
declare const write: "write";
declare const afterWrite: "afterWrite";
declare type ModifierPhases = typeof beforeRead | typeof read | typeof afterRead | typeof beforeMain | typeof main | typeof afterMain | typeof beforeWrite | typeof write | typeof afterWrite;
//#endregion
//#region node_modules/@popperjs/core/lib/types.d.ts
declare type Obj = {
  [key: string]: any;
};
declare type VisualViewport = EventTarget & {
  width: number;
  height: number;
  offsetLeft: number;
  offsetTop: number;
  scale: number;
};
declare type Window = {
  innerHeight: number;
  offsetHeight: number;
  innerWidth: number;
  offsetWidth: number;
  pageXOffset: number;
  pageYOffset: number;
  getComputedStyle: typeof getComputedStyle;
  addEventListener(type: any, listener: any, optionsOrUseCapture?: any): void;
  removeEventListener(type: any, listener: any, optionsOrUseCapture?: any): void;
  Element: Element;
  HTMLElement: HTMLElement;
  Node: Node;
  toString(): "[object Window]";
  devicePixelRatio: number;
  visualViewport?: VisualViewport;
  ShadowRoot: ShadowRoot;
};
declare type Rect = {
  width: number;
  height: number;
  x: number;
  y: number;
};
declare type Offsets = {
  y: number;
  x: number;
};
declare type PositioningStrategy = "absolute" | "fixed";
declare type StateRects = {
  reference: Rect;
  popper: Rect;
};
declare type OffsetData = { [key in Placement]?: Offsets };
declare type State = {
  elements: {
    reference: Element | VirtualElement;
    popper: HTMLElement;
    arrow?: HTMLElement;
  };
  options: OptionsGeneric<any>;
  placement: Placement;
  strategy: PositioningStrategy;
  orderedModifiers: Array<Modifier<any, any>>;
  rects: StateRects;
  scrollParents: {
    reference: Array<Element | Window | VisualViewport>;
    popper: Array<Element | Window | VisualViewport>;
  };
  styles: {
    [key: string]: Partial<CSSStyleDeclaration>;
  };
  attributes: {
    [key: string]: {
      [key: string]: string | boolean;
    };
  };
  modifiersData: {
    arrow?: {
      x?: number;
      y?: number;
      centerOffset: number;
    };
    hide?: {
      isReferenceHidden: boolean;
      hasPopperEscaped: boolean;
      referenceClippingOffsets: SideObject;
      popperEscapeOffsets: SideObject;
    };
    offset?: OffsetData;
    preventOverflow?: Offsets;
    popperOffsets?: Offsets;
    [key: string]: any;
  };
  reset: boolean;
};
declare type SetAction<S> = S | ((prev: S) => S);
declare type Instance = {
  state: State;
  destroy: () => void;
  forceUpdate: () => void;
  update: () => Promise<Partial<State>>;
  setOptions: (setOptionsAction: SetAction<Partial<OptionsGeneric<any>>>) => Promise<Partial<State>>;
};
declare type ModifierArguments<Options extends Obj> = {
  state: State;
  instance: Instance;
  options: Partial<Options>;
  name: string;
};
declare type Modifier<Name, Options extends Obj> = {
  name: Name;
  enabled: boolean;
  phase: ModifierPhases;
  requires?: Array<string>;
  requiresIfExists?: Array<string>;
  fn: (arg0: ModifierArguments<Options>) => State | void;
  effect?: (arg0: ModifierArguments<Options>) => (() => void) | void;
  options?: Partial<Options>;
  data?: Obj;
};
declare type Options$1 = {
  placement: Placement;
  modifiers: Array<Partial<Modifier<any, any>>>;
  strategy: PositioningStrategy;
  onFirstUpdate?: (arg0: Partial<State>) => void;
};
declare type OptionsGeneric<TModifier> = {
  placement: Placement;
  modifiers: Array<TModifier>;
  strategy: PositioningStrategy;
  onFirstUpdate?: (arg0: Partial<State>) => void;
};
declare type SideObject = {
  top: number;
  left: number;
  right: number;
  bottom: number;
};
declare type VirtualElement = {
  getBoundingClientRect: () => ClientRect | DOMRect;
  contextElement?: Element;
};
//#endregion
//#region node_modules/@popperjs/core/lib/popper.d.ts
declare const createPopper: <TModifier extends Partial<Modifier<any, any>>>(reference: Element | VirtualElement, popper: HTMLElement, options?: Partial<OptionsGeneric<TModifier>>) => Instance;
//#endregion
//#region node_modules/react-popper-tooltip/dist/types.d.ts
declare type TriggerType = 'click' | 'double-click' | 'right-click' | 'hover' | 'focus';
declare type Config = {
  /**
   * Whether to close the tooltip when its trigger is out of boundary
   * @default false
   */
  closeOnTriggerHidden?: boolean;
  /**
   * Event or events that trigger the tooltip
   * @default hover
   */
  trigger?: TriggerType | TriggerType[] | null;
  /**
   * Delay in hiding the tooltip (ms)
   * @default 0
   */
  delayHide?: number;
  /**
   * Delay in showing the tooltip (ms)
   * @default 0
   */
  delayShow?: number;
  /**
   * Whether to make the tooltip spawn at cursor position
   * @default false
   */
  followCursor?: boolean;
  /**
   * Options to MutationObserver, used internally for updating
   * tooltip position based on its DOM changes
   * @default  { attributes: true, childList: true, subtree: true }
   */
  mutationObserverOptions?: MutationObserverInit | null;
  /**
   * Whether tooltip is shown by default
   * @default false
   */
  defaultVisible?: boolean;
  /**
   * Used to create controlled tooltip
   */
  visible?: boolean;
  /**
   * Called when the visibility of the tooltip changes
   */
  onVisibleChange?: (state: boolean) => void;
  /**
   * If `true`, a click outside the trigger element closes the tooltip
   * @default true
   */
  closeOnOutsideClick?: boolean;
  /**
   * If `true`, hovering the tooltip will keep it open. Normally tooltip closes when the mouse cursor moves out of
   * the trigger element. If it moves to the tooltip element, the tooltip stays open.
   * @default false
   */
  interactive?: boolean;
  /**
   * Alias for popper.js placement, see https://popper.js.org/docs/v2/constructors/#placement
   */
  placement?: Placement;
  /**
   * Shorthand for popper.js offset modifier, see https://popper.js.org/docs/v2/modifiers/offset/
   * @default [0, 6]
   */
  offset?: [number, number];
};
declare type PopperOptions = Partial<Options$1> & {
  createPopper?: typeof createPopper;
};
//#endregion
//#region code/core/.dts-emit/code/core/src/components/components/tooltip/Wit