import * as react from 'react';
import react__default, { ComponentProps, MouseEvent, AnchorHTMLAttributes, ReactNode, ReactElement, ButtonHTMLAttributes, SyntheticEvent, Component, RefObject, FC, PropsWithChildren, RefAttributes, DetailedHTMLProps, ElementType } from 'react';
import * as _storybook_theming from '@storybook/theming';
import { FunctionInterpolation } from '@storybook/theming';
import * as Dialog from '@radix-ui/react-dialog';
import { Addon_RenderOptions } from '@storybook/types';

declare const A: _storybook_theming.StyledComponent<react.AnchorHTMLAttributes<HTMLAnchorElement> & {
    theme?: _storybook_theming.Theme;
}, {}, {}>;

declare const Blockquote: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements>;
}, react.DetailedHTMLProps<react.BlockquoteHTMLAttributes<HTMLQuoteElement>, HTMLQuoteElement>, {}>;

declare const DefaultCodeBlock: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react__default.ElementType<any, keyof react__default.JSX.IntrinsicElements>;
}, react__default.DetailedHTMLProps<react__default.HTMLAttributes<HTMLElement>, HTMLElement>, {}>;
declare const Code: ({ className, children, ...props }: ComponentProps<typeof DefaultCodeBlock>) => react__default.JSX.Element;

declare const Div: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements>;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

declare const DL: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements>;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDListElement>, HTMLDListElement>, {}>;

declare const H1: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements>;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, {}>;

declare const H2: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements>;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, {}>;

declare const H3: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements>;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, {}>;

declare const H4: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements>;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, {}>;

declare const H5: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements>;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, {}>;

declare const H6: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements>;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, {}>;

declare const HR: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements>;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLHRElement>, HTMLHRElement>, {}>;

declare const Img: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements>;
}, react.DetailedHTMLProps<react.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, {}>;

declare const LI: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements>;
}, react.DetailedHTMLProps<react.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, {}>;

declare const OL: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements>;
}, react.DetailedHTMLProps<react.OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>, {}>;

declare const P: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements>;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, {}>;

declare const Pre: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements>;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLPreElement>, HTMLPreElement>, {}>;

declare const Span: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements>;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, {}>;

declare const Table: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements>;
}, react.DetailedHTMLProps<react.TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>, {}>;

declare const TT: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements>;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLTitleElement>, HTMLTitleElement>, {}>;

declare const UL: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements>;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, {}>;

interface BadgeProps {
    status?: 'positive' | 'negative' | 'neutral' | 'warning' | 'critical';
    children?: react__default.ReactNode;
}
declare const Badge: ({ ...props }: BadgeProps) => react__default.JSX.Element;

interface LinkStylesProps {
    secondary?: boolean;
    tertiary?: boolean;
    nochrome?: boolean;
    inverse?: boolean;
    isButton?: boolean;
}
interface LinkInnerProps {
    withArrow?: boolean;
    containsIcon?: boolean;
}
type AProps = AnchorHTMLAttributes<HTMLAnchorElement>;
interface LinkProps$1 extends LinkInnerProps, LinkStylesProps, AProps {
    cancel?: boolean;
    className?: string;
    style?: object;
    onClick?: (e: MouseEvent) => void;
    href?: string;
}
declare const Link$1: ({ cancel, children, onClick, withArrow, containsIcon, className, style, ...rest }: LinkProps$1) => react__default.JSX.Element;

declare const DocumentWrapper: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements>;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

// Copied from `@types/prettier`
// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/5bb07fc4b087cb7ee91084afa6fe750551a7bbb1/types/prettier/index.d.ts


type BuiltInParserName =
  | "acorn"
  | "angular"
  | "babel-flow"
  | "babel-ts"
  | "babel"
  | "css"
  | "espree"
  | "flow"
  | "glimmer"
  | "graphql"
  | "html"
  | "json-stringify"
  | "json"
  | "json5"
  | "less"
  | "lwc"
  | "markdown"
  | "mdx"
  | "meriyah"
  | "scss"
  | "typescript"
  | "vue"
  | "yaml";

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 createCopyToClipboardFunction(): (text: string) => Promise<void>;

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' | BuiltInParserName;
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;

declare const LazySyntaxHighlighter: react__default.LazyExoticComponent<(props: SyntaxHighlighterBaseProps & SyntaxHighlighterCustomProps) => react__default.JSX.Element>;
declare const LazySyntaxHighlighterWithFormatter: react__default.LazyExoticComponent<(props: SyntaxHighlighterBaseProps & SyntaxHighlighterCustomProps) => react__default.JSX.Element>;
declare const SyntaxHighlighter: {
    (props: ComponentProps<typeof LazySyntaxHighlighter> | ComponentProps<typeof LazySyntaxHighlighterWithFormatter>): react__default.JSX.Element;
    registerLanguage(name: string, func: any): void;
};

interface ActionItem {
    title: string | ReactElement;
    className?: string;
    onClick: (e: MouseEvent<HTMLButtonElement>) => void;
    disabled?: boolean;
}
interface ActionBarProps {
    actionItems: ActionItem[];
}
declare const ActionBar: ({ actionItems, ...props }: ActionBarProps) => react__default.JSX.Element;

interface ButtonProps$1 extends ButtonHTMLAttributes<HTMLButtonElement> {
    asChild?: boolean;
    size?: 'small' | 'medium';
    padding?: 'small' | 'medium';
    variant?: 'outline' | 'solid' | 'ghost';
    onClick?: (event: SyntheticEvent) => void;
    disabled?: boolean;
    active?: boolean;
    animation?: 'none' | 'rotate360' | 'glow' | 'jiggle';
    /** @deprecated Use {@link asChild} instead. This will be removed in Storybook 9.0 */
    isLink?: boolean;
    /** @deprecated Use {@link variant} instead. This will be removed in Storybook 9.0 */
    primary?: boolean;
    /** @deprecated Use {@link variant} instead. This will be removed in Storybook 9.0 */
    secondary?: boolean;
    /** @deprecated Use {@link variant} instead. This will be removed in Storybook 9.0 */
    tertiary?: boolean;
    /** @deprecated Use {@link variant} instead. This will be removed in Storybook 9.0 */
    gray?: boolean;
    /** @deprecated Use {@link variant} instead. This will be removed in Storybook 9.0 */
    inForm?: boolean;
    /** @deprecated Use {@link size} instead. This will be removed in Storybook 9.0 */
    small?: boolean;
    /** @deprecated Use {@link variant} instead. This will be removed in Storybook 9.0 */
    outline?: boolean;
    /** @deprecated Add your icon as a child directly. This will be removed in Storybook 9.0 */
    containsIcon?: boolean;
}
declare const Button: react__default.ForwardRefExoticComponent<ButtonProps$1 & react__default.RefAttributes<HTMLButtonElement>>;

declare const IconButton: react__default.ForwardRefExoticComponent<ButtonProps$1 & react__default.RefAttributes<HTMLButtonElement>>;

declare const Overlay: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react__default.ElementType<any, keyof react__default.JSX.IntrinsicElements>;
}, react__default.DetailedHTMLProps<react__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
declare const Container: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react__default.ElementType<any, keyof react__default.JSX.IntrinsicElements>;
} & {
    width?: number;
    height?: number;
}, react__default.DetailedHTMLProps<react__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
declare const CloseButton: (props: react__default.ComponentProps<typeof IconButton>) => react__default.JSX.Element;
declare const Content: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react__default.ElementType<any, keyof react__default.JSX.IntrinsicElements>;
}, react__default.DetailedHTMLProps<react__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
declare const Row: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react__default.ElementType<any, keyof react__default.JSX.IntrinsicElements>;
}, react__default.DetailedHTMLProps<react__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
declare const Col: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react__default.ElementType<any, keyof react__default.JSX.IntrinsicElements>;
}, react__default.DetailedHTMLProps<react__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
declare const Header: (props: react__default.ComponentProps<typeof Col>) => react__default.JSX.Element;
declare const Title: _storybook_theming.StyledComponent<Dialog.DialogTitleProps & react__default.RefAttributes<HTMLHeadingElement> & {
    theme?: _storybook_theming.Theme;
}, {}, {}>;
declare const Description: _storybook_theming.StyledComponent<Dialog.DialogDescriptionProps & react__default.RefAttributes<HTMLParagraphElement> & {
    theme?: _storybook_theming.Theme;
}, {}, {}>;
declare const Actions: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react__default.ElementType<any, keyof react__default.JSX.IntrinsicElements>;
}, react__default.DetailedHTMLProps<react__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
declare const ErrorWrapper: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react__default.ElementType<any, keyof react__default.JSX.IntrinsicElements>;
}, react__default.DetailedHTMLProps<react__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
declare const Error$1: ({ children, ...props }: {
    children: react__default.ReactNode;
} & {
    theme?: _storybook_theming.Theme;
    as?: react__default.ElementType<any, keyof react__default.JSX.IntrinsicElements>;
} & react__default.ClassAttributes<HTMLDivElement> & react__default.HTMLAttributes<HTMLDivElement>) => react__default.JSX.Element;

declare const Components_Actions: typeof Actions;
declare const Components_CloseButton: typeof CloseButton;
declare const Components_Col: typeof Col;
declare const Components_Container: typeof Container;
declare const Components_Content: typeof Content;
declare const Components_Description: typeof Description;
declare const Components_ErrorWrapper: typeof ErrorWrapper;
declare const Components_Header: typeof Header;
declare const Components_Overlay: typeof Overlay;
declare const Components_Row: typeof Row;
declare const Components_Title: typeof Title;
declare namespace Components {
  export {
    Components_Actions as Actions,
    Components_CloseButton as CloseButton,
    Components_Col as Col,
    Components_Container as Container,
    Components_Content as Content,
    Components_Description as Description,
    Error$1 as Error,
    Components_ErrorWrapper as ErrorWrapper,
    Components_Header as Header,
    Components_Overlay as Overlay,
    Components_Row as Row,
    Components_Title as Title,
  };
}

type ContentProps = react__default.ComponentProps<typeof Dialog.Content>;
interface ModalProps extends Omit<react__default.ComponentProps<typeof Dialog.Root>, 'children'> {
    width?: number;
    height?: number;
    children: react__default.ReactNode;
    onEscapeKeyDown?: ContentProps['onEscapeKeyDown'];
    onInteractOutside?: ContentProps['onInteractOutside'];
    className?: string;
    container?: HTMLElement;
}
declare function BaseModal({ children, width, height, onEscapeKeyDown, onInteractOutside, className, container, ...rootProps }: ModalProps): react__default.JSX.Element;
declare const Modal: typeof BaseModal & typeof Components & {
    Dialog: typeof Dialog;
};

interface SpacedProps {
    children?: react__default.ReactNode;
    col?: number;
    row?: number;
    outer?: number | boolean;
}
declare const Spaced: ({ col, row, outer, children, ...rest }: SpacedProps) => react__default.JSX.Element;

interface PlaceholderProps {
    children?: react__default.ReactNode;
}
declare const Placeholder: ({ children, ...props }: PlaceholderProps) => react__default.JSX.Element;

interface ScrollAreaProps {
    children?: react__default.ReactNode;
    horizontal?: boolean;
    vertical?: boolean;
    className?: string;
    offset?: number;
    scrollbarSize?: number;
}
declare const ScrollArea: react__default.ForwardRefExoticComponent<ScrollAreaProps & react__default.RefAttributes<HTMLDivElement>>;

type ZoomProps = {
    scale: number;
    children: ReactElement | ReactElement[];
};
declare function ZoomElement({ scale, children }: ZoomProps): react__default.JSX.Element;

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__default.JSX.Element;
}

declare const Zoom: {
    Element: typeof ZoomElement;
    IFrame: typeof ZoomIFrame;
};

interface ErrorFormatterProps {
    error: Error;
}
declare const ErrorFormatter: ({ error }: ErrorFormatterProps) => react__default.JSX.Element;

/**
 * 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__default.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;
}
type Sizes = '100%' | 'flex' | 'auto';
type Alignments = 'end' | 'center' | 'start';
type ValidationStates = 'valid' | 'error' | 'warn';

interface FieldProps {
    children?: ReactNode;
    label?: ReactNode;
}

declare const Form: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements>;
}, react.DetailedHTMLProps<react.FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>, {}> & {
    Field: ({ label, children, ...props }: FieldProps) => react.JSX.Element;
    Input: _storybook_theming.StyledComponent<Omit<Omit<react.HTMLProps<HTMLInputElement>, "align" | "height" | "size" | "valid"> & {
        size?: Sizes;
        align?: Alignments;
        valid?: ValidationStates;
        height?: number;
    }, "ref"> & react.RefAttributes<any> & {
        theme?: _storybook_theming.Theme;
    } & {
        size?: Sizes;
        align?: Alignments;
        valid?: ValidationStates;
        height?: number;
    }, {}, {}> & {
        displayName: string;
    };
    Select: _storybook_theming.StyledComponent<Omit<react.SelectHTMLAttributes<HTMLSelectElement>, "align" | "height" | "size" | "valid"> & {
        size?: Sizes;
        align?: Alignments;
        valid?: ValidationStates;
        height?: number;
    } & react.RefAttributes<any> & {
        theme?: _storybook_theming.Theme;
    }, {}, {}> & {
        displayName: string;
    };
    Textarea: _storybook_theming.StyledComponent<Omit<Omit<TextareaAutosizeProps, "align" | "height" | "size" | "valid"> & {
        size?: Sizes;
        align?: Alignments;
        valid?: ValidationStates;
        height?: number;
    } & react.RefAttributes<HTMLTextAreaElement>, "ref"> & react.RefAttributes<any> & {
        theme?: _storybook_theming.Theme;
    } & Omit<TextareaAutosizeProps, "align" | "height" | "size" | "valid"> & {
        size?: Sizes;
        align?: Alignments;
        valid?: ValidationStates;
        height?: number;
    } & react.RefAttributes<HTMLTextAreaElement>, {}, {}> & {
        displayName: string;
    };
    Button: react.ForwardRefExoticComponent<ButtonProps$1 & react.RefAttributes<HTMLButtonElement>>;
};

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;

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 = {
    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;
};

declare const createPopper: <TModifier extends Partial<Modifier<any, any>>>(reference: Element | VirtualElement, popper: HTMLElement, options?: Partial<OptionsGeneric<TModifier>>) => Instance;

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> & {
    createPopper?: typeof createPopper;
};

declare const TargetContainer: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react__default.ElementType<any, keyof react__default.JSX.IntrinsicElements>;
} & {
    trigger: Config['trigger'];
}, react__default.DetailedHTMLProps<react__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
interface WithHideFn {
    onHide: () => void;
}
interface WithTooltipPureProps extends Omit<Config, 'closeOnOutsideClick'>, Omit<ComponentProps<typeof TargetContainer>, 'trigger'>, 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;
}
interface WithTooltipStateProps extends Omit<WithTooltipPureProps, 'onVisibleChange'> {
    startOpen?: boolean;
    onVisibleChange?: (visible: boolean) => void | boolean;
}

declare const LazyWithTooltip: react__default.LazyExoticComponent<({ startOpen, onVisibleChange: onChange, ...rest }: WithTooltipStateProps) => react__default.JSX.Element>;
declare const WithTooltip: (props: ComponentProps<typeof LazyWithTooltip>) => react__default.JSX.Element;
declare const LazyWithTooltipPure: react__default.LazyExoticComponent<({ svg, trigger, closeOnOutsideClick, placement, modifiers, hasChrome, defaultVisible, withArrows, offset, tooltip, children, closeOnTriggerHidden, mutationObserverOptions, delayHide, visible, interactive, delayShow, strategy, followCursor, onVisibleChange, ...props }: WithTooltipPureProps) => react__default.JSX.Element>;
declare const WithTooltipPure: (props: ComponentProps<typeof LazyWithTooltipPure>) => react__default.JSX.Element;

interface TooltipMessageProps {
    title?: ReactNode;
    desc?: ReactNode;
    links?: {
        title: string;
        href?: string;
        onClick?: () => void;
    }[];
}
declare const TooltipMessage: ({ title, desc, links }: TooltipMessageProps) => react__default.JSX.Element;

interface TooltipNoteProps {
    note: string;
}
declare const TooltipNote: ({ note, ...props }: TooltipNoteProps) => react__default.JSX.Element;

interface ItemProps {
    disabled?: boolean;
}
declare const Item: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react__default.ElementType<any, keyof react__default.JSX.IntrinsicElements>;
} & ItemProps, react__default.DetailedHTMLProps<react__default.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, {}>;
type LinkWrapperType = (props: any) => ReactNode;
interface ListItemProps extends Omit<ComponentProps<typeof Item>, 'href' | 'title'> {
    loading?: boolean;
    title?: ReactNode;
    center?: ReactNode;
    right?: ReactNode;
    icon?: ReactNode;
    active?: boolean;
    disabled?: boolean;
    href?: string;
    LinkWrapper?: LinkWrapperType;
    isIndented?: boolean;
}
declare const ListItem: ({ loading, title, center, right, active, disabled, isIndented, href, onClick, icon, LinkWrapper, ...rest }: ListItemProps) => react__default.JSX.Element;

interface Link extends Omit<ListItemProps, 'onClick'> {
    id: string;
    isGatsby?: boolean;
    onClick?: (event: SyntheticEvent, item: ListItemProps) => void;
}
interface TooltipLinkListProps {
    links: Link[];
    LinkWrapper?: LinkWrapperType;
}
declare const TooltipLinkList: ({ links, LinkWrapper }: TooltipLinkListProps) => react__default.JSX.Element;

declare const TabBar: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react__default.ElementType<any, keyof react__default.JSX.IntrinsicElements>;
}, react__default.DetailedHTMLProps<react__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
interface TabWrapperProps {
    active: boolean;
    render?: () => ReactElement;
    children?: ReactNode;
}
declare const TabWrapper: FC<TabWrapperProps>;
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__default.JSX.Element;
}

interface Props {
    title: react__default.ReactNode;
    description?: react__default.ReactNode;
    footer?: react__default.ReactNode;
}
declare const EmptyTabContent: ({ title, description, footer }: Props) => react__default.JSX.Element;

interface ButtonProps extends DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement> {
    href?: never;
    target?: never;
}
interface LinkProps extends DetailedHTMLProps<AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement> {
    disabled?: void;
    href: string;
}
interface TabButtonProps {
    active?: boolean;
    textColor?: string;
}
declare const TabButton: _storybook_theming.StyledComponent<(((Omit<ButtonProps, "ref"> & RefAttributes<HTMLButtonElement>) | (Omit<LinkProps, "ref"> & RefAttributes<HTMLAnchorElement>)) & {
    theme?: _storybook_theming.Theme;
}) & TabButtonProps, {}, {}>;
/**
 * @deprecated
 * This component will be removed in Storybook 9.0
 * */
declare const IconButtonSkeleton: () => react__default.JSX.Element;

interface SeparatorProps {
    force?: boolean;
}
declare const Separator: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react__default.ElementType<any, keyof react__default.JSX.IntrinsicElements>;
} & SeparatorProps, react__default.DetailedHTMLProps<react__default.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, {}>;
declare const interleaveSeparators: (list: any[]) => any;

interface UnstyledBarProps extends ScrollAreaProps {
    scrollable?: boolean;
}
interface BarProps extends UnstyledBarProps {
    border?: boolean;
}
declare const Bar: _storybook_theming.StyledComponent<UnstyledBarProps & {
    theme?: _storybook_theming.Theme;
} & BarProps, {}, {}>;
interface FlexBarProps extends ComponentProps<typeof Bar> {
    border?: boolean;
    backgroundColor?: string;
}
declare const FlexBar: {
    ({ children, backgroundColor, className, ...rest }: FlexBarProps): react__default.JSX.Element;
    displayName: string;
};

interface AddonPanelProps {
    active: boolean;
    children: ReactNode;
}
declare const AddonPanel: ({ active, children }: AddonPanelProps) => react__default.JSX.Element;

type IconType = keyof typeof icons;
declare const Svg: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react__default.ElementType<any, keyof react__default.JSX.IntrinsicElements>;
}, react__default.SVGProps<SVGSVGElement>, {}>;
interface IconsProps extends ComponentProps<typeof Svg> {
    icon: IconType;
    useSymbol?: boolean;
    onClick?: () => void;
    __suppressDeprecationWarning?: boolean;
}
/**
 * @deprecated No longer used, will be removed in Storybook 9.0
 * Please use the `@storybook/icons` package instead.
 * */
declare const Icons: ({ icon, useSymbol, __suppressDeprecationWarning, ...props }: IconsProps) => react__default.JSX.Element;
interface SymbolsProps {
    icons?: IconType[];
}
/**
 * @deprecated No longer used, will be removed in Storybook 9.0
 * Please use the `@storybook/icons` package instead.
 * */
declare const Symbols: react__default.NamedExoticComponent<SymbolsProps>;
declare const icons: {
    readonly user: "UserIcon";
    readonly useralt: "UserAltIcon";
    readonly useradd: "UserAddIcon";
    readonly users: "UsersIcon";
    readonly profile: "ProfileIcon";
    readonly facehappy: "FaceHappyIcon";
    readonly faceneutral: "FaceNeutralIcon";
    readonly facesad: "FaceSadIcon";
    readonly accessibility: "AccessibilityIcon";
    readonly accessibilityalt: "AccessibilityAltIcon";
    readonly arrowup: "ChevronUpIcon";
    readonly arrowdown: "ChevronDownIcon";
    readonly arrowleft: "ChevronLeftIcon";
    readonly arrowright: "ChevronRightIcon";
    readonly arrowupalt: "ArrowUpIcon";
    readonly arrowdownalt: "ArrowDownIcon";
    readonly arrowleftalt: "ArrowLeftIcon";
    readonly arrowrightalt: "ArrowRightIcon";
    readonly expandalt: "ExpandAltIcon";
    readonly collapse: "CollapseIcon";
    readonly expand: "ExpandIcon";
    readonly unfold: "UnfoldIcon";
    readonly transfer: "TransferIcon";
    readonly redirect: "RedirectIcon";
    readonly undo: "UndoIcon";
    readonly reply: "ReplyIcon";
    readonly sync: "SyncIcon";
    readonly upload: "UploadIcon";
    readonly download: "DownloadIcon";
    readonly back: "BackIcon";
    readonly proceed: "ProceedIcon";
    readonly refresh: "RefreshIcon";
    readonly globe: "GlobeIcon";
    readonly compass: "CompassIcon";
    readonly location: "LocationIcon";
    readonly pin: "PinIcon";
    readonly time: "TimeIcon";
    readonly dashboard: "DashboardIcon";
    readonly timer: "TimerIcon";
    readonly home: "HomeIcon";
    readonly admin: "AdminIcon";
    readonly info: "InfoIcon";
    readonly question: "QuestionIcon";
    readonly support: "SupportIcon";
    readonly alert: "AlertIcon";
    readonly email: "EmailIcon";
    readonly phone: "PhoneIcon";
    readonly link: "LinkIcon";
    readonly unlink: "LinkBrokenIcon";
    readonly bell: "BellIcon";
    readonly rss: "RSSIcon";
    readonly sharealt: "ShareAltIcon";
    readonly share: "ShareIcon";
    readonly circle: "CircleIcon";
    readonly circlehollow: "CircleHollowIcon";
    readonly bookmarkhollow: "BookmarkHollowIcon";
    readonly bookmark: "BookmarkIcon";
    readonly hearthollow: "HeartHollowIcon";
    readonly heart: "HeartIcon";
    readonly starhollow: "StarHollowIcon";
    readonly star: "StarIcon";
    readonly certificate: "CertificateIcon";
    readonly verified: "VerifiedIcon";
    readonly thumbsup: "ThumbsUpIcon";
    readonly shield: "ShieldIcon";
    readonly basket: "BasketIcon";
    readonly beaker: "BeakerIcon";
    readonly hourglass: "HourglassIcon";
    readonly flag: "FlagIcon";
    readonly cloudhollow: "CloudHollowIcon";
    readonly edit: "EditIcon";
    readonly cog: "CogIcon";
    readonly nut: "NutIcon";
    readonly wrench: "WrenchIcon";
    readonly ellipsis: "EllipsisIcon";
    readonly check: "CheckIcon";
    readonly form: "FormIcon";
    readonly batchdeny: "BatchDenyIcon";
    readonly batchaccept: "BatchAcceptIcon";
    readonly controls: "ControlsIcon";
    readonly plus: "PlusIcon";
    readonly closeAlt: "CloseAltIcon";
    readonly cross: "CrossIcon";
    readonly trash: "TrashIcon";
    readonly pinalt: "PinAltIcon";
    readonly unpin: "UnpinIcon";
    readonly add: "AddIcon";
    readonly subtract: "SubtractIcon";
    readonly close: "CloseIcon";
    readonly delete: "DeleteIcon";
    readonly passed: "PassedIcon";
    readonly changed: "ChangedIcon";
    readonly failed: "FailedIcon";
    readonly clear: "ClearIcon";
    readonly comment: "CommentIcon";
    readonly commentadd: "CommentAddIcon";
    readonly requestchange: "RequestChangeIcon";
    readonly comments: "CommentsIcon";
    readonly lock: "LockIcon";
    readonly unlock: "UnlockIcon";
    readonly key: "KeyIcon";
    readonly outbox: "OutboxIcon";
    readonly credit: "CreditIcon";
    readonly button: "ButtonIcon";
    readonly type: "TypeIcon";
    readonly pointerdefault: "PointerDefaultIcon";
    readonly pointerhand: "PointerHandIcon";
    readonly browser: "BrowserIcon";
    readonly tablet: "TabletIcon";
    readonly mobile: "MobileIcon";
    readonly watch: "WatchIcon";
    readonly sidebar: "SidebarIcon";
    readonly sidebaralt: "SidebarAltIcon";
    readonly sidebaralttoggle: "SidebarAltToggleIcon";
    readonly sidebartoggle: "SidebarToggleIcon";
    readonly bottombar: "BottomBarIcon";
    readonly bottombartoggle: "BottomBarToggleIcon";
    readonly cpu: "CPUIcon";
    readonly database: "DatabaseIcon";
    readonly memory: "MemoryIcon";
    readonly structure: "StructureIcon";
    readonly box: "BoxIcon";
    readonly power: "PowerIcon";
    readonly photo: "PhotoIcon";
    readonly component: "ComponentIcon";
    readonly grid: "GridIcon";
    readonly outline: "OutlineIcon";
    readonly photodrag: "PhotoDragIcon";
    readonly search: "SearchIcon";
    readonly zoom: "ZoomIcon";
    readonly zoomout: "ZoomOutIcon";
    readonly zoomreset: "ZoomResetIcon";
    readonly eye: "EyeIcon";
    readonly eyeclose: "EyeCloseIcon";
    readonly lightning: "LightningIcon";
    readonly lightningoff: "LightningOffIcon";
    readonly contrast: "ContrastIcon";
    readonly switchalt: "SwitchAltIcon";
    readonly mirror: "MirrorIcon";
    readonly grow: "GrowIcon";
    readonly paintbrush: "PaintBrushIcon";
    readonly ruler: "RulerIcon";
    readonly stop: "StopIcon";
    readonly camera: "CameraIcon";
    readonly video: "VideoIcon";
    readonly speaker: "SpeakerIcon";
    readonly play: "PlayIcon";
    readonly playback: "PlayBackIcon";
    readonly playnext: "PlayNextIcon";
    readonly rewind: "RewindIcon";
    readonly fastforward: "FastForwardIcon";
    readonly stopalt: "StopAltIcon";
    readonly sidebyside: "SideBySideIcon";
    readonly stacked: "StackedIcon";
    readonly sun: "SunIcon";
    readonly moon: "MoonIcon";
    readonly book: "BookIcon";
    readonly document: "DocumentIcon";
    readonly copy: "CopyIcon";
    readonly category: "CategoryIcon";
    readonly folder: "FolderIcon";
    readonly print: "PrintIcon";
    readonly graphline: "GraphLineIcon";
    readonly calendar: "CalendarIcon";
    readonly graphbar: "GraphBarIcon";
    readonly menu: "MenuIcon";
    readonly menualt: "MenuIcon";
    readonly filter: "FilterIcon";
    readonly docchart: "DocChartIcon";
    readonly doclist: "DocListIcon";
    readonly markup: "MarkupIcon";
    readonly bold: "BoldIcon";
    readonly paperclip: "PaperClipIcon";
    readonly listordered: "ListOrderedIcon";
    readonly listunordered: "ListUnorderedIcon";
    readonly paragraph: "ParagraphIcon";
    readonly markdown: "MarkdownIcon";
    readonly repository: "RepoIcon";
    readonly commit: "CommitIcon";
    readonly branch: "BranchIcon";
    readonly pullrequest: "PullRequestIcon";
    readonly merge: "MergeIcon";
    readonly apple: "AppleIcon";
    readonly linux: "LinuxIcon";
    readonly ubuntu: "UbuntuIcon";
    readonly windows: "WindowsIcon";
    readonly storybook: "StorybookIcon";
    readonly azuredevops: "AzureDevOpsIcon";
    readonly bitbucket: "BitbucketIcon";
    readonly chrome: "ChromeIcon";
    readonly chromatic: "ChromaticIcon";
    readonly componentdriven: "ComponentDrivenIcon";
    readonly discord: "DiscordIcon";
    readonly facebook: "FacebookIcon";
    readonly figma: "FigmaIcon";
    readonly gdrive: "GDriveIcon";
    readonly github: "GithubIcon";
    readonly gitlab: "GitlabIcon";
    readonly google: "GoogleIcon";
    readonly graphql: "GraphqlIcon";
    readonly medium: "MediumIcon";
    readonly redux: "ReduxIcon";
    readonly twitter: "TwitterIcon";
    readonly youtube: "YoutubeIcon";
    readonly vscode: "VSCodeIcon";
};

type StorybookLogoProps = {
    alt: string;
} & react__default.SVGAttributes<SVGSVGElement>;
declare const StorybookLogo: ({ alt, ...props }: StorybookLogoProps) => react__default.JSX.Element;

declare const StorybookIcon: (props: react__default.SVGAttributes<SVGElement>) => react__default.JSX.Element;

interface Progress {
    value: number;
    message: string;
    modules?: {
        complete: number;
        total: number;
    };
}
interface LoaderProps extends react__default.HTMLAttributes<HTMLDivElement> {
    progress?: Progress;
    error?: Error;
    size?: number;
}
declare const Loader: ({ progress, error, size, ...props }: LoaderProps) => react__default.JSX.Element;

declare const getStoryHref: (baseUrl: string, storyId: string, additionalParams?: Record<string, string>) => string;

declare const nameSpaceClassNames: ({ ...props }: {
    [x: string]: any;
}, key: string) => {
    [x: string]: any;
};

/**
 * This is a "local" reset to style subtrees with Storybook 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: _storybook_theming.StyledComponent<{
    theme?: _storybook_theming.Theme;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements>;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

declare const codeCommon: FunctionInterpolation;
declare const withReset: FunctionInterpolation;

interface ClipboardCodeProps {
    code: string;
}
declare const ClipboardCode: ({ code, ...props }: ClipboardCodeProps) => react__default.JSX.Element;

declare const components: {
    h1: (props: react.DetailedHTMLProps<react.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>) => react.JSX.Element;
    h2: (props: react.DetailedHTMLProps<react.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>) => react.JSX.Element;
    h3: (props: react.DetailedHTMLProps<react.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>) => react.JSX.Element;
    h4: (props: react.DetailedHTMLProps<react.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>) => react.JSX.Element;
    h5: (props: react.DetailedHTMLProps<react.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>) => react.JSX.Element;
    h6: (props: react.DetailedHTMLProps<react.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>) => react.JSX.Element;
    pre: (props: react.DetailedHTMLProps<react.HTMLAttributes<HTMLPreElement>, HTMLPreElement>) => react.JSX.Element;
    a: (props: react.DetailedHTMLProps<react.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>) => react.JSX.Element;
    hr: (props: react.DetailedHTMLProps<react.HTMLAttributes<HTMLHRElement>, HTMLHRElement>) => react.JSX.Element;
    dl: (props: react.DetailedHTMLProps<react.HTMLAttributes<HTMLDListElement>, HTMLDListElement>) => react.JSX.Element;
    blockquote: (props: react.DetailedHTMLProps<react.BlockquoteHTMLAttributes<HTMLElement>, HTMLElement>) => react.JSX.Element;
    table: (props: react.DetailedHTMLProps<react.TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>) => react.JSX.Element;
    img: (props: react.DetailedHTMLProps<react.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>) => react.JSX.Element;
    div: (props: react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>) => react.JSX.Element;
    span: (props: react.DetailedHTMLProps<react.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>) => react.JSX.Element;
    li: (props: react.DetailedHTMLProps<react.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>) => react.JSX.Element;
    ul: (props: react.DetailedHTMLProps<react.HTMLAttributes<HTMLUListElement>, HTMLUListElement>) => react.JSX.Element;
    ol: (props: react.DetailedHTMLProps<react.OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>) => react.JSX.Element;
    p: (props: react.DetailedHTMLProps<react.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>) => react.JSX.Element;
    code: (props: react.DetailedHTMLProps<react.HTMLAttributes<HTMLElement>, HTMLElement>) => react.JSX.Element;
    tt: (props: react.DetailedHTMLProps<react.HTMLAttributes<HTMLTitleElement>, HTMLTitleElement>) => react.JSX.Element;
    resetwrapper: (props: react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>) => react.JSX.Element;
};
declare const resetComponents: Record<string, ElementType>;

export { A, ActionBar, ActionItem, AddonPanel, Badge, Bar, Blockquote, Button, ClipboardCode, Code, DL, Div, DocumentWrapper, EmptyTabContent, ErrorFormatter, FlexBar, Form, H1, H2, H3, H4, H5, H6, HR, IconButton, IconButtonSkeleton, Icons, IconsProps, Img, LI, Link$1 as Link, ListItem, Loader, Modal, OL, P, Placeholder, Pre, ResetWrapper, ScrollArea, Separator, Spaced, Span, StorybookIcon, StorybookLogo, SupportedLanguage, Symbols, SyntaxHighlighter, SyntaxHighlighterFormatTypes, SyntaxHighlighterProps, SyntaxHighlighterRendererProps, TT, TabBar, TabButton, TabWrapper, Table, Tabs, TabsState, TooltipLinkList, Link as TooltipLinkListLink, TooltipMessage, TooltipNote, UL, WithTooltip, WithTooltipPure, Zoom, codeCommon, components, createCopyToClipboardFunction, getStoryHref, icons, interleaveSeparators, nameSpaceClassNames, resetComponents, withReset };