import * as class_variance_authority_types from 'class-variance-authority/types';
import { NavigationMenu as NavigationMenu$1 } from '@base-ui/react/navigation-menu';
import * as React from 'react';
import { LinkProps } from './link.js';
import 'class-variance-authority';

/**
 * Trigger chrome, exported as a cva so siblings (e.g. a main-nav pattern) and
 * plain links that should sit visually beside triggers can reuse or extend it —
 * the app source's `Contact` item renders an `<a>` with exactly these classes.
 *
 * The 10% ink halo marks hover/open and the 18% mix marks pressed; both are
 * backgrounds behind unchanged text, so text contrast is untouched. The
 * keyboard focus indicator is a 2px outline in the ink colour itself
 * (primary-800 on light surfaces, primary-200 in dark mode) — well above the
 * 3:1 non-text contrast minimum of WCAG 2.2 SC 1.4.11 against the white/dark
 * popover surfaces, and offset so it is never obscured (SC 2.4.7, 2.4.11).
 */
declare const navigationMenuTriggerVariants: (props?: class_variance_authority_types.ClassProp | undefined) => string;
type NavigationMenuProps = Omit<NavigationMenu$1.Root.Props, 'className'> & Pick<NavigationMenu$1.Positioner.Props, 'side' | 'sideOffset' | 'align' | 'alignOffset' | 'collisionPadding' | 'collisionAvoidance'> & {
    className?: string;
    /** Extra classes for the shared popup surface (sizing, width caps, …). */
    popupClassName?: string;
    /**
     * Inline styles for the shared popup surface. The popup normally sizes
     * itself from Base UI's `--popup-width`/`--popup-height`, which are
     * measured ONCE when a section activates — geometry that must track
     * something that can change while the menu is open (MainNav's
     * container-width panels, say) goes stale there. An inline style wins
     * over the measured vars and stays reactive to re-renders.
     */
    popupStyle?: React.CSSProperties;
};
/**
 * Top-level navigation menu — a menubar of triggers whose panels open into one
 * shared, animated popup.
 *
 * INTERNAL to MainNav — not exported from the package barrel, not a registry
 * item, no stories. It began as a public generic wrapper but was pulled from
 * the public API: bare primitive wrappers are not the nswds-ui style (the
 * design system publishes NSW-branded components, not shadcn-alikes), and
 * MainNav is the supported way to get this behaviour. The file ships inside
 * the main-nav registry item, and the module remains reachable through the
 * package's undocumented `components/navigation-menu` export subpath purely
 * as a build artefact — treat that as private API with no stability promise.
 * (The package name is deliberately not written out here: this comment ships
 * in registry content, and the alias-leak guard rejects any occurrence of the
 * package-prefixed import form.)
 *
 * Consumers only write `List > Item > (Trigger + Content)` pairs; the popup
 * plumbing Base UI requires (Portal → Positioner → Popup → Viewport, rendered
 * once at root level, into which every `Content` teleports) is composed here so
 * it cannot be assembled wrong. Positioning knobs (`side`, `sideOffset`,
 * `align`, `collisionPadding`, `collisionAvoidance`) pass through to the
 * internal Positioner.
 *
 * Accessibility is inherited from Base UI: the root renders a `<nav>` landmark
 * (pass `aria-label` when a page has more than one), triggers are real buttons
 * wired with `aria-expanded`/`aria-controls`, ArrowDown/Enter open from the
 * keyboard, arrow keys move along the list, and Escape or focus-out closes
 * (WAI-ARIA disclosure navigation pattern). Do not add ARIA by hand.
 *
 * Departure from the nswds-app source: that wrapper was Radix-based with an
 * optional inline viewport (`viewport` prop); Base UI's model has exactly one
 * viewport, so the prop is gone. Radix's `delayDuration`/`skipDelayDuration`
 * map to Base UI's `delay`/`closeDelay` (both default 50ms).
 */
declare function NavigationMenu({ className, children, side, sideOffset, align, alignOffset, collisionPadding, collisionAvoidance, popupClassName, popupStyle, ...props }: NavigationMenuProps): React.JSX.Element;
type NavigationMenuListProps = Omit<NavigationMenu$1.List.Props, 'className'> & {
    className?: string;
};
/**
 * The menubar row of triggers. Base UI renders a `<ul>` and manages roving
 * arrow-key focus between the items.
 *
 * Carries the app source's bottom hairline (tokenised from raw grey utilities
 * to the semantic `border-border`, which already flips for dark mode) and its
 * hidden-scrollbar overflow so a long menu can pan on narrow screens.
 *
 * `overflow-x-auto` is what makes that panning real. The scrollbar-HIDING
 * declarations beside it (`[scrollbar-width:none]`, the `::-webkit-scrollbar`
 * rule) are inert on their own: an `overflow: visible` box has no scrollbar to
 * hide, so without this the row simply overflowed its container and pushed a
 * horizontal scrollbar onto the page. `whitespace-nowrap` plus the `shrink-0`
 * items MainNav renders means a bar with more entries than fit is the normal
 * case on a phone, not an edge case.
 *
 * Two consequences of becoming a scroll container, both handled at the call
 * site rather than here:
 *
 * - Per CSS overflow, a non-visible `overflow-x` forces `overflow-y` to
 *   compute to `auto`, so anything drawn OUTSIDE a row item's border box is
 *   clipped. Items inside the list therefore use inset focus rings
 *   (`-outline-offset-*`) — see `mainNavTriggerClassName` /
 *   `mainNavTopLinkClassName`. Links inside a `NavigationMenuContent` panel
 *   are portalled out of this box and keep the house outward-offset ring.
 * - `justify-center` (the default below) makes the leading overflow
 *   unreachable in a scroll container — the well-known centred-flex overflow
 *   trap. MainNav overrides it with `justify-start`; any future consumer that
 *   keeps the centred default must not also rely on scrolling.
 */
declare function NavigationMenuList({ className, ...props }: NavigationMenuListProps): React.JSX.Element;
type NavigationMenuItemProps = Omit<NavigationMenu$1.Item.Props, 'className'> & {
    className?: string;
};
/**
 * One menubar entry (`<li>`), pairing a `NavigationMenuTrigger` with its
 * `NavigationMenuContent` — or holding a bare `NavigationMenuLink` for items
 * with no panel. Pass `value` when controlling the open item programmatically.
 */
declare function NavigationMenuItem({ className, ...props }: NavigationMenuItemProps): React.JSX.Element;
type NavigationMenuTriggerProps = Omit<NavigationMenu$1.Trigger.Props, 'className'> & {
    className?: string;
};
/**
 * Opens the item's panel. Renders a real `<button>` (never an anchor — the
 * trigger discloses content, it doesn't navigate), which Base UI wires with
 * `aria-expanded`/`aria-controls` and hover/click/keyboard open behaviour.
 *
 * The trailing chevron rides Base UI's Icon part, which mirrors the trigger's
 * `data-popup-open` attribute — the 180° flip is pure CSS off that attribute
 * (no JS state), and is suppressed for reduced-motion users (WCAG 2.3.3).
 * The chevron is decorative, so the Icon part is `aria-hidden`: it never
 * enters the button's accessible name, and the open state it hints at is
 * already conveyed programmatically via `aria-expanded` (SC 4.1.2).
 */
declare function NavigationMenuTrigger({ className, children, ...props }: NavigationMenuTriggerProps): React.JSX.Element;
type NavigationMenuContentProps = Omit<NavigationMenu$1.Content.Props, 'className'> & {
    className?: string;
};
/**
 * The panel for one item. Authored inline next to its Trigger, but rendered
 * (teleported by Base UI) into the shared root-level Viewport while active —
 * so panel-to-panel switches cross-fade inside one popup surface.
 *
 * The directional slide keys off `data-activation-direction` (which adjacent
 * trigger the user came from), matching the app source's from-start/from-end
 * motion. Set `keepMounted` to keep the panel in the DOM for SSR crawlers.
 */
declare function NavigationMenuContent({ className, children, ...props }: NavigationMenuContentProps): React.JSX.Element;
type NavigationMenuLinkProps = Omit<NavigationMenu$1.Link.Props, 'className' | 'render' | 'href'> & {
    className?: string;
    /**
     * Link target. Accepts the same string-or-UrlObject union as `Link`, since
     * the rendered element may be a framework link injected via `LinkProvider`.
     */
    href: LinkProps['href'];
};
/**
 * A navigation link inside (or beside) the menu. Composes the design system's
 * `Link` through Base UI's `render` prop: Base UI keeps the behaviour —
 * roving focus, focus-out closing, `aria-current='page'` when `active`, close
 * on click — while `Link` supplies the element, so a `LinkProvider` framework
 * component (e.g. next/link) is injected automatically. `Link` renders with
 * `variant='unstyled'`; this component owns the visual treatment (same ink
 * halo/outline contract as the trigger — see `navigationMenuTriggerVariants`).
 *
 * Departure from Base UI's default: `closeOnClick` defaults to **true** here.
 * In an SPA a client-side navigation doesn't reload the document, so a menu
 * that stays open after choosing a destination reads as broken; pass
 * `closeOnClick={false}` for in-page links that should keep the panel open.
 *
 * Set `active` for the current page (the app source's `usePathname` check is
 * a framework API this package must not import — compare in the consumer and
 * pass the result down): it sets `aria-current='page'` (WCAG 2.4.8 support)
 * and the persistent halo via `data-active`.
 */
declare function NavigationMenuLink({ className, href, closeOnClick, ...props }: NavigationMenuLinkProps): React.JSX.Element;

export { NavigationMenu, NavigationMenuContent, type NavigationMenuContentProps, NavigationMenuItem, type NavigationMenuItemProps, NavigationMenuLink, type NavigationMenuLinkProps, NavigationMenuList, type NavigationMenuListProps, type NavigationMenuProps, NavigationMenuTrigger, type NavigationMenuTriggerProps, navigationMenuTriggerVariants };