@acmekit/docs-ui 2.13.41

package/dist/index.d.ts

@@ -0,0 +1,1550 @@
+import React$1, { ReactElement, ReactNode, ComponentProps } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { IconProps } from '@acmekit/icons/dist/types';
+import { LinkProps as LinkProps$1 } from 'react-router-dom';
+import { HighlightProps as HighlightProps$1, LineInputProps, LineOutputProps, TokenInputProps, TokenOutputProps, Token } from 'prism-react-renderer';
+import { Options as Options$1, Components } from 'react-markdown';
+import { MDXComponents as MDXComponents$1 } from 'mdx/types';
+import { Tabs as Tabs$1, Switch } from '@acmekit/ui';
+import { ITooltip } from 'react-tooltip';
+
+type BreadcrumbOptions = {
+    startItems?: {
+        title: string;
+        link: string;
+    }[];
+};
+declare type DocsConfig = {
+    titleSuffix?: string;
+    description?: string;
+    baseUrl: string;
+    basePath?: string;
+    sidebars: Sidebar$1[];
+    filesBasePath?: string;
+    project: {
+        title: string;
+        key: string;
+    };
+    breadcrumbOptions?: BreadcrumbOptions;
+    version: {
+        number: string;
+        releaseUrl: string;
+        releaseDate: string;
+        hide?: boolean;
+        bannerImage?: {
+            light: string;
+            dark: string;
+        };
+    };
+    reportIssueLink?: string;
+    logo: string;
+};
+
+declare type FrontMatter = {
+    slug?: string;
+    sidebar_label?: string;
+    sidebar_group?: string;
+    sidebar_group_main?: boolean;
+    sidebar_position?: number;
+    sidebar_autogenerate_exclude?: boolean;
+    sidebar_description?: string;
+    tags?: (string | {
+        name: string;
+        label: string;
+    })[];
+    title?: string;
+    description?: string;
+    products?: string[];
+    toc_max_depth?: number;
+    generate_toc?: boolean;
+    hide_content_menu?: boolean;
+    keywords?: string[];
+};
+
+type Ref<T> = React.RefObject<T | null> | ((instance: T | null) => void);
+
+type MenuItemLink = {
+    type: "link";
+    icon?: React$1.ReactNode;
+    title: string;
+    link: string;
+    openInNewTab?: boolean;
+};
+type MenuItemDivider = {
+    type: "divider";
+};
+type MenuItemAction = {
+    type: "action";
+    icon: React$1.ReactNode;
+    title: string;
+    shortcut?: string;
+    action: () => void;
+};
+type MenuItemCustom = {
+    type: "custom";
+    content: React$1.ReactNode;
+};
+type MenuItemSubMenu = {
+    type: "sub-menu";
+    items: MenuItem[];
+    title: string;
+    link?: string;
+};
+type MenuItem = MenuItemLink | MenuItemDivider | MenuItemAction | MenuItemCustom | MenuItemSubMenu;
+
+type NavigationItemDropdown = {
+    type: "dropdown";
+    title: string;
+    children: (MenuItem & {
+        useAsFallback?: boolean;
+    })[];
+    project?: string;
+    link?: string;
+};
+type NavigationItemLink = {
+    type: "link";
+    link: string;
+    title: string;
+    project?: string;
+    useAsFallback?: boolean;
+};
+type NavigationItem = NavigationItemLink | NavigationItemDropdown;
+
+type Sidebar$1 = {
+    sidebar_id: string;
+    title: string;
+    items: SidebarItem$1[];
+};
+type SidebarItemCommon = {
+    title: string;
+    children?: SidebarItem$1[];
+    loaded?: boolean;
+    additionalElms?: React$1.ReactNode;
+    badge?: {
+        variant: "purple" | "orange" | "green" | "blue" | "red" | "neutral";
+        text: string;
+    };
+    chapterTitle?: string;
+    childSidebarTitle?: string;
+    hideChildren?: boolean;
+    number?: string;
+    description?: string;
+};
+type InteractiveSidebarItemTypes = "category" | "sub-category" | "link" | "ref" | "external" | "sidebar";
+type SidebarItemLink = SidebarItemCommon & {
+    type: "link" | "ref" | "external";
+    path: string;
+    isPathHref?: boolean;
+    linkProps?: React$1.AllHTMLAttributes<HTMLAnchorElement>;
+    childrenSameLevel?: boolean;
+};
+type SidebarItemSidebar = SidebarItemCommon & {
+    type: "sidebar";
+    sidebar_id: string;
+};
+type SidebarItemCategory = SidebarItemCommon & {
+    type: "category";
+    onOpen?: () => void;
+    initialOpen?: boolean;
+    showLoadingIfEmpty?: boolean;
+};
+type SidebarItemSubCategory = SidebarItemCommon & {
+    type: "sub-category";
+    childrenSameLevel?: boolean;
+};
+type SidebarItemSeparator = {
+    type: "separator";
+};
+type InteractiveSidebarItem = SidebarItemLink | SidebarItemCategory | SidebarItemSubCategory | SidebarItemSidebar;
+type SidebarItem$1 = InteractiveSidebarItem | SidebarItemSeparator;
+
+type ToCItem = {
+    title: string;
+    id: string;
+    level: number;
+    children?: ToCItem[];
+};
+type Product = {
+    name: string;
+    path: string;
+    title: string;
+    image: string;
+    type: "commerce";
+};
+
+declare const GITHUB_ISSUES_LINK = "https://github.com/acmekit/acmekit/issues/new/choose";
+declare const navDropdownItems: NavigationItem[];
+declare const products: Product[];
+declare enum DocsTrackingEvents {
+    SURVEY = "survey",
+    SURVEY_API = "survey_api-ref",
+    CODE_BLOCK_COPY = "code_block_copy",
+    AI_ASSISTANT_START_CHAT = "ai_assistant_start_chat",
+    AI_ASSISTANT_CALLOUT_CLICK = "ai_assistant_callout_click",
+    SEARCH_CALLOUT_CLICK = "search_callout_click"
+}
+
+declare const globalConfig: Pick<DocsConfig, "version">;
+
+type BadgeVariant = "purple" | "orange" | "green" | "blue" | "red" | "neutral" | "code";
+type BadgeType = "default" | "shaded";
+type BadgeProps = {
+    className?: string;
+    childrenWrapperClassName?: string;
+    variant: BadgeVariant;
+    badgeType?: BadgeType;
+} & React$1.HTMLAttributes<HTMLSpanElement>;
+declare const Badge: ({ className, variant, badgeType, children, childrenWrapperClassName, ...props }: BadgeProps) => react_jsx_runtime.JSX.Element;
+
+type BadgesListProps = {
+    badges: BadgeProps[];
+    className?: string;
+};
+declare const BadgesList: ({ badges, className }: BadgesListProps) => react_jsx_runtime.JSX.Element;
+
+type BetaBadgeProps = {
+    text?: string;
+    tooltipText?: string;
+};
+declare const BetaBadge: ({ text, tooltipText, }: BetaBadgeProps) => react_jsx_runtime.JSX.Element;
+
+type BorderedProps = {
+    wrapperClassName?: string;
+} & React$1.HTMLAttributes<HTMLSpanElement>;
+declare const Bordered: ({ wrapperClassName, children }: BorderedProps) => react_jsx_runtime.JSX.Element;
+
+type BorderedIconProps = {
+    icon?: string;
+    IconComponent?: React$1.FC<IconProps> | null;
+    wrapperClassName?: string;
+    iconWrapperClassName?: string;
+    iconClassName?: string;
+    iconColorClassName?: string;
+    iconWidth?: number;
+    iconHeight?: number;
+} & React$1.HTMLAttributes<HTMLSpanElement>;
+declare const BorderedIcon: ({ icon, IconComponent, iconWrapperClassName, iconClassName, iconColorClassName, wrapperClassName, iconWidth, iconHeight, ...props }: BorderedIconProps) => react_jsx_runtime.JSX.Element;
+
+declare const Breadcrumbs: () => react_jsx_runtime.JSX.Element;
+
+type ButtonVariants = "primary" | "secondary" | "transparent" | "transparent-clear";
+type ButtonType = "default" | "icon";
+type ButtonProps = {
+    isSelected?: boolean;
+    disabled?: boolean;
+    variant?: ButtonVariants;
+    className?: string;
+    buttonType?: ButtonType;
+    buttonRef?: React$1.LegacyRef<HTMLButtonElement>;
+    type?: "button" | "submit" | "reset";
+} & React$1.HTMLAttributes<HTMLButtonElement>;
+declare const Button: ({ className, children, variant, buttonType, buttonRef, ...props }: ButtonProps) => react_jsx_runtime.JSX.Element;
+
+type CardProps = {
+    type?: "default" | "large" | "filler" | "mini";
+    icon?: React$1.FC<IconProps>;
+    rightIcon?: React$1.FC<IconProps>;
+    image?: string;
+    themeImage?: {
+        light: string;
+        dark: string;
+    };
+    imageDimensions?: {
+        width: number;
+        height: number;
+    };
+    title?: string;
+    text?: string;
+    href?: string;
+    className?: string;
+    contentClassName?: string;
+    iconClassName?: string;
+    children?: React$1.ReactNode;
+    badge?: BadgeProps;
+    highlightText?: string[];
+    closeable?: boolean;
+    onClose?: () => void;
+    onClick?: () => void;
+    hrefProps?: Partial<LinkProps$1 & React$1.AllHTMLAttributes<HTMLAnchorElement>>;
+    cardRef?: React$1.Ref<HTMLDivElement>;
+};
+declare const Card: ({ type, ...props }: CardProps) => react_jsx_runtime.JSX.Element;
+
+type CardListProps = {
+    items: CardProps[];
+    itemsPerRow?: number;
+    defaultItemsPerRow?: number;
+    className?: string;
+};
+declare const CardList: ({ items, itemsPerRow, className, defaultItemsPerRow, }: CardListProps) => react_jsx_runtime.JSX.Element;
+
+type UseChildDocsProps = {
+    onlyTopLevel?: boolean;
+};
+declare const ChildDocs: (_props: UseChildDocsProps) => null;
+
+type CodeBlockHeaderMeta = {
+    badgeLabel?: string;
+    badgeColor?: BadgeVariant;
+};
+
+type ApiMethod = string;
+type ApiAuthType = string;
+type ApiDataOptions = Record<string, unknown>;
+type Highlight = {
+    line: number;
+    text?: string;
+    tooltipText?: string;
+};
+type CodeBlockMetaFields = {
+    title?: string;
+    hasTabs?: boolean;
+    npm2yarn?: boolean;
+    npx2yarn?: boolean;
+    npx2yarnExec?: boolean;
+    highlights?: string[][];
+    apiTesting?: boolean;
+    testApiMethod?: ApiMethod;
+    testApiUrl?: string;
+    testAuthType?: ApiAuthType;
+    testPathParams?: ApiDataOptions;
+    testQueryParams?: ApiDataOptions;
+    testBodyParams?: ApiDataOptions;
+    noCopy?: boolean;
+    noReport?: boolean;
+    noLineNumbers?: boolean;
+    noAskAi?: boolean;
+    collapsibleLines?: string;
+    expandButtonLabel?: string;
+    isTerminal?: boolean;
+    forceNoTitle?: boolean;
+    collapsed?: boolean;
+    wrapperClassName?: string;
+} & CodeBlockHeaderMeta;
+type CodeBlockStyle = "loud" | "subtle" | "inline";
+type CodeBlockProps = {
+    source: string;
+    lang?: string;
+    innerClassName?: string;
+    className?: string;
+    blockStyle?: CodeBlockStyle;
+    children?: React$1.ReactNode;
+    style?: React$1.HTMLAttributes<HTMLDivElement>["style"];
+    animateTokenHighlights?: boolean;
+    overrideColors?: {
+        bg?: string;
+        innerBg?: string;
+        lineNumbersBg?: string;
+        border?: string;
+        innerBorder?: string;
+        boxShadow?: string;
+    };
+} & CodeBlockMetaFields & Omit<HighlightProps$1, "code" | "language" | "children">;
+declare const CodeBlock: ({ source, hasTabs, lang, wrapperClassName, innerClassName, className, overrideColors, collapsed, title, highlights, apiTesting, blockStyle, noCopy, noReport, noLineNumbers, children, collapsibleLines, expandButtonLabel, isTerminal, style, forceNoTitle, animateTokenHighlights, noAskAi, ...rest }: CodeBlockProps) => react_jsx_runtime.JSX.Element;
+
+type InlineCodeProps = React$1.ComponentProps<"code"> & {
+    variant?: "default" | "grey-bg";
+};
+declare const InlineCode: ({ variant, ...props }: InlineCodeProps) => react_jsx_runtime.JSX.Element;
+
+type CodeMdxProps = {
+    className?: string;
+    children?: React$1.ReactNode;
+    inlineCodeProps?: Partial<InlineCodeProps>;
+    codeBlockProps?: Partial<CodeBlockProps>;
+} & CodeBlockMetaFields;
+declare const CodeMdx: ({ className, children, inlineCodeProps, codeBlockProps, ...rest }: CodeMdxProps) => react_jsx_runtime.JSX.Element;
+
+type CodeTabProps$1 = {
+    children: React$1.ReactNode;
+    className?: string;
+    group?: string;
+    blockStyle?: CodeBlockStyle;
+};
+declare const CodeTabs: ({ children, className, group, blockStyle, }: CodeTabProps$1) => react_jsx_runtime.JSX.Element;
+
+type BaseTabType = {
+    label: string;
+    value: string;
+};
+type EventData = {
+    storageValue: string;
+};
+type TabProps<T> = {
+    tabs: T[];
+    group?: string;
+};
+declare function useTabs<T extends BaseTabType>({ tabs, group }: TabProps<T>): {
+    selectedTab: T | null;
+    changeSelectedTab: (tab: T) => void;
+};
+
+type CodeTabProps = BaseTabType & {
+    children: React$1.ReactNode;
+    isSelected?: boolean;
+    blockStyle?: string;
+    changeSelectedTab?: (tab: BaseTabType) => void;
+    pushRef?: (tabButton: HTMLButtonElement | null) => void;
+};
+declare const CodeTab: ({ label, value, isSelected, blockStyle, changeSelectedTab, pushRef, }: CodeTabProps) => react_jsx_runtime.JSX.Element;
+
+declare const ContentMenu: () => react_jsx_runtime.JSX.Element;
+
+type CopyButtonChildFn = (props: {
+    isCopied: boolean;
+}) => React$1.ReactNode;
+type CopyButtonProps = {
+    text: string;
+    buttonClassName?: string;
+    tooltipClassName?: string;
+    tooltipInnerClassName?: string;
+    tooltipText?: string;
+    onCopy?: (e: React$1.MouseEvent<HTMLSpanElement, MouseEvent> | React$1.TouchEvent<HTMLSpanElement>) => void;
+    handleTouch?: boolean;
+    children?: React$1.ReactNode | CopyButtonChildFn;
+} & Omit<React$1.HTMLAttributes<HTMLDivElement>, "onCopy" | "children">;
+declare const CopyButton: ({ text, buttonClassName, tooltipClassName, tooltipText, children, className, onCopy, handleTouch, tooltipInnerClassName, }: CopyButtonProps) => react_jsx_runtime.JSX.Element;
+
+type DetailsProps = {
+    openInitial?: boolean;
+    summaryContent?: React$1.ReactNode;
+    summaryElm?: React$1.ReactNode;
+    heightAnimation?: boolean;
+} & React$1.HTMLAttributes<HTMLDetailsElement>;
+declare const Details: ({ openInitial, summaryContent, summaryElm, children, heightAnimation, ...props }: DetailsProps) => react_jsx_runtime.JSX.Element;
+
+type DetailsSummaryProps = {
+    title?: React$1.ReactNode;
+    subtitle?: React$1.ReactNode;
+    badge?: React$1.ReactNode;
+    expandable?: boolean;
+    open?: boolean;
+    className?: string;
+    titleClassName?: string;
+    hideExpandableIcon?: boolean;
+    summaryRef?: React$1.LegacyRef<HTMLDivElement>;
+} & Omit<React$1.HTMLAttributes<HTMLElement>, "title">;
+declare const DetailsSummary: ({ title, subtitle, children, badge, expandable, open, className, titleClassName, hideExpandableIcon, summaryRef, ...rest }: DetailsSummaryProps) => react_jsx_runtime.JSX.Element;
+
+type TroubleshootingSection = {
+    title: string;
+    content: React$1.ReactNode;
+};
+type DetailsListProps = {
+    sections: TroubleshootingSection[];
+} & React$1.AllHTMLAttributes<HTMLDivElement>;
+declare const DetailsList: ({ sections }: DetailsListProps) => react_jsx_runtime.JSX.Element;
+
+type DottedSeparatorProps = {
+    wrapperClassName?: string;
+    className?: string;
+    "data-testid"?: string;
+};
+declare const DottedSeparator: ({ className, wrapperClassName, "data-testid": testId, }: DottedSeparatorProps) => react_jsx_runtime.JSX.Element;
+
+type EditButtonProps = {
+    filePath: string;
+    editDate?: string;
+};
+declare const EditButton: ({ filePath, editDate }: EditButtonProps) => react_jsx_runtime.JSX.Element;
+
+type EditDateProps = {
+    date: string;
+};
+declare const EditDate: ({ date }: EditDateProps) => react_jsx_runtime.JSX.Element;
+
+declare const ErrorPage: () => react_jsx_runtime.JSX.Element;
+
+type ExpandableNoticeProps = {
+    type?: "request" | "method" | "workflow";
+    link: string;
+    badgeContent?: React$1.ReactNode;
+    badgeClassName?: string;
+};
+declare const ExpandableNotice: ({ type, link, badgeContent, badgeClassName, }: ExpandableNoticeProps) => react_jsx_runtime.JSX.Element;
+
+type FeatureFlagNoticeProps = {
+    featureFlag: string;
+    type?: "endpoint" | "type";
+    tooltipTextClassName?: string;
+    badgeClassName?: string;
+    badgeContent?: React$1.ReactNode;
+};
+declare const FeatureFlagNotice: ({ featureFlag, type, tooltipTextClassName, badgeClassName, badgeContent, }: FeatureFlagNoticeProps) => react_jsx_runtime.JSX.Element;
+
+type DeprecatedNoticeProps = {
+    description?: string;
+    tooltipTextClassName?: string;
+    badgeClassName?: string;
+    badgeContent?: React$1.ReactNode;
+};
+declare const DeprecatedNotice: ({ description, tooltipTextClassName, badgeClassName, badgeContent, }: DeprecatedNoticeProps) => react_jsx_runtime.JSX.Element;
+
+type VersionNoticeProps = {
+    version: string;
+    tooltipTextClassName?: string;
+    badgeClassName?: string;
+    badgeContent?: React$1.ReactNode;
+};
+declare const VersionNotice: ({ version, tooltipTextClassName, badgeClassName, badgeContent, }: VersionNoticeProps) => react_jsx_runtime.JSX.Element;
+
+type FeedbackProps = {
+    event: string;
+    reportLink?: string;
+    question?: string;
+    positiveBtn?: string;
+    negativeBtn?: string;
+    positiveQuestion?: string;
+    negativeQuestion?: string;
+    submitBtn?: string;
+    submitMessage?: string;
+    showPossibleSolutions?: boolean;
+    className?: string;
+    extraData?: Record<string, unknown>;
+    vertical?: boolean;
+    showDottedSeparator?: boolean;
+} & React$1.HTMLAttributes<HTMLDivElement>;
+declare const Feedback: ({ event, reportLink: initReportLink, question, positiveBtn, negativeBtn, positiveQuestion, negativeQuestion, submitBtn, submitMessage, showPossibleSolutions, className, extraData, vertical, showDottedSeparator, }: FeedbackProps) => react_jsx_runtime.JSX.Element;
+
+type SolutionsProps = {
+    feedback: boolean;
+    message?: string;
+};
+type GitHubSearchItem = {
+    url: string;
+    html_url: string;
+    title: string;
+    [key: string]: unknown;
+};
+declare const Solutions: ({ feedback, message }: SolutionsProps) => react_jsx_runtime.JSX.Element;
+
+type FooterProps = {
+    editComponent?: React$1.ReactNode;
+    showPagination?: boolean;
+    feedbackComponent?: React$1.ReactNode;
+    editDate?: string;
+};
+declare const Footer: ({ editComponent, showPagination, feedbackComponent, }: FooterProps) => react_jsx_runtime.JSX.Element;
+
+type H1Props = React$1.HTMLAttributes<HTMLHeadingElement> & {
+    id?: string;
+};
+declare const H1: ({ className, ...props }: H1Props) => react_jsx_runtime.JSX.Element;
+
+type H2Props = React$1.HTMLAttributes<HTMLHeadingElement> & {
+    id?: string;
+    passRef?: React$1.RefObject<HTMLHeadingElement | null>;
+};
+declare const H2: ({ className, children, passRef, ...props }: H2Props) => react_jsx_runtime.JSX.Element;
+
+type H3Props = React$1.HTMLAttributes<HTMLHeadingElement> & {
+    id?: string;
+};
+declare const H3: ({ className, children, ...props }: H3Props) => react_jsx_runtime.JSX.Element;
+
+declare const H4: ({ className, ...props }: React$1.HTMLAttributes<HTMLHeadingElement>) => react_jsx_runtime.JSX.Element;
+
+type IconHeadlineProps = {
+    title: string;
+    icon: React$1.ReactNode;
+};
+declare const IconHeadline: ({ title, icon }: IconHeadlineProps) => react_jsx_runtime.JSX.Element;
+
+declare const AiAssistantIcon: (props: IconProps) => react_jsx_runtime.JSX.Element;
+
+declare const BundledProductIcon: (props: IconProps) => react_jsx_runtime.JSX.Element;
+
+declare const CalendarRefreshIcon: (props: IconProps) => react_jsx_runtime.JSX.Element;
+
+declare const ChefHatIcon: (props: IconProps) => react_jsx_runtime.JSX.Element;
+
+declare const IconCircleDottedLine: (props: IconProps) => react_jsx_runtime.JSX.Element;
+
+declare const IconCloudSolid: (props: IconProps) => react_jsx_runtime.JSX.Element;
+
+declare const ColoredAcmeKitIcon: ({ className, ...props }: IconProps) => react_jsx_runtime.JSX.Element;
+
+declare const DecisionProcessIcon: (props: IconProps) => react_jsx_runtime.JSX.Element;
+
+declare const ErpIcon: (props: IconProps) => react_jsx_runtime.JSX.Element;
+
+declare const ImageBinaryIcon: (props: IconProps) => react_jsx_runtime.JSX.Element;
+
+declare const PuzzleColoredIcon: (props: IconProps) => react_jsx_runtime.JSX.Element;
+
+declare const QuestionMarkIcon: (props: IconProps) => react_jsx_runtime.JSX.Element;
+
+declare const RestockIcon: (props: IconProps) => react_jsx_runtime.JSX.Element;
+
+declare const ScrollTextIcon: (props: IconProps) => react_jsx_runtime.JSX.Element;
+
+type ShadedBgIconProps = IconProps & {
+    variant?: BadgeVariant;
+};
+declare const ShadedBgIcon: ({ variant, ...props }: ShadedBgIconProps) => react_jsx_runtime.JSX.Element;
+
+declare const ShopIcon: (props: IconProps) => react_jsx_runtime.JSX.Element;
+
+declare const StripeColoredIcon: (props: IconProps) => react_jsx_runtime.JSX.Element;
+
+declare const ThumbDownIcon: (props: IconProps) => react_jsx_runtime.JSX.Element;
+
+declare const ThumbUpIcon: (props: IconProps) => react_jsx_runtime.JSX.Element;
+
+declare const WindowPaintbrushIcon: (props: IconProps) => react_jsx_runtime.JSX.Element;
+
+type InlineIconProps = IconProps & {
+    Icon: React$1.ComponentType<IconProps>;
+    alt?: string;
+};
+declare const InlineIcon: ({ Icon, alt, ...props }: InlineIconProps) => react_jsx_runtime.JSX.Element;
+
+type ThemeImageProps = {
+    light: string;
+    dark?: string;
+    alt?: string;
+} & React$1.AllHTMLAttributes<HTMLImageElement>;
+declare const ThemeImage: ({ light, dark, alt, ...props }: ThemeImageProps) => react_jsx_runtime.JSX.Element;
+
+declare const InlineThemeImage: (props: ThemeImageProps) => react_jsx_runtime.JSX.Element;
+
+type InputTextProps = {
+    className?: string;
+    addGroupStyling?: boolean;
+    passedRef?: React$1.Ref<HTMLInputElement>;
+} & React$1.DetailedHTMLProps<React$1.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
+declare const InputText: ({ addGroupStyling, className, passedRef, ...props }: InputTextProps) => react_jsx_runtime.JSX.Element;
+
+type SearchInputProps = {
+    onChange: (value: string) => void;
+} & Omit<React$1.ComponentProps<"input">, "onChange">;
+declare const SearchInput: ({ value, onChange, className, placeholder, ...props }: SearchInputProps) => react_jsx_runtime.JSX.Element;
+
+type KbdProps = React$1.ComponentProps<"kbd"> & {
+    variant?: "default" | "small";
+};
+declare const Kbd: ({ children, className, variant, ...props }: KbdProps) => react_jsx_runtime.JSX.Element;
+
+type LabelProps = {
+    className?: string;
+} & React$1.HTMLAttributes<HTMLSpanElement>;
+declare const Label: ({ children, className }: LabelProps) => react_jsx_runtime.JSX.Element;
+
+type LinkProps = React$1.AllHTMLAttributes<HTMLAnchorElement> & {
+    href?: string;
+    children?: React$1.ReactNode;
+    className?: string;
+    withIcon?: boolean;
+    variant?: "default" | "content";
+};
+declare const Link: ({ href, children, className, withIcon, variant, ...rest }: LinkProps) => react_jsx_runtime.JSX.Element;
+
+type LinkButtonProps = LinkProps$1 & {
+    variant?: "base" | "interactive" | "subtle" | "muted";
+    className?: string;
+};
+declare const LinkButton: ({ variant, className, ...linkProps }: LinkButtonProps) => react_jsx_runtime.JSX.Element;
+
+type LoadingProps = {
+    className?: string;
+    barClassName?: string;
+    count?: number;
+};
+declare const Loading: ({ className, count, barClassName, }: LoadingProps) => react_jsx_runtime.JSX.Element;
+
+type DotsLoadingProps = {
+    className?: string;
+};
+declare const DotsLoading: ({ className }: DotsLoadingProps) => react_jsx_runtime.JSX.Element;
+
+type SpinnerLoadingProps = {
+    iconProps?: IconProps;
+};
+declare const SpinnerLoading: ({ iconProps }: SpinnerLoadingProps) => react_jsx_runtime.JSX.Element;
+
+type MainNavProps = {
+    className?: string;
+    itemsClassName?: string;
+};
+declare const MainNav: ({ className, itemsClassName }: MainNavProps) => react_jsx_runtime.JSX.Element;
+
+type MarkdownContentProps = Options$1 & {
+    components?: Partial<Components> | null | undefined;
+};
+declare const MarkdownContent: ({ children, components, ...props }: MarkdownContentProps) => react_jsx_runtime.JSX.Element;
+
+declare const MDXComponents: MDXComponents$1;
+declare const Hr: () => React$1.JSX.Element;
+
+type DropdownMenuProps = {
+    dropdownButtonContent: React$1.ReactNode;
+    dropdownButtonClassName?: string;
+    menuComponent?: React$1.ReactNode;
+    menuItems?: MenuItem[];
+    menuClassName?: string;
+    className?: string;
+    open?: boolean;
+    setOpen?: (open: boolean) => void;
+};
+declare const DropdownMenu: ({ dropdownButtonContent, dropdownButtonClassName, menuComponent, menuItems, menuClassName, className, open: externalOpen, setOpen: externalSetOpen, }: DropdownMenuProps) => react_jsx_runtime.JSX.Element | null;
+
+type MenuProps = {
+    items: MenuItem[];
+    className?: string;
+    itemsOnClick?: (item: MenuItem) => void;
+};
+declare const Menu: ({ items, className, itemsOnClick }: MenuProps) => react_jsx_runtime.JSX.Element;
+
+type ModalProps = {
+    className?: string;
+    title?: React$1.ReactNode;
+    actions?: ButtonProps[];
+    modalContainerClassName?: string;
+    contentClassName?: string;
+    onClose?: React$1.ReactEventHandler<HTMLDialogElement>;
+    open?: boolean;
+    footerContent?: React$1.ReactNode;
+    passedRef?: Ref<HTMLDialogElement>;
+    headerClassName?: string;
+} & Omit<React$1.ComponentProps<"dialog">, "ref" | "title" | "key">;
+declare const Modal: ({ className, title, actions, children, contentClassName, modalContainerClassName, onClose, open, footerContent, passedRef, ...props }: ModalProps) => react_jsx_runtime.JSX.Element;
+
+type ModalHeaderProps = {
+    title?: React$1.ReactNode;
+};
+declare const ModalHeader: ({ title }: ModalHeaderProps) => react_jsx_runtime.JSX.Element;
+
+type ModalFooterProps = {
+    actions?: ButtonProps[];
+    children?: React$1.ReactNode;
+    className?: string;
+};
+declare const ModalFooter: ({ actions, children, className, }: ModalFooterProps) => react_jsx_runtime.JSX.Element;
+
+type NoteProps = {
+    type?: "default" | "warning" | "success" | "error" | "check" | "soon";
+    title?: string;
+    children?: React$1.ReactNode;
+    forceMultiline?: boolean;
+};
+declare const Note: ({ type, ...props }: NoteProps) => react_jsx_runtime.JSX.Element;
+
+declare const NotificationContainer: () => react_jsx_runtime.JSX.Element;
+
+type NotificationItemProps = {
+    layout?: "default" | "empty";
+    type?: "info" | "error" | "warning" | "success" | "custom" | "none";
+    CustomIcon?: React$1.ReactNode;
+    title?: string;
+    text?: string;
+    className?: string;
+    children?: ReactElement;
+    isClosable?: boolean;
+    placement?: "top" | "bottom";
+    show?: boolean;
+    setShow?: (value: boolean) => void;
+    onClose?: () => void;
+    closeButtonText?: string;
+} & React$1.HTMLAttributes<HTMLDivElement>;
+declare const NotificationItem: ({ className, placement, show, layout, setShow, onClose, children, ...rest }: NotificationItemProps) => react_jsx_runtime.JSX.Element;
+
+type NotificationItemLayoutDefaultProps = NotificationItemProps & {
+    handleClose: () => void;
+    closeButtonText?: string;
+};
+declare const NotificationItemLayoutDefault: React$1.FC<NotificationItemLayoutDefaultProps>;
+
+declare const Pagination: () => react_jsx_runtime.JSX.Element;
+
+type PrerequisiteItemPosition = "top" | "middle" | "bottom" | "alone";
+type PrerequisiteItemType = {
+    text: string;
+    link?: string;
+    position?: PrerequisiteItemPosition;
+};
+
+type PrerequisitesProps = {
+    items: PrerequisiteItemType[];
+};
+declare const Prerequisites: ({ items }: PrerequisitesProps) => react_jsx_runtime.JSX.Element;
+
+type RadioItemProps = React$1.DetailedHTMLProps<React$1.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement> & {
+    checked?: boolean;
+};
+declare const RadioItem: ({ className, checked, ...props }: RadioItemProps) => react_jsx_runtime.JSX.Element;
+
+type RatingProps = {
+    event?: string;
+    className?: string;
+    onRating?: (rating?: number) => void;
+    additionalQuestion?: string;
+    parentNotificationId?: string;
+} & React$1.HTMLAttributes<HTMLDivElement>;
+declare const Rating: React$1.FC<RatingProps>;
+
+type LayoutProviderContextType = {
+    mainContentRef: React$1.RefObject<HTMLDivElement | null>;
+    showCollapsedNavbar: boolean;
+};
+declare const LayoutProviderContext: React$1.Context<LayoutProviderContextType | null>;
+type LayoutProviderProps = {
+    children: React$1.ReactNode;
+    disableResizeObserver?: boolean;
+};
+declare const LayoutProvider: ({ children, disableResizeObserver, }: LayoutProviderProps) => react_jsx_runtime.JSX.Element;
+declare const useLayout: () => LayoutProviderContextType;
+
+type RootProvidersProps = {
+    children: React$1.ReactNode;
+    layoutProviderProps?: Omit<LayoutProviderProps, "children">;
+};
+declare const RootProviders: ({ children, layoutProviderProps, }: RootProvidersProps) => react_jsx_runtime.JSX.Element;
+
+type ActiveOnScrollItem = {
+    heading: HTMLHeadingElement;
+    children?: ActiveOnScrollItem[];
+};
+type UseActiveOnScrollProps = {
+    rootElm?: Document | HTMLElement;
+    enable?: boolean;
+    useDefaultIfNoActive?: boolean;
+    maxLevel?: number;
+};
+declare const useActiveOnScroll: ({ rootElm, enable, useDefaultIfNoActive, maxLevel, }: UseActiveOnScrollProps) => {
+    items: ActiveOnScrollItem[];
+    activeItemId: string;
+};
+
+declare function useResizeObserver(ref: React.RefObject<HTMLElement | null>, callback: (entry: ResizeObserverEntry) => void): void;
+
+type UseClickOutsideProps = {
+    elmRef: React$1.RefObject<HTMLElement | null>;
+    onClickOutside: (e: MouseEvent) => void;
+};
+declare const useClickOutside: ({ elmRef, onClickOutside, }: UseClickOutsideProps) => void;
+
+type CollapsibleProps = {
+    initialValue?: boolean;
+    heightAnimation?: boolean;
+    translateEnabled?: boolean;
+    onClose?: () => void;
+    unmountOnExit?: boolean;
+    childrenRef?: React$1.RefObject<HTMLElement | null>;
+    useChild?: boolean;
+};
+type CollapsibleReturn = {
+    getCollapsibleElms: (children: React$1.ReactNode) => React$1.JSX.Element;
+    collapsed: boolean;
+    setCollapsed: React$1.Dispatch<React$1.SetStateAction<boolean>>;
+};
+declare const useCollapsible: ({ initialValue, heightAnimation, translateEnabled, onClose, unmountOnExit, childrenRef, useChild, }: CollapsibleProps) => CollapsibleReturn;
+
+type HighlightProps = {
+    getLineProps: (input: LineInputProps) => LineOutputProps;
+    getTokenProps: (input: TokenInputProps) => TokenOutputProps;
+};
+type CollapsibleCodeLines = {
+    collapsibleLinesStr?: string;
+    getLines: (token: Token[][], highlightProps: HighlightProps, lineNumberOffset?: number) => React$1.JSX.Element[];
+};
+type CollapsedCodeLinesPosition = "start" | "end";
+declare const useCollapsibleCodeLines: ({ collapsibleLinesStr, getLines, }: CollapsibleCodeLines) => {
+    getCollapsibleElms: (children: React$1.ReactNode) => React$1.JSX.Element;
+    collapsed: boolean;
+    setCollapsed: React$1.Dispatch<React$1.SetStateAction<boolean>>;
+    getCollapsedLinesElm: ({ tokens, highlightProps, }: {
+        tokens: Token[][];
+        highlightProps: HighlightProps;
+    }) => react_jsx_runtime.JSX.Element;
+    getNonCollapsedLinesElm: ({ tokens, highlightProps, }: {
+        tokens: Token[][];
+        highlightProps: HighlightProps;
+    }) => React$1.JSX.Element[];
+    type: CollapsedCodeLinesPosition | undefined;
+    isCollapsible: (tokens: Token[][]) => boolean | undefined;
+};
+
+type useCopyReturnType = {
+    isCopied: boolean;
+    handleCopy: () => void;
+};
+declare const useCopy: (text: string) => useCopyReturnType;
+
+type useHeadingUrlProps = {
+    id: string;
+};
+declare const useHeadingUrl: ({ id }: useHeadingUrlProps) => string;
+
+type UseIsExternalLinkProps = {
+    href?: string;
+};
+declare const useIsExternalLink: ({ href }: UseIsExternalLinkProps) => boolean | "" | undefined;
+
+type UseMutationObserverProps = {
+    elm: Document | HTMLElement | undefined;
+    callback: () => void;
+    options?: {
+        attributes?: boolean;
+        characterData?: boolean;
+        childList?: boolean;
+        subtree?: boolean;
+    };
+};
+declare const useMutationObserver: ({ elm, callback, options, }: UseMutationObserverProps) => void;
+
+type useKeyboardShortcutOptions = {
+    metakey?: boolean;
+    shortcutKeys: string[];
+    action: (e: KeyboardEvent) => void;
+    checkEditing?: boolean;
+    preventDefault?: boolean;
+    isLoading?: boolean;
+};
+declare const useKeyboardShortcut: ({ metakey, shortcutKeys, action, checkEditing, preventDefault, isLoading, }: useKeyboardShortcutOptions) => void;
+
+declare const usePageScrollManager: () => void;
+
+type EventFunc = (...args: never[]) => unknown;
+declare function useEvent<T extends EventFunc>(callback: T): T;
+/**
+ * Gets `value` from the last render.
+ */
+declare function usePrevious<T>(value: T): T | undefined;
+type ScrollController = {
+    /** A boolean ref tracking whether scroll events are enabled. */
+    scrollEventsEnabledRef: React$1.MutableRefObject<boolean>;
+    /** Enable scroll events in `useScrollPosition`. */
+    enableScrollEvents: () => void;
+    /** Disable scroll events in `useScrollPosition`. */
+    disableScrollEvents: () => void;
+    /** Retrieves the scrollable element. By default, it's window. */
+    scrollableElement: Element | Window | undefined;
+    /** Retrieves the scroll top if the scrollable element */
+    getScrolledTop: () => number;
+    /** Scrolls to an element */
+    scrollToElement: (elm: HTMLElement) => void;
+    /** Scrolls to a top value */
+    scrollToTop: (top: number, parentTop?: number) => void;
+};
+declare function ScrollControllerProvider({ children, scrollableSelector, }: {
+    children: ReactNode;
+    scrollableSelector?: string;
+    restoreScrollOnReload?: boolean;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * We need a way to update the scroll position while ignoring scroll events
+ * so as not to toggle Navbar/BackToTop visibility.
+ *
+ * This API permits to temporarily disable/ignore scroll events. Motivated by
+ * https://github.com/facebook/docusaurus/pull/5618
+ */
+declare function useScrollController(): ScrollController;
+type ScrollPosition = {
+    scrollX: number;
+    scrollY: number;
+};
+/**
+ * This hook fires an effect when the scroll position changes. The effect will
+ * be provided with the before/after scroll positions. Note that the effect may
+ * not be always run: if scrolling is disabled through `useScrollController`, it
+ * will be a no-op.
+ *
+ * @see {@link useScrollController}
+ */
+declare function useScrollPosition(effect: (position: ScrollPosition, lastPosition: ScrollPosition | null) => void, deps?: unknown[]): void;
+/**
+ * This hook permits to "block" the scroll position of a DOM element.
+ * The idea is that we should be able to update DOM content above this element
+ * but the screen position of this element should not change.
+ *
+ * Feature motivated by the Tabs groups: clicking on a tab may affect tabs of
+ * the same group upper in the tree, yet to avoid a bad UX, the clicked tab must
+ * remain under the user mouse.
+ *
+ * @see https://github.com/facebook/docusaurus/pull/5618
+ */
+declare function useScrollPositionBlocker(): {
+    /**
+     * Takes an element, and keeps its screen position no matter what's getting
+     * rendered above it, until the next render.
+     */
+    blockElementScrollPositionUntilNextRender: (el: HTMLElement) => void;
+};
+
+type OptionType = {
+    value: string;
+    label: string;
+    index?: string;
+    isAllOption?: boolean;
+    hitsPerPage?: number;
+};
+type SelectOptions = {
+    value: string | string[];
+    multiple?: boolean;
+    options: OptionType[];
+    setSelected?: (value: string | string[]) => void;
+    addSelected?: (value: string) => void;
+    removeSelected?: (value: string) => void;
+    handleAddAll?: (isAllSelected: boolean) => void;
+};
+declare const useSelect: ({ value, options, multiple, setSelected, addSelected, removeSelected, handleAddAll, }: SelectOptions) => {
+    isValueSelected: (val: string) => boolean;
+    hasSelectedValue: number | boolean;
+    hasSelectedValues: boolean;
+    selectedValues: OptionType[];
+    isAllSelected: boolean;
+    handleChange: (selectedValue: string, wasSelected: boolean) => void;
+    handleSelectAll: () => void;
+    setSelectedValues: (values: string[]) => void;
+};
+
+declare const SelectBadge: ({ value, options, setSelected, addSelected, removeSelected, multiple, className, addAll, handleAddAll, ...props }: SelectProps) => react_jsx_runtime.JSX.Element;
+
+type SelectDropdownProps = {
+    options: OptionType[];
+    open: boolean;
+    setOpen: React$1.Dispatch<React$1.SetStateAction<boolean>>;
+    addAll?: boolean;
+    multiple?: boolean;
+    isAllSelected: boolean;
+    isValueSelected: (val: string) => boolean;
+    handleSelectAll: () => void;
+    handleChange?: (selectedValue: string, wasSelected: boolean) => void;
+    parentRef?: React$1.RefObject<HTMLDivElement>;
+    className?: string;
+    passedRef?: Ref<HTMLDivElement>;
+    setSelectedValues?: (values: string[]) => void;
+};
+declare const SelectDropdown: ({ open, setOpen, options, addAll, multiple, isAllSelected, isValueSelected, handleSelectAll, handleChange: handleSelectChange, parentRef, className, passedRef, setSelectedValues, }: SelectDropdownProps) => react_jsx_runtime.JSX.Element;
+
+declare const SelectInput: ({ value, options, setSelected, addSelected, removeSelected, multiple, className, addAll, handleAddAll, showClearButton, ...props }: SelectProps) => react_jsx_runtime.JSX.Element;
+
+type SelectProps = {
+    options: OptionType[];
+    multiple?: boolean;
+    addAll?: boolean;
+    showClearButton?: boolean;
+} & SelectOptions & React.ComponentProps<"input">;
+
+type SidebarProps = {
+    className?: string;
+};
+declare const Sidebar: ({ className }: SidebarProps) => react_jsx_runtime.JSX.Element;
+
+type SidebarItemProps = {
+    item: SidebarItem$1;
+    nested?: boolean;
+    hasNextItems?: boolean;
+    isParentCategoryOpen?: boolean;
+} & React$1.AllHTMLAttributes<HTMLElement>;
+declare const SidebarItem: ({ item, hasNextItems, ...props }: SidebarItemProps) => react_jsx_runtime.JSX.Element;
+
+type SourceCodeLinkProps = {
+    link: string;
+    text?: string;
+    icon?: React$1.ReactNode;
+    className?: string;
+};
+declare const SourceCodeLink: ({ link, text, icon, className, }: SourceCodeLinkProps) => react_jsx_runtime.JSX.Element;
+
+type SplitListItem = {
+    title: string;
+    link: string;
+    description?: string;
+};
+type SplitListProps = {
+    items: SplitListItem[];
+    listsNum?: number;
+};
+declare const SplitList: ({ items, listsNum }: SplitListProps) => react_jsx_runtime.JSX.Element;
+
+type RootProps = React$1.HTMLAttributes<HTMLTableElement>;
+type HeaderProps = React$1.HTMLAttributes<HTMLTableSectionElement>;
+type HeaderCellProps = React$1.HTMLAttributes<HTMLTableCellElement>;
+type CellProps = React$1.HTMLAttributes<HTMLTableCellElement>;
+type BodyProps = React$1.HTMLAttributes<HTMLTableSectionElement>;
+declare const Table: (({ className, ...props }: RootProps) => react_jsx_runtime.JSX.Element) & {
+    Row: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableRowElement> & React$1.RefAttributes<HTMLTableRowElement>>;
+    Cell: ({ className, ...props }: CellProps) => react_jsx_runtime.JSX.Element;
+    Header: ({ className, ...props }: HeaderProps) => react_jsx_runtime.JSX.Element;
+    HeaderCell: ({ className, ...props }: HeaderCellProps) => react_jsx_runtime.JSX.Element;
+    Body: ({ className, ...props }: BodyProps) => react_jsx_runtime.JSX.Element;
+};
+
+type TabsProps = ComponentProps<typeof Tabs$1> & {
+    layoutType?: "horizontal" | "vertical";
+};
+declare const Tabs: ({ layoutType, className, ...props }: TabsProps) => react_jsx_runtime.JSX.Element;
+declare const TabsList: ({ className, ...props }: ComponentProps<typeof Tabs$1.List>) => react_jsx_runtime.JSX.Element;
+declare const TabsTrigger: ({ className, ...props }: ComponentProps<typeof Tabs$1.Trigger>) => react_jsx_runtime.JSX.Element;
+declare const TabsTriggerVertical: ({ className, children, ...props }: ComponentProps<typeof Tabs$1.Trigger>) => react_jsx_runtime.JSX.Element;
+type TabsContentWrapperProps = {
+    className?: string;
+    children: React$1.ReactNode;
+};
+declare const TabsContentWrapper: ({ className, ...props }: TabsContentWrapperProps) => react_jsx_runtime.JSX.Element;
+declare const TabsContent: (props: ComponentProps<typeof Tabs$1.Content>) => react_jsx_runtime.JSX.Element;
+
+type TextAreaProps = {
+    className?: string;
+} & React$1.DetailedHTMLProps<React$1.TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>;
+declare const TextArea: (props: TextAreaProps) => react_jsx_runtime.JSX.Element;
+
+declare const Toggle: ({ className, ...props }: React$1.ComponentProps<typeof Switch>) => react_jsx_runtime.JSX.Element;
+
+type TooltipProps = {
+    text?: string;
+    tooltipClassName?: string;
+    html?: string;
+    tooltipChildren?: React$1.ReactNode;
+    innerClassName?: string;
+} & React$1.HTMLAttributes<HTMLSpanElement> & ITooltip;
+declare const Tooltip: React$1.ForwardRefExoticComponent<{
+    text?: string;
+    tooltipClassName?: string;
+    html?: string;
+    tooltipChildren?: React$1.ReactNode;
+    innerClassName?: string;
+} & React$1.HTMLAttributes<HTMLSpanElement> & ITooltip & React$1.RefAttributes<HTMLSpanElement>>;
+
+type CommonProps = {
+    expandUrl?: string;
+    sectionTitle?: string;
+    openedLevel?: number;
+};
+type Type = {
+    name: string;
+    type: string;
+    optional?: boolean;
+    defaultValue?: string;
+    example?: string;
+    description?: string;
+    featureFlag?: string;
+    expandable: boolean;
+    children?: Type[];
+    deprecated?: {
+        is_deprecated: boolean;
+        description?: string;
+    };
+    since?: string;
+};
+type ParameterTypesType = {
+    types: Type[];
+    sectionTitle?: string;
+} & CommonProps & React$1.HTMLAttributes<HTMLDivElement>;
+declare const TypeList: ({ types, className, sectionTitle, expandUrl, openedLevel, ...props }: ParameterTypesType) => react_jsx_runtime.JSX.Element;
+
+type WideSectionProps = React$1.AllHTMLAttributes<HTMLElement> & {
+    as?: "div" | "main";
+};
+declare const WideSection: ({ children, className, as, }: WideSectionProps) => react_jsx_runtime.JSX.Element;
+
+type ZoomImgProps = React$1.DetailedHTMLProps<React$1.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>;
+declare const ZoomImg: (props: ZoomImgProps) => react_jsx_runtime.JSX.Element;
+
+type BareboneLayoutProps = {
+    htmlClassName?: string;
+    children: React$1.ReactNode;
+};
+declare const BareboneLayout: ({ htmlClassName, children, }: BareboneLayoutProps) => react_jsx_runtime.JSX.Element;
+
+type MainContentLayoutProps = {
+    mainWrapperClasses?: string;
+    contentClassName?: string;
+    children: React$1.ReactNode;
+    showContentMenu?: boolean;
+};
+
+type RootLayoutProps = {
+    bodyClassName?: string;
+    sidebarProps?: SidebarProps;
+    showBreadcrumbs?: boolean;
+    ProvidersComponent: React$1.FC<{
+        children: React$1.ReactNode;
+    }>;
+    footerComponent?: React$1.ReactNode;
+} & MainContentLayoutProps;
+declare const RootLayout: ({ bodyClassName, sidebarProps, ProvidersComponent, ...mainProps }: RootLayoutProps) => react_jsx_runtime.JSX.Element;
+
+declare const TightLayout: ({ children, footerComponent, showBreadcrumbs, ...props }: RootLayoutProps) => react_jsx_runtime.JSX.Element;
+
+declare const WideLayout: ({ children, footerComponent, showBreadcrumbs, ...props }: RootLayoutProps) => react_jsx_runtime.JSX.Element;
+
+type BrowserContextType = {
+    isBrowser: boolean;
+};
+type BrowserProviderProps = {
+    children: React$1.ReactNode;
+};
+declare const BrowserProvider: ({ children }: BrowserProviderProps) => react_jsx_runtime.JSX.Element;
+declare const useIsBrowser: () => BrowserContextType;
+
+type ColorMode = "light" | "dark";
+type ColorModeContextType = {
+    colorMode: ColorMode;
+    setColorMode: (value: ColorMode) => void;
+    toggleColorMode: () => void;
+};
+type ColorModeProviderProps = {
+    children: React$1.ReactNode;
+};
+declare const ColorModeProvider: ({ children }: ColorModeProviderProps) => react_jsx_runtime.JSX.Element;
+declare const useColorMode: () => ColorModeContextType;
+
+type MobileContextType = {
+    isMobile?: boolean;
+};
+type MobileProviderProps = {
+    children: React$1.ReactNode;
+};
+declare const MobileProvider: ({ children }: MobileProviderProps) => react_jsx_runtime.JSX.Element;
+declare const useMobile: () => MobileContextType;
+
+type ModalContextType = {
+    modalProps: ModalProps | null;
+    setModalProps: (value: ModalProps | null) => void;
+    closeModal: () => void;
+};
+type ModalProviderProps = {
+    children?: React$1.ReactNode;
+};
+declare const ModalProvider: ({ children }: ModalProviderProps) => react_jsx_runtime.JSX.Element;
+declare const useModal: () => ModalContextType;
+
+type NotificationItemType = {
+    id?: string;
+} & NotificationItemProps;
+type NotificationContextType = {
+    notifications: NotificationItemType[];
+    addNotification: (value: NotificationItemType) => void;
+    generateId: () => string;
+    removeNotification: (id: string) => void;
+    updateNotification: (id: string, updatedData: Partial<Omit<NotificationItemType, "id">>) => void;
+};
+declare enum NotificationReducerActionTypes {
+    ADD = "add",
+    REMOVE = "remove",
+    UPDATE = "update"
+}
+type NotificationReducerAction = {
+    type: NotificationReducerActionTypes.ADD;
+    notification: NotificationItemType;
+} | {
+    type: NotificationReducerActionTypes.REMOVE;
+    id: string;
+} | {
+    type: NotificationReducerActionTypes.UPDATE;
+    id: string;
+    updatedData: Partial<Omit<NotificationItemType, "id">>;
+};
+type NotificationProviderProps = {
+    children?: React$1.ReactNode;
+    initial?: NotificationItemType[];
+};
+declare const NotificationProvider: ({ children, initial, }: NotificationProviderProps) => react_jsx_runtime.JSX.Element;
+declare const useNotifications: (suppressError?: boolean) => NotificationContextType | null;
+
+type SearchCommand = {
+    name: string;
+    component?: React$1.ReactNode;
+    action?: () => void;
+    icon?: React$1.ReactNode;
+    title: string;
+    badge?: BadgeProps;
+};
+type SearchContextType = {
+    isOpen: boolean;
+    setIsOpen: React$1.Dispatch<React$1.SetStateAction<boolean>>;
+    searchClient: any;
+    commands: SearchCommand[];
+    command: SearchCommand | null;
+    setCommand: React$1.Dispatch<React$1.SetStateAction<SearchCommand | null>>;
+    setCommands: React$1.Dispatch<React$1.SetStateAction<SearchCommand[]>>;
+    modalRef: React$1.RefObject<HTMLDialogElement | null>;
+    indices: AlgoliaIndex[];
+    selectedIndex: string;
+    setSelectedIndex: (value: string) => void;
+};
+type AlgoliaIndex = {
+    value: string;
+    title: string;
+};
+type AlgoliaProps = {
+    appId: string;
+    apiKey: string;
+    mainIndexName: string;
+};
+type SearchProps = {
+    algolia: AlgoliaProps;
+};
+type SearchProviderProps = {
+    children: React$1.ReactNode;
+    indices?: AlgoliaIndex[];
+    defaultIndex?: string;
+    algolia?: AlgoliaProps;
+    searchProps?: any;
+    commands?: SearchCommand[];
+    modalClassName?: string;
+};
+declare const SearchProvider: ({ children, }: SearchProviderProps) => react_jsx_runtime.JSX.Element;
+declare const useSearch: () => SearchContextType;
+
+type SiteConfigContextType = {
+    config: DocsConfig;
+    setConfig: React$1.Dispatch<React$1.SetStateAction<DocsConfig>>;
+    frontmatter: FrontMatter;
+    setFrontmatter: React$1.Dispatch<React$1.SetStateAction<FrontMatter>>;
+    toc: ToCItem[] | null;
+    setToc: React$1.Dispatch<React$1.SetStateAction<ToCItem[] | null>>;
+};
+type SiteConfigProviderProps = {
+    config?: DocsConfig;
+    children?: React$1.ReactNode;
+};
+declare const SiteConfigProvider: ({ config: initConfig, children, }: SiteConfigProviderProps) => react_jsx_runtime.JSX.Element;
+declare const useSiteConfig: () => SiteConfigContextType;
+
+type AiAssistantChatType = "default" | "popover";
+type AiAssistantContextType = {
+    chatOpened: boolean;
+    setChatOpened: React$1.Dispatch<React$1.SetStateAction<boolean>>;
+    chatType: AiAssistantChatType;
+    inputRef: React$1.RefObject<HTMLInputElement | HTMLTextAreaElement | null>;
+    contentRef: React$1.RefObject<HTMLDivElement | null>;
+    loading: boolean;
+    isCaptchaLoaded: boolean;
+};
+type AiAssistantThreadItem = {
+    type: "question" | "answer" | "error";
+    content: string;
+    question_id?: string | null;
+    sources?: any[];
+    isGenerationAborted?: boolean;
+};
+type AiAssistantProviderProps = {
+    children?: React$1.ReactNode;
+    integrationId?: string;
+    chatType?: AiAssistantChatType;
+    type?: "search" | "chat";
+};
+declare const AiAssistantProvider: ({ children, chatType, }: AiAssistantProviderProps) => react_jsx_runtime.JSX.Element;
+declare const useAiAssistant: () => AiAssistantContextType;
+
+type MainNavContext = {
+    navItems: NavigationItem[];
+    activeItemIndex?: number;
+    activeItem?: NavigationItem;
+    editDate?: string;
+};
+type MainNavProviderProps = {
+    navItems: NavigationItem[];
+    children?: React$1.ReactNode;
+};
+declare const MainNavProvider: ({ navItems, children, }: MainNavProviderProps) => react_jsx_runtime.JSX.Element;
+declare const useMainNav: () => MainNavContext;
+
+type SidebarActionOptions = {
+    sidebar_id: string;
+    /**
+     * When specified, the items are added as children of the parent item
+     */
+    parent?: {
+        type: InteractiveSidebarItemTypes;
+        path: string;
+        title: string;
+        /**
+         * Whether to change the loaded state of the parent item
+         */
+        changeLoaded?: boolean;
+    };
+    /**
+     * The position to insert the items at
+     */
+    indexPosition?: number;
+    /**
+     * If enabled, the items are filtered to not add items that already exist
+     */
+    ignoreExisting?: boolean;
+};
+type SidebarStyleOptions = {
+    /**
+     * Useful for projects that have nested sidebars.
+     */
+    disableActiveTransition?: boolean;
+};
+type UpdateSidebarItemTypes = Partial<Pick<SidebarItemLink, "path" | "title" | "additionalElms">> | Partial<Pick<SidebarItemCategory, "title" | "loaded" | "onOpen" | "children">> | Partial<Pick<SidebarItemSidebar, "title" | "children">>;
+type UpdateActionType = {
+    sidebar_id: string;
+    items: {
+        existingItem: SidebarItem$1;
+        newItem: UpdateSidebarItemTypes;
+        options?: {
+            setChildrenBehavior: "replace" | "merge";
+        };
+    }[];
+};
+type SidebarContextType = {
+    sidebars: Sidebar$1[];
+    /**
+     * The sidebar that is currently shown
+     */
+    shownSidebar: Sidebar$1 | SidebarItemSidebar | undefined;
+    activePath: string | null;
+    activeItem: SidebarItemLink | null;
+    setActivePath: (path: string | null) => void;
+    /**
+     * Check if an item is active. This includes checking its child items,
+     * so for UI links that have children, the `checkLinkChildren` option should be set to `false`
+     * to ensure that the link isn't shown as active if a child link is active.
+     */
+    isItemActive: (options: {
+        item: InteractiveSidebarItem;
+        checkLinkChildren?: boolean;
+    }) => boolean;
+    addItems: (items: SidebarItem$1[], options?: SidebarActionOptions) => void;
+    updateItems: (options: UpdateActionType) => void;
+    removeItems: (options: {
+        items: SidebarItem$1[];
+        sidebar_id: string;
+    }) => void;
+    mobileSidebarOpen: boolean;
+    setMobileSidebarOpen: React$1.Dispatch<React$1.SetStateAction<boolean>>;
+    desktopSidebarOpen: boolean;
+    setDesktopSidebarOpen: React$1.Dispatch<React$1.SetStateAction<boolean>>;
+    isSidebarStatic: boolean;
+    /**
+     * Whether the active path should change when the hash changes
+     * This is only used by the API reference
+     */
+    shouldHandleHashChange: boolean;
+    sidebarRef: React$1.RefObject<HTMLDivElement | null>;
+    /**
+     * Go back in the sidebar history
+     */
+    goBack: () => void;
+    /**
+     * The height of the top part of the sidebar
+     */
+    sidebarTopHeight: number;
+    setSidebarTopHeight: React$1.Dispatch<React$1.SetStateAction<number>>;
+    /**
+     * Reset the sidebar to its initial state (the sidebars passed as a prop)
+     */
+    resetItems: () => void;
+    updatePersistedCategoryState: (title: string, opened: boolean) => void;
+    getPersistedCategoryState: (title: string) => boolean | undefined;
+    persistCategoryState: boolean;
+    isSidebarShown: boolean;
+    sidebarHistory: string[];
+    /**
+     * Get the first link child of a sidebar
+     */
+    getSidebarFirstLinkChild: (sidebar: Sidebar$1 | SidebarItemSidebar) => SidebarItemLink | undefined;
+    getSidebar: (sidebar_id: string) => Sidebar$1 | SidebarItemSidebar;
+} & SidebarStyleOptions;
+declare const SidebarContext: React$1.Context<SidebarContextType | null>;
+type ActionType = {
+    type: "add" | "update-child";
+    items: SidebarItem$1[];
+    options?: SidebarActionOptions;
+} | {
+    type: "replace";
+    sidebars: Sidebar$1[];
+} | {
+    type: "remove";
+    items: SidebarItem$1[];
+    sidebar_id: string;
+} | ({
+    type: "update";
+} & UpdateActionType);
+declare const reducer: (state: Sidebar$1[], actionData: ActionType) => Sidebar$1[];
+type SidebarProviderProps = {
+    children?: React$1.ReactNode;
+    isLoading?: boolean;
+    setIsLoading?: React$1.Dispatch<React$1.SetStateAction<boolean>>;
+    sidebars: Sidebar$1[];
+    shouldHandleHashChange?: boolean;
+    shouldHandlePathChange?: boolean;
+    scrollableElement?: Element | Window;
+    isSidebarStatic?: boolean;
+    persistCategoryState?: boolean;
+    disableActiveTransition?: boolean;
+} & SidebarStyleOptions;
+declare const SidebarProvider: ({ children, isLoading, setIsLoading, sidebars: initialSidebars, shouldHandleHashChange, shouldHandlePathChange, scrollableElement, isSidebarStatic, persistCategoryState, disableActiveTransition, }: SidebarProviderProps) => react_jsx_runtime.JSX.Element;
+declare const useSidebar: () => SidebarContextType;
+
+type Page = {
+    title: string;
+    description?: string;
+    parentTitle?: string;
+    link: string;
+};
+type PaginationContextType = {
+    nextPage?: Page;
+    previousPage?: Page;
+};
+declare const PaginationContext: React$1.Context<PaginationContextType | null>;
+type PaginationProviderProps = {
+    children?: React$1.ReactNode;
+};
+declare const PaginationProvider: ({ children }: PaginationProviderProps) => react_jsx_runtime.JSX.Element;
+declare const usePagination: () => PaginationContextType;
+
+declare function checkArraySameElms(arr1: Array<any>, arr2: Array<any>): boolean;
+
+declare function capitalize(str: string): string;
+
+declare function checkSidebarItemVisibility(item: HTMLElement, withTransition?: boolean, topMargin?: number): boolean;
+
+declare function decodeStr(str: string): string;
+
+declare function findPrevSibling(element: HTMLElement, selector: string): HTMLElement | null;
+declare function findNextSibling(element: HTMLElement, selector: string): HTMLElement | null;
+
+declare function getLinkWithBasePath(path: string, basePath?: string): string;
+
+type Options = {
+    basePath: string;
+};
+declare function getNavDropdownItems({ basePath }: Options): NavigationItem[];
+declare function normalizeMenuItems({ basePath, items, }: {
+    basePath: string;
+    items: MenuItem[];
+}): MenuItem[];
+
+declare function getBrowser(): "Chrome" | "Safari" | "Firefox" | "Internet Explorer" | "Edge" | "unknown";
+declare function getOsShortcut(): "⌘" | "Ctrl";
+
+declare function getScrolledTop(elm?: Element | Window): number;
+
+declare function isElmWindow(elm: unknown): elm is Window;
+
+declare function isInView(element: Element): boolean;
+
+declare const isSidebarItemLink: (item: SidebarItem$1 | undefined, options?: {
+    checkRef?: boolean;
+    checkExternal?: boolean;
+}) => item is SidebarItemLink;
+declare const areSidebarItemsEqual: ({ itemA, itemB, compareTitles, }: {
+    itemA: SidebarItem$1;
+    itemB: SidebarItem$1;
+    compareTitles?: boolean;
+}) => boolean;
+declare const findSidebarItem: ({ sidebarItems, item, checkChildren, compareTitles, }: {
+    sidebarItems: SidebarItem$1[];
+    item: SidebarItem$1;
+    checkChildren?: boolean;
+    compareTitles?: boolean;
+}) => SidebarItem$1 | undefined;
+declare const getSidebarItemWithHistory: ({ sidebarItems, item, sidebarHistory, checkChildren, compareTitles, }: {
+    sidebarItems: SidebarItem$1[];
+    item: SidebarItem$1;
+    sidebarHistory?: string[];
+    checkChildren?: boolean;
+    compareTitles?: boolean;
+}) => {
+    item: SidebarItem$1 | undefined;
+    sidebarHistory: string[];
+};
+
+export { type ActionType, type ActiveOnScrollItem, type AiAssistantChatType, type AiAssistantContextType, AiAssistantIcon, AiAssistantProvider, type AiAssistantProviderProps, type AiAssistantThreadItem, type AlgoliaIndex, type AlgoliaProps, Badge, type BadgeProps, type BadgeType, type BadgeVariant, BadgesList, BareboneLayout, type BareboneLayoutProps, type BaseTabType, BetaBadge, Bordered, BorderedIcon, type BorderedIconProps, type BorderedProps, Breadcrumbs, BrowserProvider, BundledProductIcon, Button, type ButtonProps, type ButtonType, type ButtonVariants, CalendarRefreshIcon, Card, CardList, type CardProps, ChefHatIcon, ChildDocs, CodeBlock, type CodeBlockMetaFields, type CodeBlockProps, type CodeBlockStyle, CodeMdx, type CodeMdxProps, CodeTab, CodeTabs, type CollapsedCodeLinesPosition, type CollapsibleCodeLines, type CollapsibleProps, type CollapsibleReturn, type ColorMode, type ColorModeContextType, ColorModeProvider, type ColorModeProviderProps, ColoredAcmeKitIcon, type CommonProps, ContentMenu, CopyButton, type CopyButtonChildFn, type CopyButtonProps, DecisionProcessIcon, DeprecatedNotice, type DeprecatedNoticeProps, Details, DetailsList, type DetailsProps, DetailsSummary, type DetailsSummaryProps, DocsTrackingEvents, DotsLoading, type DotsLoadingProps, DottedSeparator, type DottedSeparatorProps, DropdownMenu, EditButton, EditDate, ErpIcon, ErrorPage, type EventData, ExpandableNotice, type ExpandableNoticeProps, FeatureFlagNotice, type FeatureFlagNoticeProps, Feedback, type FeedbackProps, Footer, type FooterProps, GITHUB_ISSUES_LINK, type GitHubSearchItem, H1, type H1Props, H2, type H2Props, H3, type H3Props, H4, type Highlight, type HighlightProps, Hr, IconCircleDottedLine, IconCloudSolid, IconHeadline, ImageBinaryIcon, InlineCode, type InlineCodeProps, InlineIcon, InlineThemeImage, InputText, type InputTextProps, Kbd, type KbdProps, Label, type LabelProps, LayoutProvider, LayoutProviderContext, type LayoutProviderContextType, type LayoutProviderProps, Link, LinkButton, type LinkProps, Loading, type LoadingProps, MDXComponents, MainNav, type MainNavContext, MainNavProvider, type MainNavProviderProps, MarkdownContent, type MarkdownContentProps, Menu, type MenuProps, type MobileContextType, MobileProvider, type MobileProviderProps, Modal, type ModalContextType, ModalFooter, type ModalFooterProps, ModalHeader, type ModalHeaderProps, type ModalProps, ModalProvider, type ModalProviderProps, Note, type NoteProps, NotificationContainer, type NotificationContextType, NotificationItem, NotificationItemLayoutDefault, type NotificationItemLayoutDefaultProps, type NotificationItemProps, type NotificationItemType, NotificationProvider, type NotificationProviderProps, type NotificationReducerAction, NotificationReducerActionTypes, type OptionType, type Page, Pagination, PaginationContext, type PaginationContextType, PaginationProvider, type PaginationProviderProps, Prerequisites, PuzzleColoredIcon, QuestionMarkIcon, RadioItem, type RadioItemProps, Rating, type RatingProps, RestockIcon, RootLayout, type RootLayoutProps, RootProviders, ScrollControllerProvider, ScrollTextIcon, type SearchCommand, type SearchContextType, SearchInput, type SearchProps, SearchProvider, type SearchProviderProps, SelectBadge, SelectDropdown, type SelectDropdownProps, SelectInput, type SelectOptions, type SelectProps, ShadedBgIcon, ShopIcon, Sidebar, type SidebarActionOptions, SidebarContext, type SidebarContextType, SidebarItem, type SidebarItemProps, type SidebarProps, SidebarProvider, type SidebarProviderProps, type SidebarStyleOptions, type SiteConfigContextType, SiteConfigProvider, type SiteConfigProviderProps, Solutions, type SolutionsProps, SourceCodeLink, SpinnerLoading, type SpinnerLoadingProps, SplitList, type SplitListProps, StripeColoredIcon, type TabProps, Table, Tabs, TabsContent, TabsContentWrapper, TabsList, TabsTrigger, TabsTriggerVertical, TextArea, type TextAreaProps, ThemeImage, type ThemeImageProps, ThumbDownIcon, ThumbUpIcon, TightLayout, Toggle, Tooltip, type TooltipProps, type Type, TypeList, type UpdateActionType, type UpdateSidebarItemTypes, type UseActiveOnScrollProps, type UseChildDocsProps, type UseClickOutsideProps, VersionNotice, type VersionNoticeProps, WideLayout, WideSection, WindowPaintbrushIcon, ZoomImg, areSidebarItemsEqual, capitalize, checkArraySameElms, checkSidebarItemVisibility, decodeStr, findNextSibling, findPrevSibling, findSidebarItem, getBrowser, getLinkWithBasePath, getNavDropdownItems, getOsShortcut, getScrolledTop, getSidebarItemWithHistory, globalConfig, isElmWindow, isInView, isSidebarItemLink, navDropdownItems, normalizeMenuItems, products, reducer, useActiveOnScroll, useAiAssistant, useClickOutside, useCollapsible, useCollapsibleCodeLines, useColorMode, useCopy, useEvent, useHeadingUrl, useIsBrowser, useIsExternalLink, useKeyboardShortcut, type useKeyboardShortcutOptions, useLayout, useMainNav, useMobile, useModal, useMutationObserver, useNotifications, usePageScrollManager, usePagination, usePrevious, useResizeObserver, useScrollController, useScrollPosition, useScrollPositionBlocker, useSearch, useSelect, useSidebar, useSiteConfig, useTabs };