import * as react from 'react';
import { ReactNode } from 'react';

/**
 * D-pad focus navigation for the Meta Ray-Ban Display.
 *
 * The Display has no touch and no pointer. The Neural Band wristband
 * is the only input — its swipes/clicks reach the Web App as arrow
 * keys + Enter. So navigation is: move a focus ring between elements
 * with the arrows, activate with Enter.
 *
 * Convention: give any interactive element the `focusable` class.
 * `useDpad()` (call once near the app root) does the rest — spatial
 * navigation picks the nearest `focusable` in the pressed direction.
 *
 * Locally, your keyboard's arrow keys simulate the wristband.
 */
type Dir = "up" | "down" | "left" | "right";
type RectLike = {
    left: number;
    top: number;
    width: number;
    height: number;
};
/**
 * Score a candidate's position relative to the current rect in a
 * direction. Returns null if the candidate is not in `dir` at all,
 * otherwise a positive number where lower wins. Pure — no DOM. The
 * extraction makes the spatial-focus algorithm directly unit-testable.
 */
declare function scoreRect(current: RectLike, candidate: RectLike, dir: Dir): number | null;
/**
 * The current D-pad candidates, in DOM order — honors the innermost
 * <FocusScope> and skips disabled/invisible elements. Exposed so navigation
 * containers can implement focus memory (record the focused index on push,
 * restore it on pop).
 */
declare function getFocusables(): HTMLElement[];
/**
 * Move focus to the screen's preferred element: the first focusable carrying
 * `data-autofocus`, else the first focusable in DOM order. Exposed so a
 * screen that swaps its content under a single `useDpad()` (no remount) can
 * re-seed focus when its focusable set changes — `useDpad` itself only seeds
 * once on mount. Uses the same `SELECTOR`, so it skips disabled elements.
 */
declare function seedFocus(): void;
/**
 * <FocusScope> — contain the D-pad ring to a subtree while mounted (modal
 * surfaces: Confirm, PermissionPrompt, sheets). On mount it seeds focus
 * inside; arrows and Enter only see focusables within the innermost mounted
 * scope; on unmount focus returns to the element that had it before the
 * scope opened (or reseeds if that element is gone). Renders a
 * `display: contents` wrapper, so it never affects layout.
 */
declare function FocusScope({ children, restoreFocus, }: {
    children: ReactNode;
    /** Return focus to the previously focused element on unmount. */
    restoreFocus?: boolean;
}): react.JSX.Element;
/**
 * Wire the D-pad to focus navigation. Call once, near the app root.
 * Returns `{ seedFocus }` for screens that need to re-seed focus after
 * swapping content within the same mount.
 */
declare function useDpad(): {
    seedFocus: () => void;
};
/**
 * Read the D-pad cursor in React. Returns the `data-key` of the currently
 * focused `.focusable` element (or null), and re-renders as the cursor moves.
 *
 * The cursor is real DOM focus, so this is the SINGLE source of truth. Use it
 * to render decorations keyed off the focused item — a preview, a label, the
 * legal-move dots for the focused board square — WITHOUT inventing a second
 * "selected index" state that can drift out of sync with focus and paint a
 * competing highlight. There is exactly one cursor (the focused element); this
 * just lets you render against it.
 *
 * Give each focusable a stable `data-key`:
 *   `<button className="focusable" data-key={id} …>`
 */
declare function useFocusedKey(): string | null;

/**
 * Device sensor hooks for the Meta Ray-Ban Display.
 *
 * The Display's Web Apps platform exposes standard W3C sensor APIs —
 * no proprietary SDK. These hooks wrap them with a React-friendly
 * shape. In the browser you can drive them with Chrome DevTools'
 * Sensors panel (orientation, location) for local development.
 *
 * Note: `deviceorientation` and `devicemotion` fire ~60Hz, so each
 * hook guards setState — it only re-renders when a value actually
 * changes. Critical on the Display's tight perf budget.
 */
type Orientation = {
    alpha: number | null;
    beta: number | null;
    gamma: number | null;
};
type Motion = {
    x: number | null;
    y: number | null;
    z: number | null;
};
/** Exported for testing — the per-render no-op guard for orientation. */
declare function orientationEqual(a: Orientation, b: Orientation): boolean;
/** Exported for testing — the per-render no-op guard for motion. */
declare function motionEqual(a: Motion, b: Motion): boolean;
/** Head orientation — compass heading + tilt, in degrees. */
declare function useDeviceOrientation(): Orientation;
/** Motion — acceleration (incl. gravity) on each axis, in m/s². */
declare function useDeviceMotion(): Motion;
/** Live GPS — watches the phone's location. */
declare function useGeolocation(): {
    position: {
        lat: number;
        lon: number;
        accuracy: number;
    } | null;
    error: string | null;
};
/**
 * Neural Band gestures — the wristband's pinch / swipe events.
 *
 * Core gestures already arrive as D-pad arrow keys + Enter (see
 * dpad.tsx). This hook is the seam for the *richer* gestures (pinch,
 * double-pinch, swipe) — it listens for a `neuralband` CustomEvent.
 *
 * It's a **one-shot**: the gesture string is exposed for one render,
 * then cleared on the next microtask. That way `useEffect(...,
 * [gesture])` re-fires for every event, even two consecutive
 * identical pinches.
 *
 * Simulate in dev:
 *   window.dispatchEvent(
 *     new CustomEvent("neuralband", { detail: { gesture: "pinch" } }),
 *   );
 */
declare function useNeuralBand(): string | null;

/**
 * Haptic feedback seam for the Meta Ray-Ban Display.
 *
 * The Neural Band can buzz — the OS does it for system gestures — but no
 * haptics API reaches web apps yet (see the platform wishlist). This is the
 * forward-compat seam, shaped like `useNeuralBand`'s event channel:
 *
 *   - dispatches a `glasskitfeedback` CustomEvent so a future OS bridge (or
 *     your test harness) can deliver the buzz, and
 *   - calls `navigator.vibrate` where the UA supports it (desktop/Android
 *     dev — the Display webview currently ignores it),
 *   - no-ops gracefully everywhere else, SSR included.
 *
 * Call it at interaction points (`buzz("tap")` on activate, `"success"` on a
 * completed flow) and the day haptics ship, every call site lights up.
 */
type FeedbackPattern = "tap" | "success" | "warning";
/** Fire a haptic cue. Safe to call anywhere — no-ops without a platform. */
declare function buzz(pattern?: FeedbackPattern): void;
/**
 * Hook form of `buzz` — returns a stable `{ buzz }` for component code.
 * (A plain function today; a hook so future platform wiring — capability
 * detection, user settings — needs no call-site changes.)
 */
declare function useFeedback(): {
    buzz: typeof buzz;
};

/**
 * Glasses navigation as a HOOK, not a component — the routing logic is a
 * primitive (like react-router's `useNavigate`), and you render your own
 * screens. The Meta Ray-Ban Display's system back gesture (middle pinch) pops
 * browser history and the page receives `popstate`, so every `push()` adds a
 * real history entry and back — the gesture, Escape in desktop dev, or `pop()`
 * — flows through one path: history → popstate → stack. At the root, back falls
 * through to the system (app switcher / menu), exactly like Android's back
 * contract.
 *
 * Call {@link useNavigator} ONCE near the app root, render the current screen
 * yourself from `screen` + `params`, and pass `push`/`pop` down (or via your own
 * context). Overlays/sheets intercept back with {@link useBackHandler}.
 *
 * The stack rides in `history.state`, so a mid-flow reload restores the screen
 * the wearer was on instead of dropping them at the root.
 *
 * @example
 * function App() {
 *   const nav = useNavigator("home");
 *   if (nav.screen === "detail") return <Detail id={nav.params} onBack={nav.pop} />;
 *   return <Home onOpen={(id) => nav.push("detail", id)} />;
 * }
 */
type NavEntry = {
    name: string;
    params?: unknown;
    key: number;
};
type Navigator = {
    /** The current (top) screen name — render this one. */
    screen: string;
    /** Params passed to the current screen via `push`/`replace`. */
    params: unknown;
    /** The full stack, root first. */
    stack: readonly NavEntry[];
    /** Push a screen (adds a history entry; system back returns here). */
    push: (name: string, params?: unknown) => void;
    /** Pop one screen (no-op at the root). */
    pop: () => void;
    /** Pop everything back to the root screen. */
    popToTop: () => void;
    /** Swap the top screen without growing the stack. */
    replace: (name: string, params?: unknown) => void;
};
declare function useNavigator(initial: string, initialParams?: unknown): Navigator;
/**
 * Intercept the back gesture while mounted (overlays, sheets, confirm guards).
 * Return `true` to consume back (e.g. close the sheet), `false` to let it pop
 * the screen. Handlers run newest-first.
 */
declare function useBackHandler(handler: () => boolean): void;

export { type Dir, type FeedbackPattern, FocusScope, type NavEntry, type Navigator, buzz, getFocusables, motionEqual, orientationEqual, scoreRect, seedFocus, useBackHandler, useDeviceMotion, useDeviceOrientation, useDpad, useFeedback, useFocusedKey, useGeolocation, useNavigator, useNeuralBand };