import { AnchorHTMLAttributes } from 'react';
import { ClassValue } from 'clsx';
import { ComponentType } from 'react';
import { CSSProperties } from 'react';
import { HTMLAttributes } from 'react';
import { InputHTMLAttributes } from 'react';
import { JSX } from 'react/jsx-runtime';
import { KeyboardEvent as KeyboardEvent_2 } from 'react';
import { LazyExoticComponent } from 'react';
import { MouseEvent as MouseEvent_2 } from 'react';
import { Placement } from '@floating-ui/react';
import { PropsWithChildren } from 'react';
import { ReactNode } from 'react';

/**
 * Displays an application shell with desktop and mobile layouts.
 */
export declare function AppRoot({ enableSiteSearch, navLinks, routes, ...context }: {
    commonQuestions?: CommonQuestion[];
    enableSiteSearch?: boolean | undefined;
    navLinks: ReactNode;
    overview?: ReactNode | undefined;
    packageDescription: string;
    packageName: string;
    repositoryUrl: string;
    routes: Record<string, LazyExoticComponent<ComponentType<unknown>>>;
    showOpenCollectLink?: boolean | undefined;
    versions?: Versions | undefined;
}): JSX.Element;

export declare function assert(expectedCondition: unknown, message?: string): asserts expectedCondition;

export declare function Block({ children, className, ...rest }: PropsWithChildren<HTMLAttributes<HTMLDivElement> & {
    className?: string;
}>): JSX.Element;

export declare function Box({ align, children, className, direction, gap, grow, justify, shrink, style, wrap, ...rest }: HTMLAttributes<HTMLDivElement> & {
    align?: "center" | "end" | "start" | "stretch" | undefined;
    className?: string | undefined;
    direction: "column" | "row";
    gap?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | undefined;
    grow?: 0 | 1 | undefined;
    justify?: "around" | "between" | "center" | "end" | "start" | "stretch" | undefined;
    shrink?: 0 | 1 | undefined;
    style?: CSSProperties | undefined;
    wrap?: boolean | undefined;
}): JSX.Element;

export declare function Button({ children, className, disabled, intent, ...rest }: PropsWithChildren<{
    className?: string | undefined;
    disabled?: boolean | undefined;
    intent?: Intent | undefined;
    onClick?: ((event: MouseEvent_2) => void) | undefined;
    onKeyDown?: ((event: KeyboardEvent_2) => void) | undefined;
}>): JSX.Element;

export declare function Callout({ children, className, html, inline, intent, minimal, ...rest }: PropsWithChildren<HTMLAttributes<HTMLDivElement> & {
    className?: string | undefined;
    html?: boolean;
    inline?: boolean;
    intent?: Intent;
    minimal?: boolean;
}>): JSX.Element;

export declare function Checkbox({ checked, children, className, indeterminate, onChange, ...rest }: PropsWithChildren<Omit<HTMLAttributes<HTMLElement>, "defaultChecked" | "onChange"> & {
    checked: boolean;
    className?: string | undefined;
    indeterminate?: boolean;
    onChange: (value: boolean) => void;
}>): JSX.Element;

export declare function cn(...inputs: ClassValue[]): string;

export declare function Code({ className, html }: {
    className?: string;
    html: string;
}): JSX.Element;

export declare type CommonQuestion = {
    answer: ReactNode;
    id: string;
    question: ReactNode;
};

declare function CommonQuestionsRoute(): JSX.Element;

export declare type ComponentMetadata = {
    description: Section[];
    filePath: string;
    name: string;
    props: {
        [name: string]: ComponentPropMetadata;
    };
};

declare type ComponentPropMetadata = {
    description: Section[];
    html: string;
    name: string;
    required: boolean;
};

export declare function ComponentProps({ json, section }: {
    json: ComponentMetadata;
    section: string;
}): JSX.Element;

export declare function ComponentPropsSection({ header, props }: {
    header: string;
    props: ComponentPropMetadata[];
}): JSX.Element | null;

export declare type DefaultPath = keyof Routes;

export declare function DocsSection({ className, sections }: {
    className?: string;
    sections: Section[];
}): JSX.Element;

export declare function ErrorBoundary({ children }: PropsWithChildren): JSX.Element;

export declare function ExternalLink({ children, className, href, target, ...rest }: AnchorHTMLAttributes<HTMLAnchorElement>): JSX.Element;

export declare function getIntentClassNames(intent: Intent, minimal?: boolean): "bg-red-950 text-red-300 [&_svg]:text-red-500" | "bg-black/10 bg-border border-2 border-red-500 text-white [&_svg]:text-red-500 [&_a]:text-red-400!" | "bg-white/10 text-slate-300 [&_svg]:text-slate-400" | "bg-black/10 bg-border border-2 border-white/40 text-white [&_svg]:text-white/60" | "bg-sky-950 text-sky-300 [&_svg]:text-sky-400" | "bg-black/10 bg-border border-2 border-sky-400 text-white [&_svg]:text-sky-400" | "bg-emerald-950 text-emerald-300 [&_svg]:text-emerald-400" | "bg-black/10 bg-border border-2 border-emerald-400 text-white [&_svg]:text-emerald-400" | "bg-amber-950/65 text-amber-200 [&_svg]:text-amber-300" | "bg-black/10 bg-border border-2 border-amber-400 text-white [&_svg]:text-amber-400 [&_a]:text-amber-400!";

declare function GettingStartedRoute(): JSX.Element;

export declare function Header({ section, sourceCodePath, title }: {
    section?: string;
    sourceCodePath?: string;
    title: string;
}): JSX.Element;

export declare function ImperativeHandle({ json, section }: {
    json: ImperativeHandleMetadata;
    section: string;
}): JSX.Element;

export declare type ImperativeHandleMetadata = {
    description: Section[];
    filePath: string;
    name: string;
    methods: ImperativeHandleMethodMetadata[];
};

declare type ImperativeHandleMethodMetadata = {
    description: Section[];
    html: string;
    name: string;
};

export declare function Input<Type extends string>({ children, className, onChange, value, ...rest }: PropsWithChildren<Omit<InputHTMLAttributes<HTMLInputElement>, "onChange"> & {
    className?: string | undefined;
    onChange: (value: Type) => void;
    value: Type;
}>): JSX.Element;

export declare type Intent = "danger" | "none" | "primary" | "success" | "warning";

export declare function Link({ children, onClick, to, ...rest }: Omit<HTMLAttributes<HTMLSpanElement>, "children"> & {
    children?: ReactNode | RenderFunction;
    to: string;
}): JSX.Element;

export declare function LoadingSpinner(): JSX.Element;

export declare function NavLink<Path extends string = DefaultPath>({ children, className, path }: PropsWithChildren<{
    className?: string | undefined;
    path: Path;
}>): JSX.Element;

export declare function NavSection({ children, label }: PropsWithChildren<{
    label: ReactNode;
}>): JSX.Element;

declare type Option_2<Value extends string> = {
    label: string;
    value: Value;
};
export { Option_2 as Option }

declare function PageNotFoundRoute(): JSX.Element;

export declare function Radio<Value extends string>({ checked, children, className, name, onChange, value, ...rest }: PropsWithChildren<Omit<HTMLAttributes<HTMLElement>, "defaultChecked" | "onChange"> & {
    checked: boolean;
    name: string;
    onChange: (value: Value) => void;
    value: Value;
}>): JSX.Element;

declare type RenderFunction = (params: {
    isActive: boolean;
    isPending: boolean;
}) => ReactNode;

declare type Route = LazyExoticComponent<ComponentType<unknown>>;

declare type Routes = Record<keyof typeof routes, Route>;

declare const routes: {
    "*": LazyExoticComponent<PageNotFoundRoute>;
    "/": LazyExoticComponent<GettingStartedRoute>;
    "/common-questions": LazyExoticComponent<CommonQuestionsRoute>;
    "/support": LazyExoticComponent<SupportRoute>;
    "/versions": LazyExoticComponent<VersionsRoute>;
};

export declare type Section = {
    content: string;
    intent?: Intent | undefined;
};

export declare function Select<Value extends string>({ className, defaultValue, onChange, options, placeholder, value }: {
    className?: string;
    defaultValue?: Option_2<Value> | undefined;
    onChange: (value: Option_2<Value>) => void;
    options: Option_2<Value>[];
    placeholder?: string;
    value: Option_2<Value> | undefined;
}): JSX.Element;

export declare type SiteSearchRecord = {
    path: string;
    section?: string | undefined;
    title: string;
};

declare function SupportRoute(): JSX.Element;

export declare function Tooltip({ children, className, content, positions, showOnFocus, showOnHover, usePortal }: PropsWithChildren<{
    className?: string;
    content: ReactNode;
    positions?: Array<Placement> | undefined;
    showOnFocus?: boolean;
    showOnHover?: boolean;
    usePortal?: boolean;
}>): JSX.Element;

declare type Versions = {
    [fullVersion: string]: string;
};

declare function VersionsRoute(): JSX.Element;

export { }