import { type ComponentProps, type ComponentType, type ReactNode } from "react";
/**
 * One shell for the composer "+" menu and its drill-ins, regardless of the
 * kind of resource: the app's one menu surface at a fixed width.
 */
export declare const COMPOSER_MENU_PANEL_CLASS: string;
/** The back control of every drill-in header. */
export declare function MenuBackButton({ label, className, ...props }: Omit<ComponentProps<"button">, "children"> & {
    label?: string;
}): import("react").JSX.Element;
/** A drill-in's header: back, the submenu's title, optional trailing control. */
export declare function ComposerMenuHeader(props: {
    title: string;
    leading?: ReactNode | undefined;
    trailing?: ReactNode | undefined;
}): import("react").JSX.Element;
/** Visual-only form for a row that already owns the accessible toggle action. */
export declare function ComposerMenuSwitchIndicator({ checked }: {
    checked: boolean;
}): import("react").JSX.Element;
export declare function ComposerMenuSwitch(props: {
    checked: boolean;
    onCheckedChange: (checked: boolean) => void;
    label: string;
    disabled?: boolean | undefined;
    locked?: boolean | undefined;
    className?: string | undefined;
}): import("react").JSX.Element;
/**
 * Rows still loading inside a composer menu: the same height as the rows they
 * stand for, so the menu opens at its final size and nothing jumps when they
 * arrive. Never a "Loading…" sentence inside an action menu.
 */
export declare function ComposerMenuRowsSkeleton({ rows, label, size, }: {
    rows?: number | undefined;
    /** Announced to screen readers ("Loading connectors"). */
    label: string;
    /** `row`: 32px menu rows; `tile`: 56px rows with a tile and a second line. */
    size?: "row" | "tile" | undefined;
}): import("react").JSX.Element;
/**
 * A composer drill-in whose body loads on demand registers its loader here.
 * Registering loads nothing; the composer warms every registered drill-in
 * when "+" is hovered, focused or idle, so opening one never waits on code.
 */
export declare function registerComposerMenuPreload(load: () => Promise<unknown>): void;
export declare function preloadComposerMenuPanels(): void;
/**
 * `React.lazy` that renders straight away once its code is loaded. Plain lazy
 * suspends for a frame on its first render even when the module is already
 * cached, which flashes the loading rows and resizes the menu. The loader is
 * registered as a composer drill-in preload. Keep a Suspense boundary around
 * it for the cold case.
 */
export declare function lazyComposerPanel<P extends object>(load: () => Promise<ComponentType<P>>): ComponentType<P>;