@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/components/index.d.ts

@@ -0,0 +1,1924 @@
+import { DecoratorFunction } from "@aussieljk/forkbook/internal/csf";
+import * as React$1 from "react";
+import React, { AnchorHTMLAttributes, ButtonHTMLAttributes, CSSProperties, Component, ComponentProps, ComponentPropsWithoutRef, DOMAttributes, ElementType, FC, ForwardRefExoticComponent, HTMLAttributes, MouseEvent as MouseEvent$1, PropsWithChildren, ReactElement, ReactNode, RefAttributes, RefObject, SelectHTMLAttributes, SyntheticEvent } from "react";
+import { Addon_RenderOptions } from "@aussieljk/forkbook/internal/types";
+import { StorybookTheme } from "@aussieljk/forkbook/theming";
+import { API_KeyCollection } from "@aussieljk/forkbook/manager-api";
+
+//#region .dts-emit/code/core/src/components/components/typography/elements/Link.d.ts
+declare const Link$2: ({
+  href: input,
+  ...props
+}: React.AnchorHTMLAttributes<HTMLAnchorElement>) => React.JSX.Element;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/typography/elements/A.d.ts
+declare const A: ({
+  className,
+  ...props
+}: ComponentProps<typeof Link$2>) => React.JSX.Element;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/typography/elements/Blockquote.d.ts
+declare const Blockquote: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").BlockquoteHTMLAttributes<HTMLQuoteElement>, HTMLQuoteElement>, "ref"> & import("react").RefAttributes<any>>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/typography/elements/Code.d.ts
+declare const Code: ({
+  className,
+  children,
+  ...props
+}: ComponentProps<'code'>) => React.JSX.Element;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/typography/elements/Div.d.ts
+declare const Div: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<any>>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/typography/elements/DL.d.ts
+declare const DL: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDListElement>, HTMLDListElement>, "ref"> & import("react").RefAttributes<any>>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/typography/elements/H1.d.ts
+declare const H1: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref"> & import("react").RefAttributes<any>>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/typography/elements/H2.d.ts
+declare const H2: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref"> & import("react").RefAttributes<any>>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/typography/elements/H3.d.ts
+declare const H3: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref"> & import("react").RefAttributes<any>>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/typography/elements/H4.d.ts
+declare const H4: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref"> & import("react").RefAttributes<any>>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/typography/elements/H5.d.ts
+declare const H5: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref"> & import("react").RefAttributes<any>>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/typography/elements/H6.d.ts
+declare const H6: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref"> & import("react").RefAttributes<any>>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/typography/elements/HR.d.ts
+declare const HR: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHRElement>, HTMLHRElement>, "ref"> & import("react").RefAttributes<any>>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/typography/elements/Img.d.ts
+declare const Img: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, "ref"> & import("react").RefAttributes<any>>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/typography/elements/LI.d.ts
+declare const LI: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & import("react").RefAttributes<any>>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/typography/elements/OL.d.ts
+declare const OL: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>, "ref"> & import("react").RefAttributes<any>>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/typography/elements/P.d.ts
+declare const P: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref"> & import("react").RefAttributes<any>>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/typography/elements/Pre.d.ts
+declare const Pre: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLPreElement>, HTMLPreElement>, "ref"> & import("react").RefAttributes<any>>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/typography/elements/Span.d.ts
+declare const Span: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & import("react").RefAttributes<any>>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/typography/elements/Table.d.ts
+declare const Table: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>, "ref"> & import("react").RefAttributes<any>>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/typography/elements/TT.d.ts
+declare const TT: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLTitleElement>, HTMLTitleElement>, "ref"> & import("react").RefAttributes<any>>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/typography/elements/UL.d.ts
+declare const UL: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & import("react").RefAttributes<any>>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/Badge/Badge.d.ts
+interface BadgeProps {
+  compact?: boolean;
+  status?: 'positive' | 'negative' | 'neutral' | 'warning' | 'critical' | 'active';
+  children?: React.ReactNode;
+}
+declare const Badge: ({
+  compact,
+  status,
+  children
+}: BadgeProps) => React.JSX.Element;
+//#endregion
+//#region .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?: React.CSSProperties;
+  onClick?: (e: MouseEvent$1) => void;
+  href?: string;
+}
+declare const Link: React.ForwardRefExoticComponent<LinkProps & React.RefAttributes<HTMLAnchorElement>>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/typography/DocumentWrapper.d.ts
+declare const DocumentWrapper: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<any>>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/syntaxhighlighter/syntaxhighlighter-types.d.ts
+type SyntaxHighlighterFormatTypes = boolean | 'dedent';
+/** A sugar-high language name, alias or file extension, such as `tsx`, `css` or `bash`. */
+type SupportedLanguage = string;
+interface SyntaxHighlighterProps {
+  children?: ReactNode;
+  language?: SupportedLanguage;
+  copyable?: boolean;
+  bordered?: boolean;
+  padded?: boolean;
+  format?: SyntaxHighlighterFormatTypes;
+  formatter?: (type: SyntaxHighlighterFormatTypes, source: string) => Promise<string>;
+  className?: string;
+  showLineNumbers?: boolean;
+  wrapLongLines?: boolean;
+}
+//#endregion
+//#region .dts-emit/code/core/src/components/components/syntaxhighlighter/syntaxhighlighter.d.ts
+declare const SyntaxHighlighter: ({
+  children,
+  language,
+  copyable,
+  bordered,
+  padded,
+  format,
+  formatter,
+  className,
+  showLineNumbers,
+  wrapLongLines
+}: SyntaxHighlighterProps) => React.JSX.Element | null;
+//#endregion
+//#region .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 .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.JSX.Element;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/shared/overlayHelpers.d.ts
+declare const POPPER_PLACEMENTS: readonly ['top', 'top-start', 'top-end', 'bottom', 'bottom-start', 'bottom-end', 'left', 'left-start', 'left-end', 'right', 'right-start', 'right-end'];
+type PopperPlacement = (typeof POPPER_PLACEMENTS)[number];
+/** Converts a Popper.js placement to the `side` and `align` props of a Base UI positioner. */
+declare const convertToBaseUiPlacement: (placement: PopperPlacement) => {
+  side: "bottom" | "left" | "right" | "top";
+  align: "center" | "end" | "start";
+};
+//#endregion
+//#region .dts-emit/code/core/src/components/components/Button/Button.d.ts
+interface ButtonProps extends ComponentPropsWithoutRef<'button'> {
+  as?: ElementType;
+  asChild?: boolean;
+  size?: 'small' | 'medium';
+  padding?: 'small' | 'medium' | 'none';
+  appearance?: 'default' | 'agentic';
+  variant?: 'outline' | 'solid' | 'ghost';
+  /** @deprecated Use specialized components like `ToggleButton` or `Select` instead. */
+  active?: boolean;
+  readOnly?: boolean;
+  /** An animation for the icon, played on click. */
+  animation?: 'none' | 'rotate360' | 'glow' | 'jiggle';
+  /**
+   * 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;
+  /**
+   * The preferred placement of the tooltip.
+   */
+  tooltipPlacement?: PopperPlacement;
+  /**
+   * 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.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+declare const IconButton: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+//#endregion
+//#region .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.ForwardRefExoticComponent<ToggleButtonProps & React.RefAttributes<HTMLButtonElement>>;
+//#endregion
+//#region ../../node_modules/react-transition-state/types/types.d.ts
+type TransitionStatus$1 = 'preEnter' | 'entering' | 'entered' | 'preExit' | 'exiting' | 'exited' | 'unmounted';
+//#endregion
+//#region .dts-emit/code/core/src/components/components/ActionList/ActionList.d.ts
+interface ActionListItemProps extends ComponentProps<'li'> {
+  as?: ElementType;
+  active?: boolean;
+  transitionStatus?: TransitionStatus$1;
+}
+declare const ActionListAction: React.ForwardRefExoticComponent<Omit<ButtonProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const ActionListLink: (props: ComponentProps<typeof ActionListAction> & React.AnchorHTMLAttributes<HTMLAnchorElement>) => React.JSX.Element;
+declare const ActionList: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLUListElement> & React.HTMLAttributes<HTMLUListElement> & {
+  as?: ElementType;
+}, "ref"> & React.RefAttributes<HTMLUListElement>> & {
+  Item: React.ForwardRefExoticComponent<Omit<ActionListItemProps, "ref"> & React.RefAttributes<HTMLLIElement>>;
+  HoverItem: React.ForwardRefExoticComponent<Omit<ActionListItemProps & {
+    targetId: string;
+  }, "ref"> & React.RefAttributes<HTMLLIElement>>;
+  Button: React.ForwardRefExoticComponent<Omit<ButtonProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+  Toggle: React.ForwardRefExoticComponent<Omit<ToggleButtonProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+  Action: React.ForwardRefExoticComponent<Omit<ButtonProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+  Link: typeof ActionListLink;
+  Text: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+  Icon: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+};
+//#endregion
+//#region .dts-emit/code/core/src/components/components/Collapsible/Collapsible.d.ts
+declare const CollapsibleContent: ({
+  collapsed,
+  className,
+  ...props
+}: ComponentProps<'div'> & {
+  collapsed?: boolean;
+}) => React.JSX.Element;
+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.JSX.Element) & {
+  Content: typeof CollapsibleContent;
+};
+declare const useCollapsible: ({
+  collapsed,
+  disabled,
+  initialCollapsed,
+  storageKey
+}: {
+  collapsed?: boolean;
+  disabled?: boolean;
+  initialCollapsed?: boolean;
+  storageKey?: string;
+}) => {
+  contentId: string;
+  isCollapsed: boolean;
+  isDisabled: boolean;
+  setCollapsed: React.Dispatch<React.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 .dts-emit/code/core/src/components/components/Card/Card.d.ts
+type ThemeColor = keyof StorybookTheme['color'] | keyof StorybookTheme['fgColor'];
+interface CardContentProps extends ComponentProps<'div'> {
+  color?: ThemeColor;
+}
+interface CardOutlineProps extends ComponentProps<'div'> {
+  animation?: 'none' | 'rainbow' | 'spin';
+  color?: ThemeColor;
+  outlineColor?: ThemeColor;
+}
+interface CardProps extends CardContentProps {
+  outlineAnimation?: 'none' | 'rainbow' | 'spin';
+  outlineColor?: ThemeColor;
+  outlineAttrs?: DOMAttributes<HTMLDivElement>;
+}
+declare const Card: React.ForwardRefExoticComponent<Omit<CardProps, "ref"> & React.RefAttributes<HTMLDivElement>> & {
+  Content: React.ForwardRefExoticComponent<Omit<CardContentProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+  Outline: React.ForwardRefExoticComponent<Omit<CardOutlineProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+};
+declare namespace Modal_styled_d_exports {
+  export { Actions, Close, CloseButton, Col, Container, Content, Description, Dialog, Error$1 as Error, ErrorWrapper, Header, Overlay, Row, Title };
+}
+interface TransitionProps {
+  $status?: TransitionStatus$1;
+  $transitionDuration?: number;
+}
+declare const Overlay: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & TransitionProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Container: React.ForwardRefExoticComponent<Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "height" | "width"> & TransitionProps & {
+  $variant: 'dialog' | 'bottom-drawer';
+  width?: number | string;
+  height?: number | string;
+}, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface CloseProps {
+  asChild?: boolean;
+  children?: React.ReactElement<{
+    onClick?: (event: React.MouseEvent) => void;
+  }, string | React.JSXElementConstructor<{
+    onClick?: (event: React.MouseEvent) => void;
+  }>>;
+  onClick?: (event: React.MouseEvent) => void;
+}
+declare const Close: ({
+  asChild,
+  children,
+  onClick,
+  ...props
+}: CloseProps) => React.JSX.Element;
+declare const Dialog: {
+  Close: () => React.JSX.Element;
+};
+declare const CloseButton: ({
+  ariaLabel,
+  ...props
+}: React.ComponentProps<typeof Button>) => React.JSX.Element;
+declare const Content: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Row: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Col: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Header: ({
+  hasClose,
+  onClose,
+  ...props
+}: React.ComponentProps<typeof Col> & {
+  hasClose?: boolean;
+  onClose?: () => void;
+}) => React.JSX.Element;
+declare const Title: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const Description: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare const Actions: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ErrorWrapper: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Error$1: ({
+  children,
+  ...props
+}: {
+  children: React.ReactNode;
+} & ComponentProps<typeof ErrorWrapper>) => React.JSX.Element;
+//#endregion
+//#region .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.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.JSX.Element | null;
+declare const Modal: typeof BaseModal & typeof Modal_styled_d_exports;
+/**
+ * Forkbook decorator to help render Modals in stories with multiple theme layouts. Internal to
+ * Forkbook. Use at your own risk.
+ */
+declare const ModalDecorator: DecoratorFunction;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/spaced/Spaced.d.ts
+interface SpacedProps {
+  children?: React.ReactNode;
+  col?: number;
+  row?: number;
+  outer?: number | boolean;
+  className?: string;
+}
+declare const Spaced: ({
+  col,
+  row,
+  outer,
+  children,
+  className,
+  ...rest
+}: SpacedProps) => React.JSX.Element;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/placeholder/placeholder.d.ts
+interface PlaceholderProps {
+  children?: React.ReactNode;
+}
+declare const Placeholder: ({
+  children,
+  ...props
+}: PlaceholderProps) => React.JSX.Element;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/ScrollArea/ScrollArea.d.ts
+interface ScrollAreaProps {
+  children?: React.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.ForwardRefExoticComponent<ScrollAreaProps & React.RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region .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.JSX.Element;
+//#endregion
+//#region .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.JSX.Element;
+}
+//#endregion
+//#region .dts-emit/code/core/src/components/components/Zoom/Zoom.d.ts
+declare const Zoom: {
+  Element: typeof ZoomElement;
+  IFrame: typeof ZoomIFrame;
+};
+//#endregion
+//#region .dts-emit/code/core/src/components/components/ErrorFormatter/ErrorFormatter.d.ts
+interface ErrorFormatterProps {
+  error: Error;
+}
+declare const ErrorFormatter: ({
+  error
+}: ErrorFormatterProps) => React.JSX.Element;
+//#endregion
+//#region .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.ReactNode;
+  title: string;
+  description?: string;
+  icon?: React.ReactNode;
+  aside?: React.ReactNode;
+  value: Value;
+}
+//#endregion
+//#region .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.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.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.ForwardRefExoticComponent<SelectProps$1 & React.RefAttributes<HTMLButtonElement>>;
+//#endregion
+//#region .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 .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.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 .dts-emit/code/core/src/components/components/Form/Checkbox.d.ts
+declare const Checkbox: ({
+  className,
+  ...props
+}: React.InputHTMLAttributes<HTMLInputElement>) => React.JSX.Element;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/Form/Field.d.ts
+interface FieldProps extends Omit<ComponentProps<'label'>, 'children'> {
+  children?: ReactNode;
+  label?: ReactNode;
+}
+declare const Field: ({
+  label,
+  children,
+  className,
+  ...props
+}: FieldProps) => React.JSX.Element;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/Form/Radio.d.ts
+declare const Radio: ({
+  className,
+  ...props
+}: React.InputHTMLAttributes<HTMLInputElement>) => React.JSX.Element;
+//#endregion
+//#region .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,
+  size,
+  align,
+  valid,
+  height,
+  className,
+  ...props
+}: SelectProps) => React.JSX.Element;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/Form/Form.d.ts
+declare const Form: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>, "ref"> & React.RefAttributes<HTMLFormElement>> & {
+  Field: typeof Field;
+  Input: React.ForwardRefExoticComponent<Omit<Omit<React.HTMLProps<HTMLInputElement>, "align" | "height" | "size" | "valid"> & {
+    size?: Sizes;
+    align?: Alignments;
+    valid?: ValidationStates;
+    height?: number;
+    suffix?: string;
+  }, "ref"> & React.RefAttributes<any>>;
+  Select: typeof Select$1;
+  Textarea: React.ForwardRefExoticComponent<Omit<Omit<TextareaAutosizeProps, "align" | "height" | "size" | "valid"> & {
+    size?: Sizes;
+    align?: Alignments;
+    valid?: ValidationStates;
+    height?: number;
+  } & React.RefAttributes<HTMLTextAreaElement>, "ref"> & React.RefAttributes<any>>;
+  Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+  Checkbox: typeof Checkbox;
+  Radio: typeof Radio;
+};
+//#endregion
+//#region .dts-emit/code/core/src/components/components/Popover/Popover.d.ts
+interface PopoverProps extends HTMLAttributes<HTMLDivElement> {
+  /** Content of the popover. */
+  children: React.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.ForwardRefExoticComponent<PopoverProps & React.RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region .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 Forkbook 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,
+  hasChrome,
+  hasCloseButton,
+  closeLabel,
+  offset,
+  padding,
+  popover,
+  children,
+  defaultVisible,
+  visible,
+  onVisibleChange
+}: PopoverProviderProps) => React.JSX.Element;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/tooltip/Tooltip.d.ts
+type TooltipProps = Omit<PopoverProps, 'onHide' | 'hideLabel'>;
+declare const Tooltip: React.ForwardRefExoticComponent<TooltipProps & React.RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/tooltip/TooltipNote.d.ts
+interface TooltipNoteProps {
+  note?: string;
+  shortcut?: string;
+  maxWidth?: number;
+}
+declare const TooltipNote: ({
+  note,
+  maxWidth,
+  shortcut,
+  ...props
+}: TooltipNoteProps) => React.JSX.Element;
+//#endregion
+//#region .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,
+  offset,
+  tooltip,
+  children,
+  defaultVisible,
+  startOpen,
+  delayShow,
+  delayHide,
+  visible,
+  onVisibleChange
+}: TooltipProviderProps) => React.JSX.Element;
+//#endregion
+//#region ../../node_modules/@popperjs/core/lib/enums.d.ts
+declare const top: "top";
+declare const bottom: "bottom";
+declare const right$1: "right";
+declare const left$1: "left";
+declare type BasePlacement = typeof top | typeof bottom | typeof right$1 | typeof left$1;
+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$1 = {
+  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$1;
+  destroy: () => void;
+  forceUpdate: () => void;
+  update: () => Promise<Partial<State$1>>;
+  setOptions: (setOptionsAction: SetAction<Partial<OptionsGeneric<any>>>) => Promise<Partial<State$1>>;
+};
+declare type ModifierArguments<Options extends Obj> = {
+  state: State$1;
+  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$1 | 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$1>) => void;
+};
+declare type OptionsGeneric<TModifier> = {
+  placement: Placement;
+  modifiers: Array<TModifier>;
+  strategy: PositioningStrategy;
+  onFirstUpdate?: (arg0: Partial<State$1>) => 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 .dts-emit/code/core/src/components/components/tooltip/WithTooltip.d.ts
+interface WithHideFn {
+  onHide: () => void;
+}
+interface WithTooltipPureProps extends Omit<Config, 'closeOnOutsideClick'>, Omit<HTMLAttributes<HTMLElement>, 'children'>, PopperOptions {
+  svg?: boolean;
+  withArrows?: boolean;
+  hasChrome?: boolean;
+  tooltip: ReactNode | ((p: WithHideFn) => ReactNode);
+  children: ReactNode;
+  onDoubleClick?: () => void;
+  /**
+   * If `true`, a click outside the trigger element closes the tooltip
+   *
+   * @default false
+   */
+  closeOnOutsideClick?: boolean;
+  /**
+   * Optional container to portal the tooltip into. Can be a CSS selector string or a DOM Element.
+   * Falls back to document.body.
+   */
+  portalContainer?: Element | string | null;
+}
+interface WithTooltipStateProps extends Omit<WithTooltipPureProps, 'onVisibleChange'> {
+  startOpen?: boolean;
+  onVisibleChange?: (visible: boolean) => void | boolean;
+}
+//#endregion
+//#region .dts-emit/code/core/src/components/components/tooltip/lazy-WithTooltip.d.ts
+declare const LazyWithTooltip: React.LazyExoticComponent<({
+  startOpen,
+  onVisibleChange: onChange,
+  ...rest
+}: WithTooltipStateProps) => React.JSX.Element>;
+declare const WithTooltip: (props: ComponentProps<typeof LazyWithTooltip>) => React.JSX.Element;
+declare const LazyWithTooltipPure: React.LazyExoticComponent<React.FC<WithTooltipPureProps>>;
+declare const WithTooltipPure: (props: ComponentProps<typeof LazyWithTooltipPure>) => React.JSX.Element;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/tooltip/TooltipMessage.d.ts
+interface TooltipMessageProps {
+  title?: ReactNode;
+  desc?: ReactNode;
+  links?: {
+    title: string;
+    href?: string;
+    onClick?: () => void;
+  }[];
+}
+declare const TooltipMessage: ({
+  title,
+  desc,
+  links
+}: TooltipMessageProps) => React.JSX.Element;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/tooltip/ListItem.d.ts
+interface ItemProps {
+  disabled?: boolean;
+  href?: string;
+  onClick?: (event: SyntheticEvent, ...args: any[]) => any;
+}
+type LinkWrapperType = (props: any) => ReactNode;
+interface ListItemProps extends ItemProps, Omit<ComponentProps<'button'>, 'title' | 'onClick' | 'ref'> {
+  loading?: boolean;
+  title?: ReactNode;
+  center?: ReactNode;
+  right?: ReactNode;
+  icon?: ReactNode;
+  input?: ReactNode;
+  active?: boolean;
+  disabled?: boolean;
+  href?: string;
+  LinkWrapper?: LinkWrapperType;
+  isIndented?: boolean;
+}
+declare const ListItem: React.ForwardRefExoticComponent<ListItemProps & React.RefAttributes<unknown>>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/tooltip/TooltipLinkList.d.ts
+interface NormalLink extends Omit<ListItemProps, 'onClick'> {
+  id: string;
+  onClick?: (event: SyntheticEvent, item: Pick<ListItemProps, 'id' | 'active' | 'disabled' | 'title' | 'href'>) => void;
+}
+type Link$1 = CustomLink | NormalLink;
+/**
+ * This is a custom link that can be used in the `TooltipLinkList` component. It allows for custom
+ * content to be rendered in the list; it does not have to be a link.
+ */
+interface CustomLink {
+  id: string;
+  content: ReactNode;
+}
+interface TooltipLinkListProps extends HTMLAttributes<HTMLDivElement> {
+  links: Link$1[] | Link$1[][];
+  LinkWrapper?: LinkWrapperType;
+}
+declare const TooltipLinkList: ({
+  links,
+  LinkWrapper,
+  ...props
+}: TooltipLinkListProps) => React.JSX.Element;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/Tabs/Tabs.d.ts
+declare const TabBar: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+interface TabWrapperProps {
+  active: boolean;
+  render?: () => ReactElement;
+  children?: ReactNode;
+}
+declare const TabWrapper: React.ForwardRefExoticComponent<TabWrapperProps & React.RefAttributes<HTMLDivElement>>;
+interface TabsProps {
+  children?: ReactElement<{
+    children: FC<Addon_RenderOptions & PropsWithChildren>;
+    title: ReactNode | FC<PropsWithChildren>;
+  }>[];
+  id?: string;
+  tools?: ReactNode;
+  showToolsWhenEmpty?: boolean;
+  emptyState?: ReactNode;
+  selected?: string;
+  actions?: {
+    onSelect: (id: string) => void;
+  } & Record<string, any>;
+  backgroundColor?: string;
+  absolute?: boolean;
+  bordered?: boolean;
+  menuName?: string;
+}
+declare const Tabs: FC<TabsProps>;
+interface TabsStateProps {
+  children: TabsProps['children'];
+  initial: string;
+  absolute: boolean;
+  bordered: boolean;
+  backgroundColor: string;
+  menuName: string;
+}
+interface TabsStateState {
+  selected: string;
+}
+declare class TabsState extends Component<TabsStateProps, TabsStateState> {
+  static defaultProps: TabsStateProps;
+  constructor(props: TabsStateProps);
+  handlers: {
+    onSelect: (id: string) => void;
+  };
+  render(): React.JSX.Element;
+}
+//#endregion
+//#region .dts-emit/code/core/src/components/components/Tabs/Button.d.ts
+interface TabButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+  active?: boolean;
+  children: ReactNode;
+  id?: string;
+  textColor?: string;
+}
+declare const TabButton: ForwardRefExoticComponent<TabButtonProps & RefAttributes<HTMLButtonElement>>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/Bar/Separator.d.ts
+interface SeparatorProps extends ComponentProps<'span'> {
+  force?: boolean;
+}
+declare function Separator({
+  force,
+  className,
+  ...props
+}: SeparatorProps): React.JSX.Element;
+declare namespace Separator {
+  var displayName: string;
+}
+declare const interleaveSeparators: (list: any[]) => any;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/Bar/Bar.d.ts
+interface BarProps extends ComponentProps<'div'> {
+  backgroundColor?: string;
+  border?: boolean;
+  className?: string;
+  children?: React.ReactNode;
+  scrollable?: boolean;
+  /** Inline styles for the element that holds the children. */
+  innerStyle?: CSSProperties;
+}
+declare const Bar: React.ForwardRefExoticComponent<Omit<BarProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface FlexBarProps extends BarProps {
+  border?: boolean;
+  backgroundColor?: string;
+}
+declare function FlexBar({
+  children,
+  backgroundColor,
+  className,
+  ...rest
+}: FlexBarProps): React.JSX.Element;
+declare namespace FlexBar {
+  var displayName: string;
+}
+//#endregion
+//#region .dts-emit/code/core/src/components/components/Tabs/EmptyTabContent.d.ts
+interface Props {
+  title: React.ReactNode;
+  description?: React.ReactNode;
+  footer?: React.ReactNode;
+}
+declare const EmptyTabContent: ({
+  title,
+  description,
+  footer
+}: Props) => React.JSX.Element;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/addon-panel/addon-panel.d.ts
+interface AddonPanelProps {
+  active: boolean;
+  children: ReactElement;
+  /** Whether the panel has a vertical scrollbar, `true` by default. */
+  hasScrollbar?: boolean;
+  /** Whether the panel has an horizontal scrollbar, `false` by default */
+  hasHorizontalScrollbar?: boolean;
+}
+declare const AddonPanel: ({
+  active,
+  children,
+  hasScrollbar,
+  hasHorizontalScrollbar
+}: AddonPanelProps) => React.JSX.Element;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/Toolbar/Toolbar.d.ts
+interface AbstractToolbarProps {
+  className?: string;
+  children?: React.ReactNode;
+  'aria-label'?: string;
+  'aria-labelledby'?: string;
+  lang?: string;
+}
+declare const AbstractToolbar: FC<AbstractToolbarProps>;
+interface ToolbarProps extends AbstractToolbarProps, BarProps {}
+declare const Toolbar: FC<ToolbarProps>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/Tabs/TabPanel.d.ts
+interface TabPanelProps extends HTMLAttributes<HTMLDivElement> {
+  /** The state of the tab list. Primary mechanism for using the tabpanel. */
+  state: TabsState$1;
+  /**
+   * Whether the panel adds a vertical scrollbar. Disable if you want to use fixed or sticky
+   * positioning on part of the tab's content. True by default.
+   */
+  hasScrollbar?: boolean;
+  /**
+   * Whether to render only the active tab's content, or all tabs. When true, non-selected tabs are
+   * rendered with the hidden attribute and do not affect the accessibility object model.
+   */
+  renderAllChildren?: boolean;
+}
+declare const TabPanel: FC<TabPanelProps>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/Tabs/TabsView.d.ts
+interface TabProps {
+  id: string;
+  'aria-label'?: string;
+  title: FC | ReactNode | string;
+  children?: FC | ReactNode;
+  isDisabled?: boolean;
+}
+interface useTabsStateProps {
+  defaultSelected?: string;
+  selected?: string;
+  onSelectionChange?: (key: string) => void;
+  tabs: TabProps[];
+}
+interface TabsState$1 {
+  tabs: TabProps[];
+  /** ID of the selected tab, or null when no tab can be selected. */
+  selected: string | null;
+  select: (key: string) => void;
+  getTabId: (key: string) => string;
+  getPanelId: (key: string) => string;
+}
+/** Shared state for a TabList and a TabPanel that render the same tabs. */
+declare const useTabsState: ({
+  defaultSelected,
+  onSelectionChange,
+  selected,
+  tabs
+}: useTabsStateProps) => TabsState$1;
+interface TabsViewProps extends HTMLAttributes<HTMLDivElement> {
+  /** List of tabs and their associated panel. */
+  tabs: TabProps[];
+  /** ID of the tab that should be selected on first render. */
+  defaultSelected?: string;
+  /** ID of the current tab if in controlled rendering mode. */
+  selected?: string;
+  /** Called when the selected tab changes, use if you want to control the component state. */
+  onSelectionChange?: (key: string) => void;
+  /**
+   * Optional tools to avoid rendering two toolbars in a layout.
+   *
+   * @warning Only use this if the tools act upon the entire layout,
+   * not upon a single tab panel. If you want to edit which tools are
+   * visible based on the current tab, then you musn't use `tools` and
+   * should handle your own toolbar inside the tabpanel instead.
+   */
+  tools?: ReactElement;
+  /** Background color for the bar containing the tabs and tools. */
+  backgroundColor?: string;
+  /** Style properties for the inner layout container in the bar containing the tabs and tools. */
+  barInnerStyle?: React.CSSProperties;
+  /** Show tools instead of the empty state if there are no tabs. */
+  showToolsWhenEmpty?: boolean;
+  /** Custom UI for the empty state shown when there are no tabs. */
+  emptyState?: ReactNode;
+  /** Optional ID. */
+  id?: string;
+  /** Props to pass to the TabPanel component. */
+  panelProps?: Omit<ComponentProps<typeof TabPanel>, 'state'>;
+}
+declare const TabsView: FC<TabsViewProps>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/Tabs/TabList.d.ts
+interface TabListProps extends HTMLAttributes<HTMLDivElement> {
+  state: TabsState$1;
+}
+declare const TabList: FC<TabListProps>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/Tabs/StatelessTabList.d.ts
+interface StatelessTabListProps {
+  children?: ReactNode;
+}
+declare const StatelessTabList: FC<StatelessTabListProps>;
+//#endregion
+//#region ../../node_modules/@base-ui/react/internals/reason-parts.d.mts
+declare const none: 'none';
+declare const triggerPress: 'trigger-press';
+declare const triggerHover: 'trigger-hover';
+declare const triggerFocus: 'trigger-focus';
+declare const outsidePress: 'outside-press';
+declare const itemPress: 'item-press';
+declare const closePress: 'close-press';
+declare const linkPress: 'link-press';
+declare const clearPress: 'clear-press';
+declare const chipRemovePress: 'chip-remove-press';
+declare const trackPress: 'track-press';
+declare const incrementPress: 'increment-press';
+declare const decrementPress: 'decrement-press';
+declare const inputChange: 'input-change';
+declare const inputClear: 'input-clear';
+declare const inputBlur: 'input-blur';
+declare const inputPaste: 'input-paste';
+declare const inputPress: 'input-press';
+declare const focusOut: 'focus-out';
+declare const escapeKey: 'escape-key';
+declare const closeWatcher: 'close-watcher';
+declare const listNavigation: 'list-navigation';
+declare const keyboard: 'keyboard';
+declare const pointer: 'pointer';
+declare const drag: 'drag';
+declare const wheel: 'wheel';
+declare const scrub: 'scrub';
+declare const cancelOpen: 'cancel-open';
+declare const siblingOpen: 'sibling-open';
+declare const disabled$1: 'disabled';
+declare const missing: 'missing';
+declare const initial: 'initial';
+declare const imperativeAction: 'imperative-action';
+declare const swipe: 'swipe';
+declare const windowResize: 'window-resize';
+//#endregion
+//#region ../../node_modules/@base-ui/react/internals/createBaseUIEventDetails.d.mts
+interface ReasonToEventMap {
+  [none]: Event;
+  [triggerPress]: MouseEvent | PointerEvent | TouchEvent | KeyboardEvent;
+  [triggerHover]: MouseEvent;
+  [triggerFocus]: FocusEvent;
+  [outsidePress]: MouseEvent | PointerEvent | TouchEvent;
+  [itemPress]: MouseEvent | KeyboardEvent | PointerEvent;
+  [closePress]: MouseEvent | KeyboardEvent | PointerEvent;
+  [linkPress]: MouseEvent | PointerEvent;
+  [clearPress]: PointerEvent | MouseEvent | KeyboardEvent;
+  [chipRemovePress]: PointerEvent | MouseEvent | KeyboardEvent;
+  [trackPress]: PointerEvent | MouseEvent | TouchEvent;
+  [incrementPress]: PointerEvent | MouseEvent | TouchEvent;
+  [decrementPress]: PointerEvent | MouseEvent | TouchEvent;
+  [inputChange]: InputEvent | Event;
+  [inputClear]: InputEvent | FocusEvent | Event;
+  [inputBlur]: FocusEvent;
+  [inputPaste]: ClipboardEvent;
+  [inputPress]: MouseEvent | PointerEvent | TouchEvent | KeyboardEvent;
+  [focusOut]: FocusEvent | KeyboardEvent;
+  [escapeKey]: KeyboardEvent;
+  [closeWatcher]: Event;
+  [listNavigation]: KeyboardEvent;
+  [keyboard]: KeyboardEvent;
+  [pointer]: PointerEvent;
+  [drag]: PointerEvent | TouchEvent;
+  [swipe]: PointerEvent | TouchEvent;
+  [wheel]: WheelEvent;
+  [scrub]: PointerEvent;
+  [cancelOpen]: MouseEvent;
+  [siblingOpen]: Event;
+  [disabled$1]: Event;
+  [missing]: Event;
+  [initial]: Event;
+  [imperativeAction]: Event;
+  [windowResize]: UIEvent;
+}
+/**
+ * Maps a change `reason` string to the corresponding native event type.
+ */
+type ReasonToEvent<Reason extends string> = Reason extends keyof ReasonToEventMap ? ReasonToEventMap[Reason] : Event;
+type BaseUIChangeEventDetail<Reason extends string, CustomProperties extends object> = {
+  /**
+   * The reason for the event.
+   */
+  reason: Reason;
+  /**
+   * The native event associated with the custom event.
+   */
+  event: ReasonToEvent<Reason>;
+  /**
+   * Cancels Base UI from handling the event.
+   */
+  cancel: () => void;
+  /**
+   * Allows the event to propagate in cases where Base UI will stop the propagation.
+   */
+  allowPropagation: () => void;
+  /**
+   * Indicates whether the event has been canceled.
+   */
+  isCanceled: boolean;
+  /**
+   * Indicates whether the event is allowed to propagate.
+   */
+  isPropagationAllowed: boolean;
+  /**
+   * The element that triggered the event, if applicable.
+   */
+  trigger: Element | undefined;
+} & CustomProperties;
+/**
+ * Details of custom change events emitted by Base UI components.
+ */
+type BaseUIChangeEventDetails<Reason extends string, CustomProperties extends object = {}> = Reason extends string ? BaseUIChangeEventDetail<Reason, CustomProperties> & {} : never;
+//#endregion
+//#region ../../node_modules/@base-ui/react/types/index.d.mts
+type HTMLProps<T = any> = React$1.HTMLAttributes<T> & {
+  ref?: React$1.Ref<T> | undefined;
+};
+/**
+ * Shape of the render prop: a function that takes props to be spread on the element and component's state and returns a React element.
+ *
+ * @template Props Props to be spread on the rendered element.
+ * @template State Component's internal state.
+ */
+type ComponentRenderFn<Props, State> = (props: Props, state: State) => React$1.ReactElement<unknown>;
+type BaseUIEvent<E extends React$1.SyntheticEvent<Element, Event>> = E & {
+  preventBaseUIHandler: () => void;
+  readonly baseUIHandlerPrevented?: boolean | undefined;
+};
+//#endregion
+//#region ../../node_modules/@base-ui/react/internals/types.d.mts
+type WithPreventBaseUIHandler<T> = T extends ((event: infer E) => any) ? E extends React$1.SyntheticEvent<Element, Event> ? (event: BaseUIEvent<E>) => ReturnType<T> : T : T extends undefined ? undefined : T;
+/**
+ * Adds a `preventBaseUIHandler` method to all event handlers.
+ */
+type WithBaseUIEvent<T> = { [K in keyof T]: WithPreventBaseUIHandler<T[K]> };
+/**
+ * Props shared by all Base UI components.
+ * Contains `className` (string or callback taking the component's state as an argument) and `render` (function to customize rendering).
+ */
+type BaseUIComponentProps<ElementType extends React$1.ElementType, State, RenderFunctionProps = HTMLProps> = Omit<WithBaseUIEvent<React$1.ComponentPropsWithRef<ElementType>>, 'className' | 'color' | 'defaultValue' | 'defaultChecked' | 'style'> & {
+  /**
+   * CSS class applied to the element, or a function that
+   * returns a class based on the component's state.
+   */
+  className?: string | ((state: State) => string | undefined) | undefined;
+  /**
+   * Allows you to replace the component's HTML element
+   * with a different tag, or compose it with another component.
+   *
+   * Accepts a `ReactElement` or a function that returns the element to render.
+   */
+  render?: React$1.ReactElement | ComponentRenderFn<RenderFunctionProps, State> | undefined;
+  /**
+   * Style applied to the element, or a function that
+   * returns a style object based on the component's state.
+   */
+  style?: React$1.CSSProperties | ((state: State) => React$1.CSSProperties | undefined) | undefined;
+};
+interface NativeButtonProps {
+  /**
+   * Whether the component renders a native `<button>` element when replacing it
+   * via the `render` prop.
+   * Set to `false` if the rendered element is not a button (for example, `<div>`).
+   * @default true
+   */
+  nativeButton?: boolean | undefined;
+}
+type Orientation = 'horizontal' | 'vertical';
+//#endregion
+//#region ../../node_modules/@base-ui/react/tabs/tab/TabsTab.d.mts
+/**
+ * An individual interactive tab button that toggles the corresponding panel.
+ * Renders a `<button>` element.
+ *
+ * Documentation: [Base UI Tabs](https://base-ui.com/react/components/tabs)
+ */
+declare const TabsTab: React$1.ForwardRefExoticComponent<Omit<TabsTabProps, "ref"> & React$1.RefAttributes<HTMLElement>>;
+type TabsTabValue = any | null;
+type TabsTabActivationDirection = 'left' | 'right' | 'up' | 'down' | 'none';
+interface TabsTabPosition {
+  left: number;
+  right: number;
+  top: number;
+  bottom: number;
+}
+interface TabsTabSize {
+  width: number;
+  height: number;
+}
+interface TabsTabMetadata {
+  disabled: boolean;
+  id: string | undefined;
+  value: TabsTab.Value | undefined;
+}
+interface TabsTabState {
+  /**
+   * Whether the component should ignore user interaction.
+   */
+  disabled: boolean;
+  /**
+   * Whether the component is active.
+   */
+  active: boolean;
+  /**
+   * The component orientation.
+   */
+  orientation: TabsRoot.Orientation;
+  /**
+   * The direction used for tab activation.
+   */
+  tabActivationDirection: TabsTab.ActivationDirection;
+}
+interface TabsTabProps extends NativeButtonProps, BaseUIComponentProps<'button', TabsTabState> {
+  /**
+   * The value of the Tab.
+   */
+  value: TabsTab.Value;
+  /**
+   * Whether the Tab is disabled.
+   *
+   * If a first Tab on a `<Tabs.List>` is disabled, it won't initially be selected.
+   * Instead, the next enabled Tab will be selected.
+   * However, it does not work like this during server-side rendering, as it is not known
+   * during pre-rendering which Tabs are disabled.
+   * To work around it, ensure that `defaultValue` or `value` on `<Tabs.Root>` is set to an enabled Tab's value.
+   */
+  disabled?: boolean | undefined;
+}
+declare namespace TabsTab {
+  type Value = TabsTabValue;
+  type ActivationDirection = TabsTabActivationDirection;
+  type Position = TabsTabPosition;
+  type Size = TabsTabSize;
+  type Metadata = TabsTabMetadata;
+  type State = TabsTabState;
+  type Props = TabsTabProps;
+}
+//#endregion
+//#region ../../node_modules/@base-ui/react/tabs/root/TabsRoot.d.mts
+/**
+ * Groups the tabs and the corresponding panels.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Tabs](https://base-ui.com/react/components/tabs)
+ */
+declare const TabsRoot: React$1.ForwardRefExoticComponent<Omit<TabsRootProps, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+type TabsRootOrientation = Orientation;
+interface TabsRootState {
+  /**
+   * The component orientation.
+   */
+  orientation: TabsRoot.Orientation;
+  /**
+   * The direction used for tab activation.
+   */
+  tabActivationDirection: TabsTab.ActivationDirection;
+}
+interface TabsRootProps extends BaseUIComponentProps<'div', TabsRootState> {
+  /**
+   * The value of the currently active `Tab`. Use when the component is controlled.
+   * When the value is `null`, no Tab will be active.
+   */
+  value?: TabsTab.Value | undefined;
+  /**
+   * The default value. Use when the component is not controlled.
+   * When the value is `null`, no Tab will be active.
+   * @default 0
+   */
+  defaultValue?: TabsTab.Value | undefined;
+  /**
+   * The component orientation (layout flow direction).
+   * @default 'horizontal'
+   */
+  orientation?: TabsRoot.Orientation | undefined;
+  /**
+   * Callback invoked when new value is being set.
+   *
+   * The event `reason` is `'none'` for user-initiated changes, such as a click
+   * or keyboard navigation; `'initial'` for the first automatic selection or
+   * fallback in uncontrolled roots when `defaultValue` is omitted or
+   * `undefined`, including when the implicit initial value is disabled or
+   * missing; `'disabled'` for automatic fallback when the selected tab becomes
+   * disabled in uncontrolled roots; or `'missing'` for automatic fallback when
+   * the selected tab is removed, or when an explicit `defaultValue` never
+   * matches a mounted tab in uncontrolled roots.
+   *
+   * For automatic changes, the selected value can be `null` when no enabled Tab
+   * is available as a fallback.
+   *
+   * Automatic changes cannot be canceled; calling `eventDetails.cancel()` for
+   * `'initial'`, `'disabled'`, or `'missing'` has no effect.
+   */
+  onValueChange?: ((value: TabsTab.Value, eventDetails: TabsRoot.ChangeEventDetails) => void) | undefined;
+}
+type TabsRootChangeEventReason = typeof none | typeof disabled$1 | typeof missing | typeof initial;
+type TabsRootChangeEventDetails = BaseUIChangeEventDetails<TabsRoot.ChangeEventReason, {
+  activationDirection: TabsTab.ActivationDirection;
+}>;
+declare namespace TabsRoot {
+  type State = TabsRootState;
+  type Props = TabsRootProps;
+  type Orientation = TabsRootOrientation;
+  type ChangeEventReason = TabsRootChangeEventReason;
+  type ChangeEventDetails = TabsRootChangeEventDetails;
+}
+//#endregion
+//#region ../../node_modules/@base-ui/react/internals/useTransitionStatus.d.mts
+type TransitionStatus = 'starting' | 'ending' | 'idle' | undefined;
+//#endregion
+//#region ../../node_modules/@base-ui/react/tabs/panel/TabsPanel.d.mts
+/**
+ * A panel displayed when the corresponding tab is active.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Tabs](https://base-ui.com/react/components/tabs)
+ */
+declare const TabsPanel: React$1.ForwardRefExoticComponent<Omit<TabsPanelProps, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+interface TabsPanelMetadata {
+  id?: string | undefined;
+  value: TabsTab.Value;
+}
+interface TabsPanelState extends TabsRootState {
+  /**
+   * Whether the component is hidden.
+   */
+  hidden: boolean;
+  /**
+   * The transition status of the component.
+   */
+  transitionStatus: TransitionStatus;
+}
+interface TabsPanelProps extends BaseUIComponentProps<'div', TabsPanelState> {
+  /**
+   * The value of the TabPanel. It will be shown when the Tab with the corresponding value is active.
+   */
+  value: TabsTab.Value;
+  /**
+   * Whether to keep the HTML element in the DOM while the panel is hidden.
+   * @default false
+   */
+  keepMounted?: boolean | undefined;
+}
+declare namespace TabsPanel {
+  type Metadata = TabsPanelMetadata;
+  type State = TabsPanelState;
+  type Props = TabsPanelProps;
+}
+//#endregion
+//#region .dts-emit/code/core/src/components/components/Tabs/StatelessTabPanel.d.ts
+interface StatelessTabPanelProps extends Omit<ComponentProps<typeof TabsPanel>, 'value' | 'children'> {
+  /** Content of the tab panel. */
+  children: ReactNode;
+  /** Unique id of the TabPanel, must match that of its corresponding Tab. */
+  name: string;
+  /**
+   * Whether the panel adds a vertical scrollbar. Disable if you want to use fixed or sticky
+   * positioning on part of the tab's content. True by default.
+   */
+  hasScrollbar?: boolean;
+}
+declare const StatelessTabPanel: FC<StatelessTabPanelProps>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/Tabs/StatelessTabsView.d.ts
+interface StatelessTabsViewProps extends Omit<TabsViewProps, 'tabs'> {
+  children: ReactNode;
+}
+declare const StatelessTabsView: FC<StatelessTabsViewProps>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/Tabs/StatelessTab.d.ts
+interface StatelessTabProps extends Omit<ComponentProps<typeof TabsTab>, 'value'> {
+  /** Unique id of the Tab, must match that of its corresponding TabPanel. */
+  name: string;
+  /** Tab button content */
+  children: React.ReactNode;
+}
+declare const StatelessTab: FC<StatelessTabProps>;
+//#endregion
+//#region .dts-emit/code/core/src/components/brand/StorybookLogo.d.ts
+type StorybookLogoProps = {
+  alt: string;
+} & React.SVGAttributes<SVGSVGElement>;
+declare const StorybookLogo: ({
+  alt,
+  ...props
+}: StorybookLogoProps) => React.JSX.Element;
+//#endregion
+//#region .dts-emit/code/core/src/components/brand/StorybookIcon.d.ts
+declare const StorybookIcon: (props: React.SVGAttributes<SVGElement>) => React.JSX.Element;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/Loader/Loader.d.ts
+interface Progress {
+  value: number;
+  message: string;
+  modules?: {
+    complete: number;
+    total: number;
+  };
+}
+interface LoaderProps extends React.HTMLAttributes<HTMLDivElement> {
+  progress?: Progress;
+  error?: Error;
+  size?: number;
+}
+declare const Loader: ({
+  progress,
+  error,
+  size,
+  ...props
+}: LoaderProps) => React.JSX.Element;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/ProgressSpinner/ProgressSpinner.d.ts
+interface ProgressSpinnerProps extends ComponentProps<'div'> {
+  percentage?: number;
+  running?: boolean;
+  size?: number;
+  width?: number;
+  children?: React.ReactNode;
+}
+declare const ProgressSpinner: ({
+  percentage,
+  running,
+  size,
+  width,
+  children,
+  className,
+  style,
+  ...props
+}: ProgressSpinnerProps) => React.JSX.Element;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/utils/getStoryHref.d.ts
+/** @deprecated Use the api.getStoryHrefs method instead (from `@aussieljk/forkbook/manager-api`) */
+declare const getStoryHref: (baseUrl: string, storyId: string, additionalParams?: Record<string, string>) => string;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/typography/DocumentFormatting.d.ts
+declare const nameSpaceClassNames: ({
+  ...props
+}: {
+  [x: string]: any;
+}, key: string) => {
+  [x: string]: any;
+};
+//#endregion
+//#region .dts-emit/code/core/src/components/components/typography/ResetWrapper.d.ts
+/**
+ * This is a "local" reset to style subtrees with Forkbook styles
+ *
+ * We can't style individual elements (e.g. h1, h2, etc.) in here because the CSS specificity is too
+ * high, so those styles can too easily override child elements that are not expecting it.
+ */
+declare const ResetWrapper: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region .dts-emit/code/core/src/components/components/clipboard/ClipboardCode.d.ts
+interface ClipboardCodeProps {
+  code: string;
+}
+declare const ClipboardCode: ({
+  code,
+  ...props
+}: ClipboardCodeProps) => React.JSX.Element;
+//#endregion
+//#region .dts-emit/code/core/src/shared/useCopyButton.d.ts
+interface UseCopyButtonOptions<T> {
+  /** Content shown in the button by default. */
+  children?: T;
+  /** Content shown in the button for `duration` ms after a successful copy. */
+  childrenOnCopy?: T;
+  /** Text written to the clipboard when the button is clicked. */
+  content: string;
+  /** Optional side-effect called after the text is successfully written to the clipboard. */
+  onCopy?: (e: SyntheticEvent) => void;
+  /** aria-label for the button in its default state. Pass `false` to suppress. */
+  ariaLabel?: false | string;
+  /** aria-label for the button while in its "copied" state. Pass `false` to suppress. */
+  ariaLabelOnCopy?: false | string;
+  /** Duration in milliseconds to show the copied state. Defaults to 3000. */
+  duration?: number;
+}
+interface UseCopyButtonResult<T> {
+  /** Current label/icon — switches to `childrenOnCopy` after a copy. */
+  children: T;
+  /** Props to spread onto the `<Button>` element. */
+  buttonProps: {
+    onClick: (e: SyntheticEvent) => void;
+    ariaLabel: false | string;
+  };
+}
+declare function useCopyButton<T extends ReactNode>({
+  children,
+  childrenOnCopy,
+  content,
+  onCopy,
+  ariaLabel,
+  ariaLabelOnCopy,
+  duration
+}: UseCopyButtonOptions<T>): UseCopyButtonResult<T>;
+//#endregion
+//#region .dts-emit/code/core/src/shared/announce.d.ts
+/**
+ * A small screen reader announcer. It keeps one visually hidden live region per politeness level
+ * at the end of the document body, and puts each message in it for a short time.
+ */
+type Politeness = 'polite' | 'assertive';
+/** Announces a message to screen readers. */
+declare function announce(message: string, politeness?: Politeness): void;
+/** Removes all messages of one politeness level. */
+declare function clearAnnouncer(politeness: Politeness): void;
+/** Removes the live regions from the document. Use it to reset state between tests. */
+declare function destroyAnnouncer(): void;
+//#endregion
+//#region .dts-emit/code/core/src/components/index.d.ts
+declare const components: {
+  h1: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>) => import("react").JSX.Element;
+  h2: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>) => import("react").JSX.Element;
+  h3: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>) => import("react").JSX.Element;
+  h4: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>) => import("react").JSX.Element;
+  h5: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>) => import("react").JSX.Element;
+  h6: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>) => import("react").JSX.Element;
+  pre: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLPreElement>, HTMLPreElement>) => import("react").JSX.Element;
+  a: (props: import("react").DetailedHTMLProps<import("react").AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>) => import("react").JSX.Element;
+  hr: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHRElement>, HTMLHRElement>) => import("react").JSX.Element;
+  dl: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDListElement>, HTMLDListElement>) => import("react").JSX.Element;
+  blockquote: (props: import("react").DetailedHTMLProps<import("react").BlockquoteHTMLAttributes<HTMLElement>, HTMLElement>) => import("react").JSX.Element;
+  table: (props: import("react").DetailedHTMLProps<import("react").TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>) => import("react").JSX.Element;
+  img: (props: import("react").DetailedHTMLProps<import("react").ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>) => import("react").JSX.Element;
+  div: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>) => import("react").JSX.Element;
+  span: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>) => import("react").JSX.Element;
+  li: (props: import("react").DetailedHTMLProps<import("react").LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>) => import("react").JSX.Element;
+  ul: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLUListElement>, HTMLUListElement>) => import("react").JSX.Element;
+  ol: (props: import("react").DetailedHTMLProps<import("react").OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>) => import("react").JSX.Element;
+  p: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>) => import("react").JSX.Element;
+  code: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLElement>, HTMLElement>) => import("react").JSX.Element;
+  tt: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLTitleElement>, HTMLTitleElement>) => import("react").JSX.Element;
+  resetwrapper: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>) => import("react").JSX.Element;
+};
+declare const resetComponents: Record<string, ElementType>;
+//#endregion
+export { A, AbstractToolbar, ActionBar, type ActionItem, ActionList, AddonPanel, Badge, Bar, type BarProps, Blockquote, Button, type ButtonProps, Card, ClipboardCode, Code, Collapsible, DL, Div, DocumentWrapper, EmptyTabContent, ErrorFormatter, FlexBar, Form, H1, H2, H3, H4, H5, H6, HR, IconButton, Img, LI, Link, ListItem, Loader, Modal, ModalDecorator, OL, P, Placeholder, Popover, type PopoverProps, PopoverProvider, type PopoverProviderProps, type PopperPlacement, Pre, ProgressSpinner, ResetWrapper, ScrollArea, Select, Separator, Spaced, Span, StatelessTab, StatelessTabList, type StatelessTabListProps, StatelessTabPanel, type StatelessTabPanelProps, type StatelessTabProps, StatelessTabsView, type StatelessTabsViewProps, StorybookIcon, StorybookLogo, type SupportedLanguage, SyntaxHighlighter, type SyntaxHighlighterFormatTypes, type SyntaxHighlighterProps, TT, TabBar, TabButton, TabList, type TabListProps, TabPanel, type TabPanelProps, type TabProps, TabWrapper, Table, Tabs, TabsState, TabsView, type TabsViewProps, ToggleButton, Toolbar, Tooltip, TooltipLinkList, type Link$1 as TooltipLinkListLink, TooltipMessage, TooltipNote, type TooltipNoteProps, type TooltipProps, TooltipProvider, type TooltipProviderProps, UL, type UseCopyButtonOptions, type UseCopyButtonResult, WithTooltip, WithTooltipPure, Zoom, announce, clearAnnouncer, codeCommon, components, convertToBaseUiPlacement, createCopyToClipboardFunction, destroyAnnouncer, getStoryHref, interleaveSeparators, nameSpaceClassNames, resetComponents, useCopyButton, useTabsState, withReset };