import * as class_variance_authority_types from 'class-variance-authority/types';
import * as preact from 'preact';
import { JSX, ComponentChildren, ComponentType } from 'preact';
import { VariantProps } from 'class-variance-authority';
import { ClassValue } from 'clsx';
import { SiteName, NavNode, Heading, PlaygroundProvider, CopyPageAction, IslandName } from '@clean-jsdoc-theme/utils';
export { ChromeKey, DEFAULT_I18N, I18n, InterpolationVars, LanguageProvider, Messages, createI18n, useI18n, useTranslation } from '@clean-jsdoc-theme/bhasha';

/**
 * shadcn-style Button, ported to Preact. Variant + size are cva-driven and
 * resolve to the semantic theme tokens (see dwar's `@theme` mapping).
 *
 * Note: Preact function components don't forward refs by default, and we avoid
 * pulling in `preact/compat` just for that. Call sites that need a ref on the
 * underlying element use `buttonVariants(...)` on a native `<button>` instead.
 */
declare const buttonVariants: (props?: ({
    variant?: "default" | "secondary" | "outline" | "ghost" | "link" | null | undefined;
    size?: "default" | "sm" | "lg" | "icon" | "icon-sm" | "icon-xs" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
interface ButtonProps extends Omit<JSX.IntrinsicElements['button'], 'size'>, VariantProps<typeof buttonVariants> {
}
declare function Button({ class: cls, variant, size, ...props }: ButtonProps): JSX.Element;

interface ButtonGroupProps {
    children?: ComponentChildren;
    /**
     * Layout axis. `horizontal` (default) joins children left↔right; `vertical`
     * stacks and joins them top↔bottom.
     */
    orientation?: 'horizontal' | 'vertical';
    /** Accessible label for the group. */
    label?: string;
    class?: string;
}
/**
 * shadcn-style ButtonGroup: lays out adjacent buttons (or button-like children)
 * as a single segmented control. Direct children lose their inner border radii
 * and their shared 1px border is collapsed (`-ml-px` / `-mt-px`), so the row
 * reads as one connected unit with only its outer corners rounded. A focused
 * child lifts above its neighbor (`z-10`) so its focus ring isn't clipped.
 *
 * Compose with {@link Button} for a segmented control, or pair a {@link Button}
 * with a {@link DropdownMenu} trigger for a split button.
 */
declare function ButtonGroup({ children, orientation, label, class: cls, }: ButtonGroupProps): preact.JSX.Element;

interface DropdownMenuProps {
    /** Controlled open state. Omit for an uncontrolled menu. */
    open?: boolean;
    onOpenChange?: (open: boolean) => void;
    children?: ComponentChildren;
    class?: string;
}
declare function DropdownMenu({ open: openProp, onOpenChange, children, class: cls, }: DropdownMenuProps): JSX.Element;
type DropdownMenuTriggerProps = JSX.IntrinsicElements['button'];
/**
 * The button that toggles the menu. Style it yourself (e.g. with
 * `buttonVariants(...)`) — it only adds the menu wiring and ARIA. `ArrowDown`
 * and `Enter`/`Space` open the menu (which then focuses the first item).
 */
declare function DropdownMenuTrigger({ class: cls, children, onClick, onKeyDown, ...rest }: DropdownMenuTriggerProps): JSX.Element;
interface DropdownMenuContentProps {
    children?: ComponentChildren;
    /** Which edge of the trigger the menu aligns to. */
    align?: 'start' | 'end';
    /** Accessible label; defaults to being labelled by the trigger. */
    label?: string;
    class?: string;
}
declare function DropdownMenuContent({ children, align, label, class: cls, }: DropdownMenuContentProps): JSX.Element | null;
interface DropdownMenuItemProps {
    children?: ComponentChildren;
    /** Fired when the item is activated (click / Enter / Space); the menu closes after. */
    onSelect?: () => void;
    /** Render as a link (e.g. "Open in ChatGPT") instead of a button. */
    href?: string;
    target?: string;
    rel?: string;
    disabled?: boolean;
    class?: string;
}
declare function DropdownMenuItem({ children, onSelect, href, target, rel, disabled, class: cls, }: DropdownMenuItemProps): JSX.Element;
declare function DropdownMenuSeparator({ class: cls }: {
    class?: string;
}): JSX.Element;
declare function DropdownMenuLabel({ children, class: cls, }: {
    children?: ComponentChildren;
    class?: string;
}): JSX.Element;

interface DialogProps {
    open: boolean;
    onOpenChange: (open: boolean) => void;
    /** Accessible label for the dialog surface. */
    label?: string;
    /**
     * Placement of the surface:
     *   - `center` (default) / `top` — a centered or top-anchored modal (zoom).
     *   - `left` / `right` — a full-height side sheet that slides in from that
     *     edge (used for the mobile nav drawer).
     */
    align?: 'center' | 'top' | 'left' | 'right';
    /** Render the built-in top-right close button (default true). */
    showClose?: boolean;
    /** Extra classes on the content panel. */
    class?: string;
    children?: ComponentChildren;
}
declare function Dialog({ open, onOpenChange, label, align, showClose, class: cls, children, }: DialogProps): preact.JSX.Element | null;
interface DialogSectionProps {
    children?: ComponentChildren;
    class?: string;
}
declare function DialogHeader({ children, class: cls }: DialogSectionProps): preact.JSX.Element;
declare function DialogTitle({ children, class: cls }: DialogSectionProps): preact.JSX.Element;
declare function DialogBody({ children, class: cls }: DialogSectionProps): preact.JSX.Element;
declare function DialogFooter({ children, class: cls }: DialogSectionProps): preact.JSX.Element;

/**
 * shadcn's class-merge helper: compose conditional classes (clsx) and resolve
 * conflicting Tailwind utilities so a caller-supplied class wins (tailwind-merge).
 */
declare function cn(...inputs: ClassValue[]): string;

interface LayoutPkg {
    name?: string;
    version?: string;
    repository?: string;
    homepage?: string;
}
interface LayoutProps {
    children?: ComponentChildren;
    /** Header control slot (search, language, theme, settings); rendered on the header's right. */
    headerControls?: ComponentChildren;
    /** Left nav slot. When omitted, the sidebar column is not rendered. */
    sidebar?: ComponentChildren;
    /** Right table-of-contents slot. When omitted, the toc column is not rendered. */
    toc?: ComponentChildren;
    /**
     * Mobile table-of-contents slot — a bar shown below the header under `lg`,
     * where the right-rail `toc` column is hidden. When omitted, nothing renders.
     */
    tocMobile?: ComponentChildren;
    pkg?: LayoutPkg;
    siteName?: SiteName;
    basePath?: string;
    /**
     * Author-supplied footer HTML (`opts.footer`). When set, the default `Footer`
     * is replaced by this markup; omit for the default footer.
     */
    footer?: string;
}
/**
 * Page chrome shell: header + 3-column grid (sidebar · main · toc) + footer.
 *
 * Pure markup. It renders whatever nodes the caller supplies in the
 * `sidebar` / `toc` / `headerControls` slots and never references islands
 * itself. dwar wraps its island components in hydration markers and passes
 * them into these slots, so the chrome markup lives here once.
 */
declare function Layout({ children, headerControls, sidebar, toc, tocMobile, pkg, siteName, basePath, footer, }: LayoutProps): preact.JSX.Element;

interface HeaderPkg {
    name?: string;
    version?: string;
    repository?: string;
    homepage?: string;
}
interface HeaderProps {
    siteName?: SiteName;
    pkg?: HeaderPkg;
    basePath?: string;
    children?: ComponentChildren;
}
declare function Header({ siteName, pkg, basePath, children }: HeaderProps): preact.JSX.Element;

interface FooterPkg {
    name?: string;
    repository?: string;
    homepage?: string;
}
interface FooterProps {
    pkg?: FooterPkg;
    /** Site name or logo; takes precedence over `pkg.name` (mirrors the header). */
    siteName?: SiteName;
    year?: number;
    /**
     * Author-supplied footer HTML (`opts.footer`, resolved to a string by the
     * bridge). When set, it replaces the default footer markup entirely — rendered
     * verbatim inside the `<footer>` element. Style it via `customCss`.
     */
    custom?: string;
}
declare function Footer({ pkg, siteName, year, custom }: FooterProps): preact.JSX.Element;

interface BrandProps {
    /** Plain text, or a per-theme logo image set. */
    siteName?: SiteName;
    /** Text fallback when `siteName` carries no logo (typically `pkg.name`). */
    fallback?: string;
    /** Classes for the text-label variant. */
    textClass?: string;
    /** Classes for the logo `<img>` variant. */
    logoClass?: string;
    /**
     * Classes for an element wrapping the logo image(s). Only applies to the logo
     * variant — when set, the `<img>`(s) are wrapped in a `<span>` carrying these
     * classes, giving a stable container to style (padding, background, rounding)
     * regardless of the single- vs dark/light-pair rendering. Omit for no wrapper.
     */
    containerClass?: string;
}
/**
 * Site identity — renders either the site name as text or a logo image,
 * depending on whether `siteName` is a string or a `{ default, dark, light }`
 * set. Used by the header, footer, and mobile nav so the text/logo decision and
 * the dark/light image swap live in one place.
 *
 * Dark/light is handled with CSS only: both images render and the `dark:`
 * variant (rebound to `[data-theme="dark"]`, set pre-paint by the theme script)
 * toggles which is shown — no JS, no flash, nothing to hydrate. A single
 * supplied image (or `light === dark`) renders one `<img>` with no toggle.
 */
declare function Brand({ siteName, fallback, textClass, logoClass, containerClass }: BrandProps): preact.JSX.Element;

interface SidebarProps {
    nav: NavNode[];
    currentSlug: string;
    /**
     * Base-path prefix for internal nav links (default `'/'`). This island
     * hydrates from JSON props, so the prefix must travel as a prop — not via a
     * Preact context (which wouldn't survive to the client).
     */
    basePath?: string;
    /**
     * Top-level section labels that render as collapse toggles (resolved by setu
     * into `manifest.collapsibleGroups`). Defaults to `[]` → every header static
     * (today's behavior). A listed label's header becomes a chevron toggle that
     * shows/hides its items; state persists in `localStorage` (default open).
     */
    collapsibleGroups?: string[];
}
interface SidebarItemProps {
    /** Leading icon node (e.g. a lucide icon element). */
    icon: ComponentChildren;
    label: string;
    onClick: () => void;
}
/**
 * A clickable sidebar row with a leading icon, styled like a nav entry. Used
 * for the action items (theme toggle, settings) at the top of the mobile nav
 * drawer — sharing `ITEM_BASE`/`ITEM_INACTIVE` so it matches the page links.
 */
declare function SidebarItem({ icon, label, onClick }: SidebarItemProps): preact.JSX.Element;
declare function Sidebar({ nav, currentSlug, basePath, collapsibleGroups }: SidebarProps): preact.JSX.Element;

interface MobileNavProps {
    nav: NavNode[];
    currentSlug: string;
    siteName?: SiteName;
    basePath?: string;
    collapsibleGroups?: string[];
}
/**
 * Mobile navigation island. The desktop sidebar column is hidden below `md`
 * (see rang's `Layout`); this provides the same navigation behind a header
 * trigger instead.
 *
 * The trigger is a `panel-right` icon button; tapping it opens a left side
 * sheet (the `Dialog` `align="left"` variant — so the overlay, Escape,
 * click-outside, focus trap, and scroll lock are all reused, not reimplemented).
 *
 * The sheet stacks, top to bottom: the site name (matching the header), the
 * theme toggle and settings as sidebar rows, then the full page list — all
 * reused from their existing components/hooks so nothing here duplicates the
 * desktop chrome. Tapping any item closes the drawer; "Settings" also opens the
 * settings dialog, which is rendered as a sibling of the drawer so it survives
 * the drawer unmounting.
 */
declare function MobileNav({ nav, currentSlug, siteName, basePath, collapsibleGroups, }: MobileNavProps): preact.JSX.Element;

interface TOCProps {
    headings: Heading[];
}
declare function TOC({ headings }: TOCProps): preact.JSX.Element | null;

interface TocPopoverProps {
    headings: Heading[];
}
/**
 * Mobile "On this page" bar — the `< lg` counterpart to the curved right-rail
 * `TOC`. Heavily influenced by fumadocs' toc popover: a trigger row (a circular
 * scroll-progress indicator + the current section title + a chevron) that
 * expands a height-animated, scrollable list of the page headings. Tapping a
 * heading or clicking outside collapses it; Escape closes too.
 *
 * Tracks the current section by scroll position via `useTocProgress` (a
 * reading-line rule, correct at the top and bottom of the page) and shares the
 * depth indentation (`getItemOffset`) with the rail. The compact list marks the
 * single current section ("you are here") rather than the rail's visible-set
 * span.
 *
 * The sticky/breakpoint placement lives in the Layout slot, not here, mirroring
 * the rail. Note: on `≥ lg` the rail is shown and this bar is CSS-hidden, but
 * both islands still hydrate — each runs its own scroll/observer listener.
 * That's an accepted tradeoff to keep each island a single, independent
 * hydration root rather than sharing tracking state across two roots.
 */
declare function TocPopover({ headings }: TocPopoverProps): preact.JSX.Element | null;

/**
 * A node (e.g. the copy-page button) to drop into the first heading's row.
 * `placed` guards against re-placement when a page has more than one heading.
 * Mutating it during render is safe here: MDX content is server-rendered in a
 * single top-down pass and never hydrated as a whole (only its island markers
 * hydrate, independently), so the first heading rendered is the page's.
 */
interface HeaderSlot {
    node: ComponentChildren;
    placed: boolean;
}
/** Provided by dwar around the MDX render; consumed by the first heading. */
declare const HeaderSlotContext: preact.Context<HeaderSlot | null>;
/**
 * Base-path prefix for INTERNAL in-content links, provided by dwar around the
 * SSR-only MDX render (the body is rendered to a string, never hydrated, so a
 * context is safe — no client-side provider exists). Consumed by `MdxA`,
 * `SourceLink`, and `MemberMeta` to prefix root-relative hrefs. Defaults to `/`
 * (the root, identity-prefix), so unset behavior is unchanged.
 */
declare const BasePathContext: preact.Context<string>;
/**
 * Map from a doc image `src` to inline SVG markup. dwar fills it (per render)
 * from the bridge's read of the referenced `.svg` doc assets; `MdxImg` inlines
 * any `src` present here instead of `<img>`-ing it, so the SVG's
 * `[data-theme="dark"]` styles follow the theme toggle (an `<img>`-loaded SVG
 * only sees the OS `prefers-color-scheme`).
 */
declare const InlineSvgContext: preact.Context<Record<string, string>>;
/**
 * Turns a TypeScript signature string into shiki-highlighted inline HTML (the
 * coloured token `<span>`s, no `<pre>`/`<code>` wrapper). dwar provides it per
 * render (shiki loads at compile time, keeping render() pure); when absent — unit
 * tests, or a host that didn't wire it — signatures fall back to plain `<code>`.
 */
type SignatureHighlighter = (code: string) => string;
declare const SignatureHighlightContext: preact.Context<SignatureHighlighter | null>;

interface CodeBlockProps {
    /** Raw code as a string — standalone / `CodeTabs` use. */
    code?: string;
    /** Language hint → `language-*` class on `<code>` (string-`code` mode only). */
    lang?: string;
    /** Show the hover copy button (default true). */
    showCopy?: boolean;
    /**
     * Wrap in the bordered chrome (default true). Set false when an outer
     * container already provides the border (e.g. `CodeTabs` panels).
     */
    bordered?: boolean;
    /**
     * MDX `pre` mode: `children` is the `<code>` vnode. Shiki (rehype) emits its
     * `shiki …` class + `--shiki-*` inline style on THIS element (the `<pre>`) and
     * the highlighted nodes inside the `<code>`. `className`/`class`/`style` are
     * therefore the pre's own attributes; the code vnode carries the inner nodes.
     */
    children?: ComponentChildren;
    className?: unknown;
    class?: unknown;
    style?: unknown;
}
/**
 * The single block-code renderer. It is the MDX `pre` component (handles a
 * `<code>` child + Shiki's class/style) and also serves standalone / `CodeTabs`
 * use via a raw `code` string + `lang`. In bordered mode it owns the card + a
 * header bar (a `CODE`/filename label on the left; the copy control and, when a
 * `<Playground>` wrapper supplies providers, the "Open Code in" dropdown on the
 * right). The `copy-btn` / `playground` island markers dwar's loader hydrates
 * live in that header. Unbordered mode (e.g. `CodeTabs` panels) keeps the old
 * borderless body with a floating hover copy button.
 */
declare function CodeBlock({ code, lang, showCopy, bordered, children, className, class: klass, style, }: CodeBlockProps): preact.JSX.Element;

interface CodeTab {
    label: string;
    lang: string;
    code: string;
}
interface CodeTabsProps {
    tabs: CodeTab[];
}
declare function CodeTabs({ tabs }: CodeTabsProps): preact.JSX.Element | null;

interface CodeViewerProps {
    /** Full file text (used for SSR fallback; the client re-reads it from the DOM <pre>). */
    code: string;
    /** Monaco language id, e.g. 'javascript'. */
    language: string;
    filename?: string;
    /** 1-based line to reveal + highlight. Falls back to the `#L<n>` URL hash. */
    highlightLine?: number;
}
declare function CodeViewer({ code, language, filename, highlightLine }: CodeViewerProps): preact.JSX.Element;

interface CopyBtnProps {
    text: string;
}
/**
 * Copy-to-clipboard button for a code block's header. Styled like the sibling
 * "Open Code in" trigger — the same `outline`/`sm` button variant, `rounded-lg`
 * (0.5rem) — so the two header controls are balanced. On a successful copy the
 * copy glyph is swapped for a check (tick) for 2s.
 */
declare function CopyBtn({ text }: CopyBtnProps): preact.JSX.Element;

interface SimpleIconProps {
    /** Simple Icons slug, e.g. `codepen`, `jsfiddle`, `npm`. */
    slug: string;
    /** Extra classes (sizing/spacing). Defaults to a 1rem square. */
    class?: string;
}
/**
 * A monochrome Simple Icons CDN glyph, painted with the `fg` theme token via a
 * CSS mask. The silhouette SVG (`cdn.simpleicons.org/<slug>`) is used as a mask
 * over a `var(--clean-fg)` fill, so it picks up the exact fg color and the
 * light/dark swap for free (the variable is rebound under `[data-theme="dark"]`)
 * — no per-theme image pair, no baked-in hex. Shared by the sidebar's `NavIcon`
 * and the playground "Open Code in" menu.
 */
declare function SimpleIcon({ slug, class: cls }: SimpleIconProps): preact.JSX.Element;

/**
 * The resolved playground config for the code block nested inside a
 * `<Playground>` — read by {@link CodeBlock} via {@link usePlayground}.
 */
interface PlaygroundContextValue {
    /** Providers the block can be opened in (empty → no "Open Code in" dropdown). */
    providers: PlaygroundProvider[];
    /** Header label override (else the localized `CODE` label). */
    filename?: string;
    /** 1-based line numbers to highlight in the code body. */
    highlight: number[];
}
/**
 * Set by a `<Playground>` wrapper, consumed by the nested `CodeBlock`. `null`
 * outside a wrapper — an ordinary code block renders with no filename/highlight
 * and no dropdown.
 */
declare const PlaygroundContext: preact.Context<PlaygroundContextValue | null>;
/** Read the enclosing `<Playground>` config (or `null`). */
declare function usePlayground(): PlaygroundContextValue | null;
interface PlaygroundProps {
    /** Space-separated provider list (setu emits the resolved set). */
    providers?: string;
    /** Filename header label. */
    filename?: string;
    /** Comma-separated 1-based line numbers to highlight. */
    highlight?: string;
    children?: ComponentChildren;
}
/**
 * setu emits `<Playground providers="codepen jsfiddle" filename="x.js"
 * highlight="1,4,8">` wrapping a single code fence (the same capitalized-JSX
 * round-trip as `<Embed>`/`<Callout>`). This component is a **context provider
 * with no markup of its own**: it parses the stringy attributes into a
 * {@link PlaygroundContextValue} and renders its children, so the nested
 * `CodeBlock` can read the config and add the filename header, line highlight,
 * and the "Open Code in" dropdown. SSR-only — the playground island re-reads its
 * config from the DOM at hydration, so this context never crosses that boundary.
 */
declare function Playground({ providers, filename, highlight, children }: PlaygroundProps): preact.JSX.Element;

interface PlaygroundMenuProps {
    /** Enabled providers, in render order. */
    providers: PlaygroundProvider[];
    /** Source to prefill — read from the sibling `<pre>` at hydration. */
    code?: string;
    /** Site-wide per-provider options — read from the page payload at hydration. */
    options?: Partial<Record<PlaygroundProvider, Record<string, unknown>>>;
}
/**
 * The "Open Code in" dropdown — the body of the `playground` in-content island
 * (mounted into the `data-island="playground"` marker `CodeBlock` renders in a
 * code block's header). One menu item per enabled provider; selecting one POSTs
 * the example to that provider's prefill endpoint in a new tab (the pure payload
 * builders live in `playground/`). SSR renders the trigger; the island hands the
 * `code` (from the sibling `<pre>`) and `options` (page payload) at hydration.
 */
declare function PlaygroundMenu({ providers, code, options }: PlaygroundMenuProps): preact.JSX.Element | null;

interface CopyPageButtonProps {
    /** URL of the page's companion markdown file (dwar's `<slug>/index.md`). */
    mdUrl: string;
    /** Site name (logo alt or package name) used in the default AI prompt. */
    siteName?: string;
    /**
     * Custom AI prompt; `{siteName}`, `{url}`, and `{mdUrl}` (the page's raw
     * Markdown link) are substituted at click time. Overrides the default. The
     * page body is never sent — the AI fetches `{mdUrl}` itself.
     */
    prompt?: string;
    /**
     * Which dropdown actions to show, in order. Omit for all; pass a subset to
     * trim the menu; pass `[]` to show just the primary "Copy page" button.
     */
    actions?: CopyPageAction[];
}
declare function CopyPageButton({ mdUrl, siteName, prompt, actions }: CopyPageButtonProps): preact.JSX.Element;

/**
 * Previous/next page pager — the box-card footer navigation common to most docs
 * sites (Docusaurus / Nextra / VitePress). dwar computes each page's neighbors
 * in sidebar reading order and hands them here; this is pure SSR markup (plain
 * anchors, no island).
 *
 * Layout: a two-column grid — the previous card aligns left, the next card
 * aligns right. When only one neighbor exists, an empty cell holds the other
 * column so a lone "Next" still sits on the right.
 */
/** One neighbor link in the pager. */
interface PageNavLink {
    /** Page slug (no leading slash); resolved against `basePath` for the href. */
    slug: string;
    /** Page title, shown as the card heading. */
    title: string;
    /** Short description (already truncated by dwar) shown under the title. */
    description?: string;
}
interface PageNavProps {
    prev?: PageNavLink;
    next?: PageNavLink;
    basePath?: string;
}
/** The prev/next pager. Renders nothing when the page has no neighbors. */
declare function PageNav({ prev, next, basePath }: PageNavProps): preact.JSX.Element | null;

type Mode = 'light' | 'dark';
type ThemeToggleProps = Record<string, never>;
/**
 * Theme mode state + toggle, factored out so multiple controls can drive the
 * same light/dark preference without duplicating the storage/apply logic — the
 * header's icon `ThemeToggle` and the mobile drawer's "Toggle theme" row both
 * use it. `current` is the resolved mode (defaults to light pre-hydration);
 * `next` is what `toggle()` switches to.
 */
declare function useThemeMode(): {
    current: Mode;
    next: Mode;
    toggle: () => void;
};
declare function ThemeToggle(_props?: ThemeToggleProps): preact.JSX.Element;

interface CtrlKProps {
    basePath: string;
    /**
     * URL of the JSON search index dwar emits (one `SearchEntry` per non-hidden
     * page). Fetched lazily on first open. When omitted, the palette opens but
     * reports an empty index.
     */
    searchIndexUrl?: string;
}

/**
 * The `cmdk` island: a command-palette search over the fetched index, with
 * persisted recent + favorite searches. Composed from small pieces — see the
 * sibling files for each section, the saved-search store (`useSavedSearches`),
 * and the reusable list keyboard navigation (`useListKeyboardNav`).
 */
declare function CtrlK({ basePath, searchIndexUrl }: CtrlKProps): preact.JSX.Element;

/** One selectable locale in the switcher. */
interface LanguageOption {
    /** Locale code, e.g. `'en'`, `'fr'`. */
    code: string;
    /** Display label for the menu row, e.g. `'English'`, `'Français'`. */
    label: string;
    /**
     * URL of THIS page in that locale. The switcher is navigation, not a runtime
     * toggle — each locale is its own statically-rendered site, so picking one is
     * a link to its URL. The cross-locale index that computes these hrefs lives in
     * aadesh (Phase 3); rang only renders the list it's handed.
     */
    href: string;
}
interface LanguageSwitcherProps {
    /** The locales this page exists in (already filtered by the cross-locale index). */
    locales: LanguageOption[];
    /** The active locale code, marked with a check and rendered non-navigable. */
    current: string;
}
/**
 * The language switcher: a dropdown of links to the current page in each
 * available locale, triggered by the lucide `Languages` icon. On desktop it
 * sits in the header controls just after the search button; on mobile it stays
 * in the bar, immediately before the nav-drawer (sidebar) trigger. Because locale is a build
 * dimension (each locale is a separate static site), this is a *navigation*
 * control — every option is an `<a href>`, never a live DOM swap.
 *
 * Renders nothing when there's only one locale (the common, no-i18n case), so
 * a default build never shows an empty switcher.
 */
declare function LanguageSwitcher({ locales, current }: LanguageSwitcherProps): preact.JSX.Element | null;

type SettingsProps = Record<string, never>;
interface SettingsDialogProps {
    open: boolean;
    onOpenChange: (open: boolean) => void;
}
/**
 * The settings dialog itself (reading-preference controls), controlled by the
 * caller. Split out from the trigger so it can be opened from anywhere — the
 * header's icon `Settings` button and the mobile drawer's "Settings" row both
 * drive this same dialog without duplicating the font-size / line-spacing logic.
 */
declare function SettingsDialog({ open, onOpenChange }: SettingsDialogProps): preact.JSX.Element;
declare function Settings(_props?: SettingsProps): preact.JSX.Element;

interface StepProps {
    /** Optional bold heading shown above the step body. */
    label?: string;
    /** The rendered MDX content of the step. */
    children?: ComponentChildren;
}
/**
 * A logical marker, never rendered on its own — `Steps` reads its props off the
 * child vnodes directly (it inspects `.type === Step` to find the real steps and
 * pulls `label`/`children` from `.props`). Returning `null` means an authoring
 * mistake (a stray `<Step>` outside a `<Steps>`) renders nothing rather than
 * leaking markup.
 */
declare function Step(_props: StepProps): null;
declare function Steps({ children }: {
    children?: ComponentChildren;
}): preact.JSX.Element | null;

interface TabProps {
    /** Tab button label; falls back to `Tab N`. */
    label?: string;
    /**
     * Sync key used by grouped tabs (see `Tabs`' `group`). When a `<Tabs group>`
     * block is switched, every other grouped block on the page (and on later
     * page loads) jumps to the tab sharing this `value`. Defaults to the
     * normalized label (lower-cased, trimmed), so identical labels sync for free.
     */
    value?: string;
    /** The rendered MDX content of the tab panel. */
    children?: ComponentChildren;
}
/**
 * A logical marker, never rendered on its own — `Tabs` reads its props off the
 * child vnodes directly (`.type === Tab` → pull `label`/`children` from
 * `.props`). Returning `null` keeps a stray `<Tab>` outside a `<Tabs>` from
 * leaking markup. Mirrors `Step`.
 */
declare function Tab(_props: TabProps): null;
declare function Tabs({ children, group }: {
    children?: ComponentChildren;
    group?: string;
}): preact.JSX.Element | null;

/**
 * The MDX element → component registry. Maps intrinsic element names that MDX
 * emits (`h1`, `pre`, `code`, `table`, …) onto their renderers:
 *   - plain tags + `makeHeading`        → ./components/mdx-tags, ./components/mdx-utils
 *   - block code (`pre`) + inline `code` → ./components/CodeBlock
 *
 * dwar passes this map to compiled MDX content; consumers can override
 * individual keys via `ComponentOverrides.mdxComponents`.
 */

declare const defaultMdxComponents: Record<string, ComponentType<any>>;

declare const ISLAND_REGISTRY: Record<IslandName, ComponentType<any>>;

interface ListKeyboardNav {
    /** The currently highlighted index. */
    active: number;
    /** Imperatively set the active index (e.g. reset on open, sync with hover). */
    setActive: (index: number) => void;
}
interface UseListKeyboardNavOptions {
    /** Only handle keys while true (e.g. while a palette/menu is open). */
    enabled: boolean;
    /** Number of navigable items; arrow keys wrap within `[0, count)`. */
    count: number;
    /** Called with the active index when Enter is pressed on a non-empty list. */
    onSelect: (index: number) => void;
}
/**
 * Roving keyboard navigation for a list/listbox: ArrowDown/ArrowUp move a
 * wrapping "active" index and Enter selects it, via a single global `keydown`
 * listener that only acts while `enabled`. Generic and dependency-free, so any
 * component with a navigable list (command palette, menu, combobox, …) can reuse
 * it. `count`, `enabled`, and `onSelect` are read through refs, so the listener
 * always sees the latest values without rebinding.
 */
declare function useListKeyboardNav({ enabled, count, onSelect, }: UseListKeyboardNavOptions): ListKeyboardNav;

/**
 * @clean-jsdoc-theme/rang
 *
 * Preact component library + MDX component map + island registry. Provides
 * the typed components that dwar bundles for SSR and hydration.
 *
 * Components are styled with Tailwind utility classes that reference CSS
 * variables (e.g. `bg-[var(--clean-bg)]`). dwar's Phase 4 work plumbs the
 * ThemeTokens values into those variables on `:root`.
 */
declare const RANG_PACKAGE_VERSION: string;

export { BasePathContext, Brand, type BrandProps, Button, ButtonGroup, type ButtonGroupProps, type ButtonProps, CodeBlock, type CodeBlockProps, type CodeTab, CodeTabs, type CodeTabsProps, CodeViewer, type CodeViewerProps, CopyBtn, type CopyBtnProps, CopyPageButton, type CopyPageButtonProps, CtrlK, type CtrlKProps, Dialog, DialogBody, DialogFooter, DialogHeader, type DialogProps, DialogTitle, DropdownMenu, DropdownMenuContent, type DropdownMenuContentProps, DropdownMenuItem, type DropdownMenuItemProps, DropdownMenuLabel, type DropdownMenuProps, DropdownMenuSeparator, DropdownMenuTrigger, type DropdownMenuTriggerProps, Footer, type FooterPkg, type FooterProps, Header, type HeaderPkg, type HeaderProps, type HeaderSlot, HeaderSlotContext, ISLAND_REGISTRY, InlineSvgContext, type LanguageOption, LanguageSwitcher, type LanguageSwitcherProps, Layout, type LayoutPkg, type LayoutProps, type ListKeyboardNav, MobileNav, type MobileNavProps, PageNav, type PageNavLink, type PageNavProps, Playground, PlaygroundContext, type PlaygroundContextValue, PlaygroundMenu, type PlaygroundMenuProps, type PlaygroundProps, RANG_PACKAGE_VERSION, Settings, SettingsDialog, type SettingsDialogProps, type SettingsProps, Sidebar, SidebarItem, type SidebarItemProps, type SidebarProps, SignatureHighlightContext, type SignatureHighlighter, SimpleIcon, type SimpleIconProps, Step, type StepProps, Steps, TOC, type TOCProps, Tab, type TabProps, Tabs, ThemeToggle, type ThemeToggleProps, TocPopover, type TocPopoverProps, type UseListKeyboardNavOptions, buttonVariants, cn, defaultMdxComponents, useListKeyboardNav, usePlayground, useThemeMode };