vue-micro-router 1.0.1

package/dist/index.d.ts

@@ -0,0 +1,887 @@
+import { AsyncComponentLoader } from 'vue';
+import { Component } from 'vue';
+import { ComponentOptionsMixin } from 'vue';
+import { ComponentProvideOptions } from 'vue';
+import { ComputedOptions } from 'vue';
+import { ComputedRef } from 'vue';
+import { CreateComponentPublicInstanceWithMixins } from 'vue';
+import { DefineComponent } from 'vue';
+import { GlobalComponents } from 'vue';
+import { GlobalDirectives } from 'vue';
+import { InjectionKey } from 'vue';
+import { MethodOptions } from 'vue';
+import { PublicProps } from 'vue';
+import { Ref } from 'vue';
+import { TransitionGroupProps } from 'vue';
+
+declare const __VLS_component: DefineComponent<Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
+pageContainerRef: CreateComponentPublicInstanceWithMixins<Readonly<TransitionGroupProps>, {}, {}, ComputedOptions, MethodOptions, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+P: {};
+B: {};
+D: {};
+C: {};
+M: {};
+Defaults: {};
+}, Readonly<TransitionGroupProps>, {}, {}, ComputedOptions, MethodOptions, {}> | null;
+}, any>;
+
+declare const __VLS_component_2: DefineComponent<Props_2, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<Props_2> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+declare const __VLS_component_3: DefineComponent<Props_3, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+close: (path: string) => any;
+}, string, PublicProps, Readonly<Props_3> & Readonly<{
+onClose?: ((path: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
+dialogRef: HTMLDialogElement;
+}, any>;
+
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        pageContainerRef: CreateComponentPublicInstanceWithMixins<Readonly<TransitionGroupProps>, {}, {}, ComputedOptions, MethodOptions, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+        }, Readonly<TransitionGroupProps>, {}, {}, ComputedOptions, MethodOptions, {}> | null;
+    };
+    rootEl: any;
+};
+
+declare function __VLS_template_2(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_3(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        dialogRef: HTMLDialogElement;
+    };
+    rootEl: any;
+};
+
+declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+
+declare type __VLS_TemplateResult_2 = ReturnType<typeof __VLS_template_2>;
+
+declare type __VLS_TemplateResult_3 = ReturnType<typeof __VLS_template_3>;
+
+declare type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_2<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_3<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+/** Join segments into path: ["home", "missions"] → "/home/missions" */
+export declare function buildPathFromSegments(segments: string[]): string;
+
+/**
+ * Per-control attrs — augment from each control component.
+ * Keys = control name strings, values = attrs type for that control.
+ */
+export declare interface ControlAttrsMap {
+}
+
+export declare interface ControlLifecycleHooks {
+    /** Called when this control becomes the active control */
+    onControlEnter?: () => void;
+    /** Called when this control is deactivated */
+    onControlLeave?: () => void;
+}
+
+declare interface ControlManagerConfig {
+    defaultControlName: string;
+    onboardingControlName?: string;
+}
+
+export declare interface ControlManagerState {
+    resolveControls: ComputedRef<MicroControl[]>;
+    activeControl: ComputedRef<boolean>;
+    currentControl: ComputedRef<string>;
+    toggleControl: (name: string, active: boolean, attrs?: Record<string, unknown>) => void;
+    registerControl: (control: MicroControl) => void;
+    registerControls: (controls: MicroControl[]) => void;
+    getControlAttrs: (name: string) => Record<string, unknown> | undefined;
+    updateControlAttrs: (name: string, attrs: Record<string, unknown>) => void;
+    cleanup: () => void;
+}
+
+/** Factory to create unique injection keys for nested routers */
+export declare function createRouterKey(): InjectionKey<MicroRouterStore>;
+
+/**
+ * Define a feature plugin — a bundle of routes, dialogs, and controls.
+ *
+ * @example
+ * ```ts
+ * export const inventoryPlugin = defineFeaturePlugin({
+ *   name: 'inventory',
+ *   routes: [{ path: 'inventory', component: () => import('./InventoryPage.vue') }],
+ *   dialogs: [{ path: 'item-detail', component: ItemDetail, activated: false }],
+ *   controls: [{ name: 'inventory_gui', component: InventoryHUD, activated: false }],
+ * });
+ * ```
+ */
+/**
+ * Generic overload preserves literal path/name types when `as const` is used.
+ * Without `as const`, falls back to loose FeaturePlugin type (backward compatible).
+ */
+export declare function defineFeaturePlugin<const T extends FeaturePluginConfig>(config: T): T;
+
+export declare function defineFeaturePlugin(config: FeaturePluginConfig): FeaturePlugin;
+
+/**
+ * Per-dialog attrs — augment from each dialog component.
+ * Keys = dialog path strings, values = attrs type for that dialog.
+ */
+export declare interface DialogAttrsMap {
+}
+
+export declare interface DialogInstance {
+    path: string;
+    attrs?: Record<string, unknown>;
+}
+
+export declare interface DialogLifecycleHooks {
+    /** Called when this dialog becomes the active (topmost) dialog */
+    onDialogEnter?: () => void;
+    /** Called when this dialog is no longer the active dialog (another opened on top, or this one closed) */
+    onDialogLeave?: () => void;
+}
+
+export declare interface DialogManagerState {
+    activeDialog: ComputedRef<string>;
+    fromDialog: ComputedRef<string>;
+    toDialog: ComputedRef<string>;
+    resolveDialogs: ComputedRef<MicroDialog[]>;
+    openDialog: (path: string, props?: Record<string, unknown>) => DialogInstance;
+    closeDialog: (path: string) => void;
+    closeAllDialogs: () => void;
+    registerDialog: (dialog: MicroDialog) => void;
+    registerDialogs: (dialogs: MicroDialog[]) => void;
+    getDialogAttrs: (path: string) => Record<string, unknown> | undefined;
+    updateDialogAttrs: (path: string, attrs: Record<string, unknown>) => void;
+    cleanup: () => void;
+}
+
+export declare type DialogPosition = 'standard' | 'top' | 'right' | 'bottom' | 'left';
+
+export declare interface DialogProps {
+    path: string;
+    open?: boolean;
+    attrs?: Record<string, unknown>;
+}
+
+/** Extract control name literals from a plugin config type */
+export declare type ExtractControlNames<T> = T extends {
+    controls: readonly (infer C)[];
+} ? C extends {
+    name: infer N;
+} ? N & string : never : never;
+
+/** Extract dialog path literals from a plugin config type */
+export declare type ExtractDialogPaths<T> = T extends {
+    dialogs: readonly (infer D)[];
+} ? D extends {
+    path: infer P;
+} ? P & string : never : never;
+
+/** Extract route path literals from a plugin config type */
+export declare type ExtractRoutePaths<T> = T extends {
+    routes: readonly (infer R)[];
+} ? R extends {
+    path: infer P;
+} ? P & string : never : never;
+
+export declare type FeaturePlugin = FeaturePluginConfig;
+
+/**
+ * Bundle of routes, dialogs, and controls to register as a single feature.
+ *
+ * @example
+ * ```ts
+ * const shopPlugin = defineFeaturePlugin({
+ *   name: 'shop',
+ *   routes: [{ path: 'shop', component: ShopPage }],
+ *   dialogs: [{ path: 'buy-confirm', component: BuyDialog, activated: false }],
+ * });
+ * ```
+ */
+export declare interface FeaturePluginConfig {
+    name: string;
+    routes?: MicroRoute[];
+    dialogs?: MicroDialog[];
+    controls?: MicroControl[];
+}
+
+export declare interface GestureConfig {
+    /** Enable gesture navigation. Default: false */
+    enabled?: boolean;
+    /** Pixels from left edge that starts gesture. Default: 20 */
+    edgeWidth?: number;
+    /** Percentage (0-1) to trigger navigation. Default: 0.3 */
+    threshold?: number;
+    /** px/ms — fast swipe always triggers. Default: 0.5 */
+    velocityThreshold?: number;
+}
+
+declare interface GestureContext {
+    /** The DOM element or Vue component instance ref to attach gesture listeners to */
+    containerRef: Ref<HTMLElement | Record<string, unknown> | null>;
+    /** Go back one step — respects guards */
+    goBack: () => Promise<void>;
+    /** Check if there's a page to go back to */
+    canGoBack: () => boolean;
+}
+
+/** Get last segment from path: "/home/missions/detail" → "detail" */
+export declare function getLastSegment(path: string): string;
+
+declare interface GuardConfig {
+    beforeEach?: NavigationGuard[];
+    afterEach?: NavigationAfterHook[];
+    guardTimeout?: number;
+}
+
+/** True if user has augmented Register with a plugin */
+declare type HasRegisteredPlugin = [RegisteredPlugin] extends [never] ? false : true;
+
+/** True if user has augmented Register with a route map */
+declare type HasRegisteredRouteMap = [RegisteredRouteMap] extends [never] ? false : true;
+
+/**
+ * Check if a value is an async component loader (arrow fn returning import()),
+ * not a Vue component object or functional component.
+ */
+export declare function isAsyncLoader(component: AsyncComponentLoader | Component): component is AsyncComponentLoader;
+
+/** Inject/provide key for reading attrs — consumed by useMicroState to read parent-injected props */
+export declare const MICRO_ATTRS_READ_KEY: InjectionKey<() => Record<string, unknown> | undefined>;
+
+/** Inject/provide key for writing attrs — consumed by useMicroState to sync mutations back to store */
+export declare const MICRO_ATTRS_WRITE_KEY: InjectionKey<(attrs: Record<string, unknown>) => void>;
+
+/** Inject/provide key for the current control name — injected per MicroControlWrapper for useControlLifecycle */
+export declare const MICRO_CONTROL_NAME_KEY: InjectionKey<string>;
+
+/** Inject/provide key for the current dialog path — injected per MicroDialog for useDialogLifecycle */
+export declare const MICRO_DIALOG_PATH_KEY: InjectionKey<string>;
+
+/** Inject/provide key for the current route path — injected per RoutePage slot for useRouteLifecycle */
+export declare const MICRO_ROUTE_PATH_KEY: InjectionKey<string>;
+
+/** Default inject/provide key for the MicroRouterStore — used by useGlobalMicroRouter / useMicroRouter */
+export declare const MICRO_ROUTER_KEY: InjectionKey<MicroRouterStore>;
+
+/** Inject/provide key for the ROOT router — always points to the outermost MicroRouterView */
+export declare const MICRO_ROUTER_ROOT_KEY: InjectionKey<MicroRouterStore>;
+
+export declare interface MicroControl {
+    /** Unique control name, e.g. "main_gui", "inventory" */
+    name: string;
+    /** Whether the control overlay is currently visible */
+    activated: boolean;
+    /** Vue component or async loader */
+    component: AsyncComponentLoader | Component;
+    /** Props passed to the component */
+    attrs?: Record<string, unknown>;
+    /** Internal: incremented on each activation to force component remount */
+    componentKey?: number;
+}
+
+export declare const MicroControlWrapper: DefineComponent<Props_4, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<Props_4> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface MicroDialog {
+    /** Unique dialog identifier, e.g. "confirm", "settings-modal" */
+    path: string;
+    /** Vue component or async loader */
+    component: AsyncComponentLoader | Component;
+    /** Whether the dialog is currently visible */
+    activated: boolean;
+    /** True during exit animation — keeps dialog in DOM until animation completes */
+    closing?: boolean;
+    /** Render dialog at full viewport size */
+    fullscreen?: boolean;
+    /** If true, clicking backdrop or pressing Escape won't close the dialog */
+    persistent?: boolean;
+    /** Props passed to the component, includes injected onClose callback */
+    attrs?: Record<string, unknown>;
+    /** Where the dialog appears: 'standard' (center), 'top', 'right', 'bottom', 'left' */
+    position?: DialogPosition;
+    /** Custom transition duration in ms. Defaults: slide=500ms, fade/scale=300ms */
+    transitionDuration?: number;
+    /** Animation type: 'fade' (scale+fade), 'scale' (pop), 'slide' (page-style) */
+    transition?: TransitionType;
+    /** If true (default), dialog has transparent background and no shadow */
+    seamless?: boolean;
+    /** Internal: incremented on each open to force component remount */
+    componentKey?: number;
+}
+
+export declare const MicroDialogComponent: __VLS_WithTemplateSlots_3<typeof __VLS_component_3, __VLS_TemplateResult_3["slots"]>;
+
+export declare interface MicroRoute {
+    /** Unique segment name, e.g. "home", "settings" — used in path like "home/settings" */
+    path: string;
+    /** Vue component or async loader (() => import('./MyPage.vue')) */
+    component: AsyncComponentLoader | Component;
+    /** Props passed to the component via useMicroState */
+    attrs?: Record<string, unknown>;
+    /** Background music track name — resolved by audio manager's urlResolver */
+    bgm?: string;
+    /** Preloading strategy: 'eager' (on mount), 'adjacent' (after each nav), false (default) */
+    preload?: 'eager' | 'adjacent' | false;
+    /** Page transition type: 'slide' (default), 'fade', or 'none' to disable */
+    transition?: TransitionType | 'none';
+    /** Custom transition duration in ms. Defaults: slide=500ms, fade=300ms */
+    transitionDuration?: number;
+    /** Guard called before navigating TO this route. Return false to cancel. */
+    beforeEnter?: NavigationGuard;
+    /** Guard called before navigating AWAY from this route. Return false to cancel. */
+    beforeLeave?: NavigationGuard;
+    /** Internal: cache key for transition identity */
+    key?: string;
+    /** Internal: incremented to force full component remount */
+    componentKey?: number;
+}
+
+export declare interface MicroRouterConfig {
+    /** Initial page path on mount — must match a registered route segment */
+    defaultPath: string;
+    /** Delay between step-wise navigation transitions in ms. Defaults to 600 */
+    stepDelay?: number;
+    /** Name of the default GUI control — auto-activated on mount, auto-restored on deactivate */
+    defaultControlName: string;
+    /** Name of the onboarding control (exempt from auto-restore). Optional — only needed for onboarding flows. */
+    onboardingControlName?: string;
+    /** Navigation history tracking — opt-in, records sequence of paths visited */
+    history?: {
+        enabled?: boolean;
+        /** Max entries before FIFO eviction. Default: 50 */
+        maxEntries?: number;
+    };
+    /** Swipe-back gesture navigation config (opt-in) */
+    gesture?: {
+        enabled?: boolean;
+        edgeWidth?: number;
+        threshold?: number;
+        velocityThreshold?: number;
+    };
+    /** Navigation guard hooks — beforeEach runs before every navigation, afterEach runs after */
+    guards?: {
+        beforeEach?: NavigationGuard[];
+        afterEach?: NavigationAfterHook[];
+    };
+    /** Analytics hooks for page/dialog/control enter/leave events */
+    tracker?: PageTrackerHooks;
+    /** Reactive volume ref (0-100) for audio manager. Only used with vue-micro-router/audio */
+    volumeRef?: Ref<number>;
+}
+
+/**
+ * Main store interface — injected by useMicroRouter(), provided by useGlobalMicroRouter().
+ * Contains all navigation, dialog, control, and optional audio APIs.
+ */
+export declare interface MicroRouterStore {
+    /** Current full path, e.g. "/home/menu/settings" */
+    activePath: ComputedRef<string>;
+    fromPath: ComputedRef<string>;
+    toPath: ComputedRef<string>;
+    activePage: ComputedRef<string>;
+    fromPage: ComputedRef<string>;
+    toPage: ComputedRef<string>;
+    resolveRoutes: ComputedRef<MicroRoute[]>;
+    /**
+     * Navigate to a destination. Guarded against rapid double-clicks.
+     * @param destination - Relative segment ("menu"), absolute path ("/home/menu"), or negative number (-1 = back)
+     * @param props - Optional attrs to pass to the target page via useMicroState
+     */
+    push: (destination: string | number, props?: Record<string, unknown>) => Promise<void>;
+    /** Navigate through intermediate pages one-by-one with stepDelay between each */
+    stepWisePush: (targetPath: string, props?: Record<string, unknown>) => Promise<void>;
+    /** Go back N steps, animating through each intermediate page */
+    stepWiseBack: (steps: number) => Promise<void>;
+    registerRoute: (route: MicroRoute) => void;
+    registerRoutes: (routes: MicroRoute[]) => void;
+    updateRouteAttrs: (segment: string, attrs: Record<string, unknown>) => void;
+    getRouteAttrs: (segment: string) => Record<string, unknown> | undefined;
+    /** Manually preload an async route component by segment name */
+    preloadRoute: (segment: string) => Promise<void>;
+    /** Path of the topmost open dialog, or "" if none */
+    activeDialog: ComputedRef<string>;
+    fromDialog: ComputedRef<string>;
+    toDialog: ComputedRef<string>;
+    resolveDialogs: ComputedRef<MicroDialog[]>;
+    /** Open a dialog by path. Returns a DialogInstance handle. Props available via useMicroState inside the dialog. */
+    openDialog: (path: string, props?: Record<string, unknown>) => DialogInstance;
+    /** Close a specific dialog by path. Triggers exit animation. */
+    closeDialog: (path: string) => void;
+    /** Close all open dialogs at once. Invokes onClose callbacks after DOM updates. */
+    closeAllDialogs: () => void;
+    registerDialog: (dialog: MicroDialog) => void;
+    registerDialogs: (dialogs: MicroDialog[]) => void;
+    getDialogAttrs: (path: string) => Record<string, unknown> | undefined;
+    updateDialogAttrs: (path: string, attrs: Record<string, unknown>) => void;
+    /** All currently activated controls */
+    resolveControls: ComputedRef<MicroControl[]>;
+    activeControl: ComputedRef<boolean>;
+    currentControl: ComputedRef<string>;
+    /**
+     * Activate or deactivate a GUI control by name.
+     * Activating a non-default control auto-hides the default GUI.
+     * Deactivating a non-default control auto-restores the default GUI.
+     */
+    toggleControl: (name: string, active: boolean, attrs?: Record<string, unknown>) => void;
+    registerControl: (control: MicroControl) => void;
+    registerControls: (controls: MicroControl[]) => void;
+    getControlAttrs: (name: string) => Record<string, unknown> | undefined;
+    updateControlAttrs: (name: string, attrs: Record<string, unknown>) => void;
+    /** Whether there's a previous entry to go back to */
+    canGoBack?: ComputedRef<boolean>;
+    /** Whether there's a forward entry (after going back) */
+    canGoForward?: ComputedRef<boolean>;
+    /** Navigate to previous history entry */
+    historyBack?: () => Promise<void>;
+    /** Navigate to next history entry */
+    historyForward?: () => Promise<void>;
+    /** Navigate by delta in history */
+    historyGo?: (delta: number) => Promise<void>;
+    /** Serialize current router state to a JSON-safe object */
+    serialize?: () => SerializedState;
+    /** Restore router state from a serialized snapshot */
+    restore?: (state: SerializedState) => Promise<void>;
+    playSound?: (soundSrc: string, loop?: boolean) => Promise<void>;
+    stopSound?: () => void;
+    updateBackgroundMusic?: (route: string) => Promise<void>;
+}
+
+export declare const MicroRouterView: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+
+/**
+ * Hook called after navigation completes. Cannot cancel — purely observational.
+ */
+export declare type NavigationAfterHook = (to: string, from: string) => void;
+
+declare interface NavigationConfig {
+    defaultPath: string;
+    stepDelay?: number;
+    guards?: GuardConfig;
+    history?: NavigationHistoryConfig;
+}
+
+/**
+ * Guard called before navigation. Return false (or resolve to false) to cancel.
+ * @param to - target path
+ * @param from - current path
+ */
+export declare type NavigationGuard = (to: string, from: string) => boolean | Promise<boolean>;
+
+declare interface NavigationHistory {
+    entries: ComputedRef<NavigationHistoryEntry_2[]>;
+    canGoBack: ComputedRef<boolean>;
+    canGoForward: ComputedRef<boolean>;
+    /** Navigate to the previous history entry */
+    back: () => Promise<void>;
+    /** Navigate to the next history entry (after going back) */
+    forward: () => Promise<void>;
+    /** Navigate by delta: negative = back, positive = forward */
+    go: (delta: number) => Promise<void>;
+    /** Clear all history entries */
+    clear: () => void;
+    /** Record a navigation event — called internally after successful push */
+    record: (path: string, props?: Record<string, unknown>) => void;
+}
+
+declare interface NavigationHistoryConfig {
+    enabled?: boolean;
+    maxEntries?: number;
+}
+
+declare interface NavigationHistoryEntry_2 {
+    path: string;
+    timestamp: number;
+    props?: Record<string, unknown>;
+}
+
+export declare interface NavigationState {
+    activePath: ComputedRef<string>;
+    fromPath: ComputedRef<string>;
+    toPath: ComputedRef<string>;
+    activePage: ComputedRef<string>;
+    fromPage: ComputedRef<string>;
+    toPage: ComputedRef<string>;
+    resolveRoutes: ComputedRef<MicroRoute[]>;
+    push: (destination: string | number, props?: Record<string, unknown>) => Promise<void>;
+    stepWisePush: (targetPath: string, props?: Record<string, unknown>) => Promise<void>;
+    stepWiseBack: (steps: number) => Promise<void>;
+    registerRoute: (route: MicroRoute) => void;
+    registerRoutes: (routes: MicroRoute[]) => void;
+    updateRouteAttrs: (segment: string, attrs: Record<string, unknown>) => void;
+    getRouteAttrs: (segment: string) => Record<string, unknown> | undefined;
+    /** Manually preload an async route component */
+    preloadRoute: (segment: string) => Promise<void>;
+    /** Navigation history (only populated when config.history.enabled) */
+    history?: NavigationHistory;
+    cleanup: () => void;
+}
+
+/** Ensure path starts with / */
+export declare function normalizePath(path: string): string;
+
+export declare interface PageTrackerHooks {
+    trackPageEnter?: (page: string, from?: string, to?: string) => void;
+    trackPageLeave?: (page: string, from?: string, to?: string) => void;
+    trackDialogEnter?: (dialog: string, from?: string, to?: string) => void;
+    trackDialogLeave?: (dialog: string, from?: string, to?: string) => void;
+    trackGuiEnter?: (name: string) => void;
+    trackGuiLeave?: (name: string) => void;
+    cleanupAllSessions?: () => void;
+}
+
+/** Split path into segments: "/home/missions/detail" → ["home", "missions", "detail"] */
+export declare function parsePathSegments(path: string): string[];
+
+export declare interface PluginTypedCloseDialog<Dialogs extends string> {
+    (path: Dialogs): void;
+}
+
+/**
+ * Typed store from plugin(s) — push/openDialog/closeDialog/toggleControl all validate names.
+ * Accepts single plugin or union of plugins: `typeof pluginA | typeof pluginB`
+ */
+export declare type PluginTypedMicroRouterStore<T> = Omit<MicroRouterStore, 'push' | 'stepWisePush' | 'stepWiseBack' | 'openDialog' | 'closeDialog' | 'toggleControl'> & {
+    push: PluginTypedPush<ExtractRoutePaths<T>, RegisteredRouteAttrs>;
+    stepWisePush: PluginTypedStepWisePush<ExtractRoutePaths<T>, RegisteredRouteAttrs>;
+    stepWiseBack: PluginTypedStepWiseBack;
+    openDialog: PluginTypedOpenDialog<ExtractDialogPaths<T>, RegisteredDialogAttrs>;
+    closeDialog: PluginTypedCloseDialog<ExtractDialogPaths<T>>;
+    toggleControl: PluginTypedToggleControl<ExtractControlNames<T>, RegisteredControlAttrs>;
+};
+
+export declare interface PluginTypedOpenDialog<Dialogs extends string, AttrsMap = {}> {
+    <K extends Dialogs>(path: K, ...args: K extends keyof AttrsMap ? [props: AttrsMap[K]] : [props?: Record<string, unknown>]): {
+        path: string;
+        attrs?: Record<string, unknown>;
+    };
+}
+
+/**
+ * Per-call generic: TypeScript infers K from the destination string literal,
+ * then resolves props type specifically for that route.
+ * K extends keyof AttrsMap → AttrsMap[K]
+ * K not in AttrsMap → Record<string, unknown>
+ */
+/**
+ * Conditional rest args pattern:
+ * - Route in AttrsMap → [props: AttrsMap[K]] (required)
+ * - Route not in AttrsMap → [props?: Record<string, unknown>] (optional)
+ */
+export declare interface PluginTypedPush<Routes extends string, AttrsMap = {}> {
+    <K extends Routes>(destination: K, ...args: K extends keyof AttrsMap ? [props: AttrsMap[K]] : [props?: Record<string, unknown>]): Promise<void>;
+    (destination: number, props?: Record<string, unknown>): Promise<void>;
+    (destination: `/${string}`, props?: Record<string, unknown>): Promise<void>;
+}
+
+declare interface PluginTypedStepWiseBack {
+    (steps: number): Promise<void>;
+}
+
+declare interface PluginTypedStepWisePush<Routes extends string, AttrsMap = {}> {
+    <K extends Routes>(targetPath: K, ...args: K extends keyof AttrsMap ? [props: AttrsMap[K]] : [props?: Record<string, unknown>]): Promise<void>;
+    (targetPath: `/${string}`, props?: Record<string, unknown>): Promise<void>;
+}
+
+export declare interface PluginTypedToggleControl<Controls extends string, AttrsMap = {}> {
+    <K extends Controls>(name: K, active: boolean, ...args: K extends keyof AttrsMap ? [attrs: AttrsMap[K]] : [attrs?: Record<string, unknown>]): void;
+}
+
+declare interface Props {
+    /** Required config — must provide defaultPath and defaultControlName */
+    config: MicroRouterConfig;
+    plugins?: FeaturePlugin[];
+    /** Mark as a nested router — each nested instance has its own independent page/dialog/control state */
+    nested?: boolean;
+}
+
+declare interface Props_2 {
+    routePath?: string;
+}
+
+declare interface Props_3 {
+    dialog: MicroDialog;
+    stackIndex: number;
+}
+
+declare interface Props_4 {
+    control: MicroControl;
+}
+
+/** Register plugin type — declare once in app-plugin.ts */
+export declare interface Register {
+}
+
+export declare type RegisteredControlAttrs = ControlAttrsMap;
+
+export declare type RegisteredDialogAttrs = DialogAttrsMap;
+
+/** Resolved plugin type from Register — `never` if not augmented */
+export declare type RegisteredPlugin = Register extends {
+    plugin: infer T;
+} ? T : never;
+
+/** Resolved attrs maps — from augmented interfaces */
+export declare type RegisteredRouteAttrs = RouteAttrsMap;
+
+/** Resolved route map from Register — `never` if not augmented */
+declare type RegisteredRouteMap = Register extends {
+    routeMap: infer T extends RouteMap;
+} ? T : never;
+
+/**
+ * Register all plugins' routes/dialogs/controls with the router store.
+ * Call synchronously before onMounted (typically in MicroRouterView setup).
+ */
+export declare function registerFeaturePlugins(plugins: FeaturePlugin[], store: MicroRouterStore): void;
+
+/**
+ * Auto-resolved store type based on Register augmentation.
+ * Priority: plugin > routeMap > untyped MicroRouterStore
+ * Attrs maps (routeAttrs/dialogAttrs/controlAttrs) are passed through when declared.
+ */
+export declare type ResolvedMicroRouterStore = HasRegisteredPlugin extends true ? Omit<MicroRouterStore, 'push' | 'stepWisePush' | 'stepWiseBack' | 'openDialog' | 'closeDialog' | 'toggleControl'> & {
+    push: PluginTypedPush<ExtractRoutePaths<RegisteredPlugin>, RegisteredRouteAttrs>;
+    stepWisePush: PluginTypedStepWisePush<ExtractRoutePaths<RegisteredPlugin>, RegisteredRouteAttrs>;
+    stepWiseBack: PluginTypedStepWiseBack;
+    openDialog: PluginTypedOpenDialog<ExtractDialogPaths<RegisteredPlugin>, RegisteredDialogAttrs>;
+    closeDialog: PluginTypedCloseDialog<ExtractDialogPaths<RegisteredPlugin>>;
+    toggleControl: PluginTypedToggleControl<ExtractControlNames<RegisteredPlugin>, RegisteredControlAttrs>;
+} : HasRegisteredRouteMap extends true ? Omit<MicroRouterStore, 'push'> & {
+    push: TypedPush<RegisteredRouteMap>;
+} : MicroRouterStore;
+
+/**
+ * Per-route attrs — augment from each route component.
+ * Keys = route path strings, values = attrs type for that route.
+ * TS interface merging combines declarations across all files.
+ */
+export declare interface RouteAttrsMap {
+}
+
+export declare interface RouteLifecycleHooks {
+    onRouteEnter?: () => void;
+    onRouteLeave?: () => void;
+}
+
+/**
+ * Type-level helpers for opt-in type safety across routes, dialogs, and controls.
+ *
+ * Two usage patterns:
+ *
+ * 1. Infer from plugin (recommended — zero duplication):
+ *    ```ts
+ *    const plugin = defineFeaturePlugin({ ... } as const);
+ *    const store = useMicroRouter<typeof plugin>();
+ *    ```
+ *
+ * 2. Manual route map (when you need typed props):
+ *    ```ts
+ *    interface AppRoutes { home: undefined; profile: { userId: number } }
+ *    const store = useMicroRouter<AppRoutes>();
+ *    ```
+ */
+/** Route map: keys are route segment names, values are props type or undefined */
+export declare type RouteMap = Record<string, Record<string, unknown> | undefined>;
+
+export declare const RoutePage: __VLS_WithTemplateSlots_2<typeof __VLS_component_2, __VLS_TemplateResult_2["slots"]>;
+
+/** Extract route names that don't require props */
+export declare type RoutesWithoutProps<T extends RouteMap> = {
+    [K in keyof T]: T[K] extends undefined ? K : never;
+}[keyof T];
+
+/** Extract route names that require props */
+export declare type RoutesWithProps<T extends RouteMap> = {
+    [K in keyof T]: T[K] extends undefined ? never : K;
+}[keyof T];
+
+/** Safely mark a Vue component as raw to prevent reactivity */
+export declare function safeMarkRaw<T extends object>(component: T): T;
+
+export declare interface SerializedState {
+    /** Schema version for future migration support */
+    version: 1;
+    navigation: {
+        activePath: string;
+        routeAttrs: Record<string, Record<string, unknown>>;
+    };
+    dialogs: {
+        /** Open dialog paths in stack order */
+        stack: string[];
+        attrs: Record<string, Record<string, unknown>>;
+    };
+    controls: {
+        /** Active control names */
+        active: string[];
+        attrs: Record<string, Record<string, unknown>>;
+    };
+}
+
+/**
+ * Like ToRefs but all keys are required (ref always exists).
+ * Optional fields → Ref<T | undefined> (value may be undefined, ref itself never is).
+ * Required fields → Ref<T> (value always present).
+ *
+ * This means: `meta.value?.title` ✅ (not `meta?.value?.title`)
+ */
+export declare type StateRefs<T extends object> = {
+    [K in keyof T]-?: Ref<T[K]>;
+};
+
+/**
+ * Default delay (ms) between step-wise navigation transitions and navigation lock release.
+ * Must be >= the longest page transition (500ms slide) + buffer for Vue DOM patching.
+ * Too short = overlapping animations. Too long = sluggish feel.
+ */
+export declare const STEP_DELAY = 550;
+
+export declare type TransitionType = 'fade' | 'slide' | 'scale';
+
+/** Typed store from manual RouteMap — push() validates route names + props */
+export declare type TypedMicroRouterStore<T extends RouteMap> = Omit<MicroRouterStore, 'push'> & {
+    push: TypedPush<T>;
+};
+
+/** Typed push overloads for manual RouteMap */
+export declare interface TypedPush<T extends RouteMap> {
+    (destination: RoutesWithoutProps<T>): Promise<void>;
+    <K extends RoutesWithProps<T>>(destination: K, props: T[K]): Promise<void>;
+    (destination: number): Promise<void>;
+    (destination: `/${string}`, props?: Record<string, unknown>): Promise<void>;
+}
+
+export declare function useControlLifecycle(hooks: ControlLifecycleHooks): void;
+
+export declare function useControlManager(config: ControlManagerConfig, tracker?: Required<PageTrackerHooks>): ControlManagerState;
+
+export declare function useDialogLifecycle(hooks: DialogLifecycleHooks): void;
+
+export declare function useDialogManager(tracker?: Required<PageTrackerHooks>): DialogManagerState;
+
+export declare function useGestureNavigation(config: GestureConfig, ctx: GestureContext): void;
+
+/**
+ * Create and provide the MicroRouter store.
+ * Call once in the root MicroRouterView component.
+ */
+export declare function useGlobalMicroRouter(config: MicroRouterConfig): MicroRouterStore;
+
+/**
+ * Inject the MicroRouter store from a parent MicroRouterView.
+ *
+ * @example Auto-typed via Register (recommended — declare once, typed everywhere)
+ * ```ts
+ * // env.d.ts — declare once
+ * declare module 'vue-micro-router' {
+ *   interface Register { plugin: typeof appPlugin }
+ * }
+ *
+ * // Any component — no generic needed
+ * const { push } = useMicroRouter();
+ * push('shop');              // ✅ type-safe
+ * push('unknown');           // ❌ compile error
+ * ```
+ *
+ * @example Explicit generic (override or without Register)
+ * ```ts
+ * const store = useMicroRouter<typeof plugin>();
+ * ```
+ *
+ * @example Manual RouteMap (for typed props)
+ * ```ts
+ * interface AppRoutes { home: undefined; profile: { userId: number } }
+ * const store = useMicroRouter<AppRoutes>();
+ * store.push('profile', { userId: 42 }); // OK
+ * ```
+ */
+export declare function useMicroRouter(options?: UseMicroRouterOptions): ResolvedMicroRouterStore;
+
+export declare function useMicroRouter<T extends RouteMap>(options?: UseMicroRouterOptions): TypedMicroRouterStore<T>;
+
+export declare function useMicroRouter<T extends {
+    name: string;
+}>(options?: UseMicroRouterOptions): PluginTypedMicroRouterStore<T>;
+
+declare interface UseMicroRouterOptions {
+    /** If true, injects the root (outermost) router instead of the nearest parent */
+    root?: boolean;
+}
+
+/**
+ * Reactive state bridge for routes, dialogs, and controls.
+ * Auto-reads attrs from parent wrapper (RoutePage/MicroDialog/MicroControlWrapper).
+ * Mutations auto-sync back to the store — state survives remount.
+ *
+ * Returns a reactive object — no `.value` needed, works like Vue's `reactive()`.
+ * Reactive in template: `{{ state.userId }}` auto-updates.
+ * Writable: `state.userId = 42` triggers sync back to store.
+ *
+ * @example
+ * ```ts
+ * const state = useMicroState<{ userId: number; username: string }>();
+ * state.userId   // number — no .value
+ * state.userId = 42  // reactive, syncs back
+ *
+ * // With defaults
+ * const state = useMicroState({ count: 0 });
+ * state.count++  // reactive
+ * ```
+ */
+export declare function useMicroState<T extends object>(): StateRefs<T>;
+
+export declare function useMicroState<T extends object>(defaults: T): StateRefs<T>;
+
+export declare function useNavigation(config: NavigationConfig, tracker?: Required<PageTrackerHooks>): NavigationState;
+
+/** Create a page tracker with optional hook implementations. No-ops by default. */
+export declare function usePageTracker(hooks?: PageTrackerHooks): Required<PageTrackerHooks>;
+
+/**
+ * Route lifecycle hooks — fire when a route becomes/stops being the active (top) page.
+ * Similar to iOS viewWillAppear/viewWillDisappear or Vue Router's navigation guards.
+ *
+ * @example
+ * ```ts
+ * useRouteLifecycle({
+ *   onRouteEnter: () => console.log('Page visible'),
+ *   onRouteLeave: () => console.log('Page hidden'),
+ * });
+ * ```
+ */
+export declare function useRouteLifecycle(hooks: RouteLifecycleHooks): void;
+
+export { }