ngx-stack 22.0.0

package/types/ngx-stack.d.ts

@@ -0,0 +1,1075 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, EnvironmentProviders, ComponentRef, Signal, OnDestroy, ViewContainerRef, EnvironmentInjector, ChangeDetectorRef, Type, Injector, OnInit, EventEmitter } from '@angular/core';
+import { ActivatedRoute, OutletContext, NavigationExtras, RouterOutletContract, Data, RouteReuseStrategy, DetachedRouteHandle, ActivatedRouteSnapshot, Routes } from '@angular/router';
+import * as ngx_stack from 'ngx-stack';
+
+/** Which way the stack is moving. */
+type StackDirection = 'forward' | 'back';
+interface TransitionContext {
+    /**
+     * The page that will be on top of the stack once the transition finishes. On `forward` this is
+     * the newly created page; on `back` it is the page being uncovered.
+     */
+    enteringEl: HTMLElement;
+    /**
+     * The page that was on top when the transition started, or `null` when the stack was empty
+     * (the root page).
+     */
+    leavingEl: HTMLElement | null;
+    /** The element both pages live in. */
+    hostEl: HTMLElement;
+    direction: StackDirection;
+    /**
+     * The app is running right-to-left. Everything horizontal mirrors: "forward" arrives from the
+     * left rather than the right, and the swipe-back lives on the right edge. A transition that
+     * ignores this will feel backwards in Arabic and Hebrew — the new page will appear to come
+     * from where the user just came *from*.
+     */
+    rtl: boolean;
+    /** Host width in px, for transitions that want absolute distances. */
+    width: number;
+    /** Requested duration in ms, from the config. */
+    duration: number;
+}
+interface ElementAnimation {
+    el: HTMLElement;
+    /**
+     * The first keyframe is the state at progress 0, the last at progress 1. A swipe-back gesture
+     * seeks between them, so keyframes must be continuous and reversible — avoid discrete steps or
+     * properties that can't be interpolated.
+     */
+    keyframes: Keyframe[];
+    /** Overrides the spec-level easing for this element. */
+    easing?: string;
+}
+interface TransitionSpec {
+    duration: number;
+    easing: string;
+    animations: ElementAnimation[];
+}
+/**
+ * Describes how two pages swap places. Called once per transition, and also at the start of a
+ * swipe-back — in that case the resulting animation is seeked by the finger rather than played,
+ * so it must be a pure function of progress.
+ */
+type StackTransition = (ctx: TransitionContext) => TransitionSpec;
+/** The dim overlay that sits on top of a page while it is covered by another. */
+declare function scrimOf(pageEl: HTMLElement): HTMLElement | null;
+
+/** The three surfaces that get their own transition. */
+type StackPlatformKind = 'ios' | 'android' | 'web';
+interface StackPlatform {
+    /** Which transition this device gets by default. Decided by OS, not by browser vs native. */
+    readonly kind: StackPlatformKind;
+    readonly isIos: boolean;
+    readonly isAndroid: boolean;
+    /** Running inside a Capacitor native webview. */
+    readonly isCapacitor: boolean;
+    /** Running inside a Cordova / PhoneGap native webview. */
+    readonly isCordova: boolean;
+    /** Either of the above: a native webview shell rather than a real browser. */
+    readonly isNative: boolean;
+    /** Installed to the home screen and running without browser chrome. */
+    readonly isStandalonePwa: boolean;
+    /**
+     * True when the browser runs its own interactive back gesture at the screen edge, so we have to
+     * share (or fight over) those pixels.
+     *
+     * That means iOS Safari and iOS PWAs. Native shells — Capacitor and Cordova alike — leave
+     * `allowsBackForwardNavigationGestures` off in their WKWebView, so the edge is ours alone. Which
+     * is why native is the easy target and the browser is the awkward one.
+     */
+    readonly hasSystemBackGesture: boolean;
+}
+declare const NGX_STACK_PLATFORM: InjectionToken<StackPlatform>;
+
+/** A transition per platform. Anything you leave out keeps the built-in for that platform. */
+interface StackTransitionMap {
+    ios?: StackTransition;
+    android?: StackTransition;
+    web?: StackTransition;
+}
+/**
+ * What to do about the browser's *own* edge-swipe back gesture.
+ *
+ * Only relevant on iOS Safari and iOS standalone PWAs — WebKit reserves the screen edge for
+ * its own interactive back navigation and gives you no way to turn it off. Under Capacitor
+ * the webview has no such gesture, so this setting does nothing there.
+ */
+type SystemGesturePolicy = 
+/**
+ * Start our gesture zone a few px inland so the two don't fight over the same pixels. The
+ * system still owns the outermost `systemEdgeInset` px; when it fires we notice and skip
+ * our own animation rather than drawing a second one on top of WebKit's.
+ */
+'inset'
+/**
+ * `preventDefault()` the touchstart inside the edge zone, which stops WebKit starting its
+ * gesture. Reliable, but it also suppresses the synthetic `click` for touches beginning
+ * there — don't use it if you have tappable UI within `swipeEdgeWidth` px of the edge.
+ */
+ | 'suppress'
+/** Do nothing, and let both gestures coexist. */
+ | 'ignore';
+/**
+ * What to do when the page on top has a `canDeactivate` guard.
+ *
+ * The gesture animates the page away *before* the navigation runs, so a guard that later says
+ * no leaves us with nothing to do but snap the page back — a visible, ugly bounce. Guards can
+ * also be async, and a touch handler cannot wait for a promise.
+ */
+type GuardPolicy = 
+/**
+ * **Default.** A route with a `canDeactivate` guard is not swipeable, unless its component
+ * implements `ngxCanSwipeBack()` — which is synchronous, so the gesture can simply not start.
+ * Your back button still runs the guard normally, and that's where a confirm dialog belongs.
+ */
+'block'
+/**
+ * Let the gesture run and take the bounce if the guard refuses. Pick this only when you know
+ * your guards effectively always pass.
+ */
+ | 'allow';
+interface NgxStackConfig {
+    /** Force a platform instead of detecting it. Handy for testing an iOS build on a laptop. */
+    platform?: StackPlatformKind | 'auto';
+    /**
+     * Writing direction. `'auto'` reads the computed `direction` off the host element, so an
+     * app that sets `<html dir="rtl">` mirrors everything with no configuration: the transitions
+     * come from the other side and the swipe lives on the right edge.
+     */
+    direction?: 'auto' | 'ltr' | 'rtl';
+    /**
+     * The page transition. Pass one function to use it everywhere, or a
+     * {@link StackTransitionMap} to vary it by platform.
+     */
+    transitions?: StackTransition | StackTransitionMap;
+    /**
+     * Base duration in ms. Built-in transitions scale this to taste (Android and web run shorter
+     * than iOS). A custom transition returns its own duration and can ignore it.
+     */
+    duration?: number;
+    /**
+     * The tabs, as URL path prefixes: `['home', 'search', 'profile']`.
+     *
+     * Set this and each one gets its own independent stack. Switching tabs unwinds nothing and
+     * destroys nothing — the tab you left keeps its pages mounted, exactly where you were, and comes
+     * back that way. Leave it unset and there's a single stack, which is the common case.
+     *
+     * It has to be declared, because nothing in a route config distinguishes "these are siblings you
+     * switch between, each keeping its own history" from "these are just different URLs". `/settings`
+     * is a tab and `/settings/sheet` is a page inside it; only you know that.
+     *
+     * It isn't repeated anywhere, though — {@link NgxStackTabs} exposes it as `tabs()`, so the same
+     * declaration also renders your tab bar. And a route whose URL doesn't happen to start with its
+     * tab's name can say where it belongs with `data: { tab: 'search' }`.
+     */
+    tabs?: string[];
+    /**
+     * Rebuild the pages that *should* have been underneath, when the app opens partway in — a push
+     * notification, a shared link, a refresh three screens deep.
+     *
+     * Without this the router lands you on the detail page with a stack of exactly one: nothing for a
+     * swipe to drag into view. (The back *button* is a separate matter and always works — declare
+     * `data: { parent: '/inbox' }` on the route.)
+     *
+     * - `true` — work the ancestors out from the route config: `data: { parent }` where you've
+     *   declared one, otherwise the URL's own nesting (`/inbox/item/12/notes` → `/inbox/item/12` →
+     *   `/inbox`).
+     * - a function — your own `(url) => parentUrl | null`, applied repeatedly to build a chain. For a
+     *   URL scheme whose nesting doesn't reflect the screens, or routes behind `loadChildren`, whose
+     *   children can't be inspected without loading them.
+     *
+     * Nothing else to set up: the first navigation is intercepted before anything is built, so the
+     * deep page is still constructed exactly once — at the end, on top of its ancestors.
+     *
+     * The cost is real, though: the ancestors are built and **their resolvers run**, for pages the
+     * user may never look at. If your list page does something expensive on load, leave this off and
+     * let the first back be a tap.
+     */
+    deepLinks?: boolean | ((url: string) => string | null);
+    /**
+     * Cap on how many pages one stack keeps mounted. `0` (the default) means no cap.
+     *
+     * Pages are cheap but not free, and a stack you can descend forever — a chat, a wiki, a file
+     * browser — will happily hold fifty live components. With a cap, pages that fall off the
+     * bottom are destroyed. Going back past that horizon still works: the page is rebuilt from
+     * its URL and still animates as a *back*, so nothing looks wrong. It just lost its state,
+     * which is the trade you asked for.
+     */
+    maxDepth?: number;
+    /**
+     * Move focus into the page that just entered, and announce it to screen readers. Default
+     * `true`. Without this, a screen-reader user gets no signal that the page changed and their
+     * focus stays on a control that has now slid off the screen.
+     */
+    manageFocus?: boolean;
+    /** See {@link GuardPolicy}. */
+    guardPolicy?: GuardPolicy;
+    /**
+     * Interactive swipe-to-go-back. `'auto'` arms it on iOS only — Android's back gesture belongs
+     * to the OS, and the default web transition is too subtle to scrub usefully.
+     *
+     * Only the starting value; {@link NgxStackSwipe} changes it at runtime.
+     */
+    swipeBack?: boolean | 'auto';
+    /** Width of the edge zone, in px, in which a swipe can begin. Mirrored in RTL. */
+    swipeEdgeWidth?: number;
+    /** Progress in `[0, 1]` past which releasing the finger completes the pop. */
+    swipeThreshold?: number;
+    /** px/ms. A flick faster than this decides on its own, whatever the progress. */
+    swipeVelocityThreshold?: number;
+    /** See {@link SystemGesturePolicy}. */
+    systemGesture?: SystemGesturePolicy;
+    /** With `systemGesture: 'inset'`, how many px at the very edge to concede to the browser. */
+    systemEdgeInset?: number;
+    /** Also allow dragging with a mouse. For developing the gesture in a desktop browser. */
+    swipeWithMouse?: boolean;
+    /** Animate the very first page pushed onto an empty stack. */
+    animateRoot?: boolean;
+    /**
+     * Honour `prefers-reduced-motion: reduce` by making transitions instant. Default `true`.
+     *
+     * The swipe-back keeps its animation regardless, on purpose: motion the user is dragging with
+     * their own finger is direct manipulation, which the guidance exempts — and a swipe with no
+     * visual response isn't reduced motion, it's a broken gesture.
+     */
+    respectReducedMotion?: boolean;
+}
+type ResolvedStackConfig = Required<Omit<NgxStackConfig, 'transitions' | 'tabs'>> & Pick<NgxStackConfig, 'transitions' | 'tabs'>;
+
+/**
+ * Wire up the stack. One call, everything in it.
+ *
+ * ```ts
+ * bootstrapApplication(App, {
+ *   providers: [
+ *     provideRouter(routes),
+ *     provideNgxStack({
+ *       transitions: { ios: iosTransition, android: androidTransition, web: noneTransition },
+ *       tabs: ['inbox', 'search'],
+ *       deepLinks: true,     // needs withDisabledInitialNavigation() — see below
+ *     }),
+ *   ],
+ * });
+ * ```
+ *
+ * Installs {@link NgxStackRouteReuseStrategy}, which is required — Angular's default strategy
+ * recycles a component when only the route params change, which would quietly merge `/item/1` and
+ * `/item/2` into one page instead of two.
+ */
+declare function provideNgxStack(config?: NgxStackConfig): EnvironmentProviders;
+/** The slice of `@capacitor/app` we need. Structural, so there is no dependency on Capacitor. */
+interface CapacitorAppLike {
+    addListener(eventName: 'backButton', listenerFunc: (event: {
+        canGoBack: boolean;
+    }) => void): Promise<unknown>;
+    exitApp(): Promise<void>;
+}
+/**
+ * Route the Android hardware back button (and the Android system back gesture, which Capacitor
+ * reports through the same event) into the stack.
+ *
+ * Pass the plugin in rather than having the library import it, so `@capacitor/app` stays out of the
+ * dependency graph of anyone shipping only to the web:
+ *
+ * ```ts
+ * import { App } from '@capacitor/app';
+ * provideCapacitorBack(App)
+ * ```
+ *
+ * At the root of the stack this calls `exitApp()`, which is what Android users expect — back on the
+ * first screen closes the app rather than doing nothing.
+ *
+ * The event's own `canGoBack` is deliberately ignored. It describes the *webview's* history, and
+ * history is a single linear thread while tabs are several stacks — so it says yes when the only
+ * thing behind you is a different tab. We ask the stack instead.
+ */
+declare function provideCapacitorBack(app: CapacitorAppLike): EnvironmentProviders;
+/**
+ * The same, for Cordova / PhoneGap.
+ *
+ * Cordova is a WKWebView (iOS) or WebView (Android) with plugins bolted on, so everything else in
+ * this library already works there unchanged — the swipe, the transitions, the stacks, the tabs.
+ * The one thing that isn't web is the Android hardware back button, which Cordova delivers as a
+ * `backbutton` event on `document` once `deviceready` has fired.
+ *
+ * ```ts
+ * provideCordovaBack()
+ * ```
+ *
+ * Nothing to pass in: unlike Capacitor, Cordova's API is a global. At the root of the stack this
+ * calls `navigator.app.exitApp()`.
+ */
+declare function provideCordovaBack(): EnvironmentProviders;
+
+/**
+ * A page transition that can be either played or scrubbed.
+ *
+ * This is the whole reason the library exists. A CSS transition or a View Transition is
+ * fire-and-forget: it runs to completion on its own clock. A swipe-back is the opposite —
+ * the finger owns the clock, the transition has to follow it, and the user may change
+ * their mind halfway and drag right back.
+ *
+ * So a transition is built as a set of paused Web Animations with `fill: 'both'`. Paused at
+ * `currentTime = 0` they hold their first keyframe; the gesture then writes `currentTime`
+ * directly on every touch move.
+ */
+declare class TransitionPlayer {
+    private readonly spec;
+    private animations;
+    private duration;
+    private disposed;
+    /**
+     * @param interactive Build for scrubbing. Timing easing is forced to linear so that
+     *   seeking to progress `p` puts the page at exactly `p` of the way across — otherwise
+     *   the iOS curve makes the page lead and then lag the finger, which is precisely the
+     *   tell that separates a native-feeling swipe from a web one. The real curve is applied
+     *   later, by `settle()`.
+     */
+    constructor(spec: TransitionSpec, interactive?: boolean);
+    /** Where the transition currently sits, in `[0, 1]`. */
+    get progress(): number;
+    /** Jump to a progress in `[0, 1]`. Called on every touch move during a swipe. */
+    seek(progress: number): void;
+    /** Run to progress 1 on the transition's own clock. */
+    play(): Promise<void>;
+    /**
+     * Hand the clock back to the browser after a scrub, carrying on to `target`.
+     *
+     * Deliberately *not* a continuation of the scrub timeline. Re-applying the easing curve
+     * to a timeline that is already part-way through would snap the page to `easing(t)`, a
+     * visible jump at the exact moment the user lets go. Instead we snapshot what is
+     * currently on screen and animate from there to the target with the real curve, which is
+     * continuous by construction.
+     *
+     * @param ms How long the remaining distance should take. Scale this by the distance left
+     *   so a release near the end is quick and one near the start is not.
+     */
+    settle(target: 0 | 1, ms: number, easing?: string): Promise<void>;
+    private run;
+    private settled;
+    /** Snap to the end state with no animation. */
+    finish(): void;
+    /** Drop the animations, reverting the elements to the styles they had before. */
+    destroy(): void;
+}
+
+/** One page living on the stack. */
+interface StackEntry {
+    readonly id: number;
+    /**
+     * Serialized URL that owns this page, used to recognise it again on a later navigation.
+     * Empty for imperative stacks, which have no URL of their own.
+     */
+    url: string;
+    /**
+     * Which tab's stack this page belongs to, or `''` when the app has no tabs. Pages of
+     * inactive tabs stay mounted — that is the entire point of tabs having their own stacks.
+     */
+    readonly tab: string;
+    /** The wrapper we transform. Not the component's own host element — that lives inside. */
+    readonly element: HTMLElement;
+    /** The dim overlay shown while this page is covered. */
+    readonly scrim: HTMLElement;
+    readonly ref: ComponentRef<unknown>;
+    route: ActivatedRoute | null;
+    /**
+     * Child outlet contexts captured when this page was navigated away from, so that any nested
+     * `<router-outlet>` inside it comes back alive rather than empty when we return.
+     */
+    savedContexts?: Map<string, OutletContext>;
+}
+/**
+ * Lifecycle callbacks for a page on the stack.
+ *
+ * Stacked pages are *not* destroyed when you navigate away from them — that's the point, it's
+ * what preserves their state and lets the swipe reveal them instantly. Which also means
+ * `ngOnDestroy` no longer means "the user left this page". These hooks do.
+ */
+interface NgxStackPage {
+    /** The page is about to become the top of the stack. Fires before the transition. */
+    ngxViewWillEnter?(): void;
+    /** The page is now the top of the stack and the transition has finished. */
+    ngxViewDidEnter?(): void;
+    /** The page is about to stop being the top of the stack. */
+    ngxViewWillLeave?(): void;
+    /** The page is no longer the top of the stack. It stays alive unless it was popped. */
+    ngxViewDidLeave?(): void;
+    /**
+     * Veto the swipe-back gesture while this page is on top. Consulted on every touch, so it can
+     * depend on live state — an open modal, a dirty form, an in-flight payment.
+     *
+     * A veto only. It cannot turn the gesture *on* where `NgxStackSwipe` or the outlet have
+     * turned it off. For a page that is simply never swipeable, `data: { swipeBack: false }` on
+     * the route says the same thing without any code.
+     *
+     * This is also how a route with a `canDeactivate` guard opts back into the gesture — see
+     * `guardPolicy`.
+     */
+    ngxCanSwipeBack?(): boolean;
+}
+
+/** A swipe-back in progress: the pages involved, and the transition the finger is scrubbing. */
+interface InteractiveBack {
+    readonly player: TransitionPlayer;
+    /** The page being uncovered — the one that will be on top if the swipe completes. */
+    readonly entering: StackEntry;
+    /** The page being dragged off — the current top. */
+    readonly leaving: StackEntry;
+}
+/** Emitted around every transition, including the ones a finger is driving. */
+interface StackTransitionEvent {
+    direction: StackDirection;
+    entering: StackEntry;
+    leaving: StackEntry | null;
+    /** The tab this happened in, or `''` in a single-stack app. */
+    tab: string;
+    /** False when the pages simply swapped, e.g. a tab switch or reduced motion. */
+    animated: boolean;
+    /** True when a swipe-back drove it rather than a navigation. */
+    interactive: boolean;
+}
+type StackOp = 
+/** Mount `entering` on top of `tab`'s stack. */
+{
+    kind: 'push';
+    tab: string;
+    entering: StackEntry;
+    animated: boolean;
+}
+/**
+ * Swap the top page for `entering`. What `router.navigate(…, { replaceUrl: true })` means for a
+ * stack: history didn't grow, so neither should the stack.
+ */
+ | {
+    kind: 'replace';
+    tab: string;
+    entering: StackEntry;
+    animated: boolean;
+}
+/** Unwind `tab`'s stack to `toIndex`, destroying everything above it. */
+ | {
+    kind: 'pop';
+    tab: string;
+    toIndex: number;
+    animated: boolean;
+    player?: TransitionPlayer;
+}
+/** Replace *every* stack with this one page. */
+ | {
+    kind: 'root';
+    tab: string;
+    entering: StackEntry;
+    animated: boolean;
+}
+/**
+ * Rebuild a page that fell off the bottom of a capped stack, and make it the new bottom.
+ * Everything currently in that stack sat above it, so all of it goes.
+ */
+ | {
+    kind: 'restore';
+    tab: string;
+    entering: StackEntry;
+    animated: boolean;
+};
+/**
+ * Owns the pages of a stack — their DOM, their order, and the transitions between them.
+ *
+ * Deliberately free of framework plumbing: it knows nothing about the Router or about
+ * imperative pushes. Both `NgxStackOutlet` and `NgxStack` drive this same class, which is why
+ * a swipe-back behaves identically whether the stack is fed by URLs or by `push()`.
+ *
+ * With `tabs` configured it holds one stack *per tab* and shows the active one. Tabs are not a
+ * feature bolted on top — they're the reason the pages live in a map keyed by tab rather than a
+ * flat array. Switching tabs mounts nothing and destroys nothing; it just changes which stack's
+ * top page is on screen, so the tab you left is still exactly where you left it.
+ */
+declare class StackController {
+    private readonly hostEl;
+    private readonly config;
+    private readonly platform;
+    private readonly stacks;
+    private readonly active;
+    /** URLs evicted by `maxDepth`, per tab. Remembered so we still know they're *behind* us. */
+    private readonly pruned;
+    /** The active tab's pages, bottom first. */
+    readonly pages: Signal<readonly StackEntry[]>;
+    readonly depth: Signal<number>;
+    readonly canGoBack: Signal<boolean>;
+    readonly activeTab: Signal<string>;
+    private readonly _animating;
+    readonly animating: Signal<boolean>;
+    /** Set by the host so it can re-emit these as component outputs. */
+    onTransitionStart?: (event: StackTransitionEvent) => void;
+    onTransitionEnd?: (event: StackTransitionEvent) => void;
+    private nextId;
+    private running;
+    private readonly doc;
+    constructor(hostEl: HTMLElement, config: ResolvedStackConfig, platform: StackPlatform);
+    stackOf(tab: string): readonly StackEntry[];
+    top(tab?: string): StackEntry | null;
+    at(index: number, tab?: string): StackEntry | null;
+    findByUrl(url: string, tab?: string): number;
+    /** Was this URL evicted by `maxDepth`? If so it's behind us, not ahead of us. */
+    wasPruned(url: string, tab?: string): boolean;
+    private hasPrunedPages;
+    /** Wrap a freshly created component in a page element and put it in the host. */
+    adopt(ref: ComponentRef<unknown>, url: string, route: ActivatedRoute | null, tab?: string): StackEntry;
+    /**
+     * Apply a stack operation. The stacks are updated *synchronously* so a navigation arriving
+     * mid-animation still sees the correct top; only the visuals and the destruction of popped
+     * pages wait for the transition.
+     */
+    run(op: StackOp): Promise<void>;
+    /** Enforce `maxDepth` by dropping pages off the bottom, remembering that they existed. */
+    private prune;
+    private playerOf;
+    private transition;
+    /** Tear down a transition: drop popped pages, fix up classes, fire the `did` hooks. */
+    private finish;
+    /** Jump an in-flight transition straight to its end state. */
+    private settle;
+    /**
+     * Set up a back transition and hand it to the gesture, paused at progress 0.
+     *
+     * Deliberately fires no lifecycle hooks: a swipe is a *peek* until the user releases, and
+     * pages should not be told they entered somewhere the user may drag right back out of. The
+     * hooks fire when the pop actually commits, through `run()`.
+     */
+    beginInteractiveBack(): InteractiveBack | null;
+    /** The user let go without going far enough: run the transition back to where it started. */
+    abortInteractiveBack(back: InteractiveBack, ms: number): Promise<void>;
+    private buildPlayer;
+    /** Which platform's look we're using, honouring a `platform` override in the config. */
+    platformKind(): StackPlatformKind;
+    /** One function for every platform, a per-platform override, or the built-in. */
+    transitionFn(): StackTransition;
+    /**
+     * Read from the DOM rather than cached, so an app that flips `dir` at runtime — which is what
+     * a language switcher does — mirrors on the very next transition without a reload.
+     */
+    isRtl(): boolean;
+    /**
+     * Only gates the *automatic* transitions. A swipe-back still animates: the user is dragging it
+     * themselves, and direct manipulation is exempt — a gesture that doesn't visibly follow the
+     * finger isn't reduced motion, it's a broken gesture.
+     */
+    private prefersReducedMotion;
+    private reveal;
+    /**
+     * The definitive resting state. Exactly one page is visible: the top of the active tab's
+     * stack. Everything else — buried pages, and every page of every inactive tab — is hidden and
+     * inert but still mounted.
+     */
+    private applyStates;
+    /**
+     * Put focus in the page that just arrived, and say its name out loud.
+     *
+     * Without this a screen-reader user gets no signal that anything happened, and keyboard focus
+     * stays on whatever control they activated — which has now slid off the screen and been marked
+     * `inert`, leaving focus nowhere at all.
+     */
+    private moveFocus;
+    private destroyEntry;
+    destroy(): void;
+}
+
+interface SwipeBackHost {
+    readonly hostEl: HTMLElement;
+    /**
+     * May a swipe start right now? Asked on every touch that lands in the edge zone, so it is free
+     * to depend on live state. The single gate: whether the gesture is enabled at all, whether
+     * there is anything to go back to, and whether the current page objects.
+     */
+    canSwipeBack(): boolean;
+    /** Right-to-left, so the gesture lives on the right edge and pulls the other way. */
+    isRtl(): boolean;
+    /** Build the scrubbable back transition, or return null to refuse. */
+    beginSwipeBack(): InteractiveBack | null;
+    /** The user let go past the threshold. Finish the animation over `ms`, then pop for real. */
+    commitSwipeBack(back: InteractiveBack, ms: number): void;
+    /** The user let go short of the threshold. Put everything back over `ms`. */
+    abortSwipeBack(back: InteractiveBack, ms: number): void;
+}
+
+/**
+ * The master switch for swipe-to-go-back.
+ *
+ * `provideNgxStack({ swipeBack })` only sets the *starting* value — this is what you reach
+ * for when the answer changes while the app is running. A modal is open, a map is eating the
+ * drag, a form has unsaved edits, a payment is in flight: turn it off, turn it back on after.
+ *
+ * ```ts
+ * const swipe = inject(NgxStackSwipe);
+ * swipe.disable();
+ * // …later
+ * swipe.reset();   // back to whatever the config said
+ * ```
+ *
+ * This is the global layer. Two narrower ones sit on top of it, and either can veto:
+ * `<ngx-stack-outlet [swipeBack]="…">` for one stack, and `ngxCanSwipeBack()` or
+ * `data: { swipeBack: false }` for one page. See {@link NgxStackPage}.
+ */
+declare class NgxStackSwipe {
+    private readonly config;
+    private readonly platform;
+    private readonly _enabled;
+    /** Read it in a template or a computed; it's a signal. */
+    readonly enabled: Signal<boolean>;
+    enable(): void;
+    disable(): void;
+    set(enabled: boolean): void;
+    /** Go back to what the config asked for, whatever that resolved to on this device. */
+    reset(): void;
+    private fromConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxStackSwipe, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgxStackSwipe>;
+}
+
+/**
+ * Everything the two kinds of stack have in common — which is almost everything.
+ *
+ * `NgxStackOutlet` is fed by the Router and `NgxStack` by `push()`, and that difference is real but
+ * shallow: it only decides *where the next page comes from*. Once a page exists, holding it,
+ * transitioning to it, dragging it around with a finger and tearing it down are identical jobs, and
+ * a swipe-back must behave the same in both. Keeping that in one place is the only way it stays that
+ * way.
+ *
+ * So a subclass supplies three things — how strict to be about guards, whether it overrides the
+ * app-wide swipe switch, and what a committed swipe should actually *do* — and inherits the rest.
+ */
+declare abstract class StackHostBase implements SwipeBackHost, OnDestroy {
+    /** Fires as a transition begins — including one a finger is about to scrub. */
+    readonly transitionStart: i0.OutputEmitterRef<StackTransitionEvent>;
+    /** Fires once the pages have settled and any popped page has been destroyed. */
+    readonly transitionEnd: i0.OutputEmitterRef<StackTransitionEvent>;
+    protected readonly config: ResolvedStackConfig;
+    protected readonly platform: ngx_stack.StackPlatform;
+    protected readonly swipe: NgxStackSwipe;
+    protected readonly viewContainer: ViewContainerRef;
+    protected readonly environmentInjector: EnvironmentInjector;
+    protected readonly changeDetector: ChangeDetectorRef;
+    readonly hostEl: HTMLElement;
+    protected readonly controller: StackController;
+    private gesture;
+    /** The active stack's pages, bottom first. */
+    readonly pages: Signal<readonly StackEntry[]>;
+    readonly depth: Signal<number>;
+    readonly animating: Signal<boolean>;
+    constructor();
+    /** Arm the gesture. Subclasses call this once they are ready to be swiped. */
+    protected startGesture(): void;
+    /**
+     * Instantiate a page component and hand it to the controller to be wrapped and mounted.
+     *
+     * The `markForCheck` matters and is easy to lose: both hosts are OnPush with an empty template of
+     * their own, so nothing would ever dirty the view and the freshly inserted page would sit there
+     * un-checked until something unrelated happened to trigger a pass.
+     */
+    protected createPage<T>(component: Type<T>, options: {
+        injector: Injector;
+        environmentInjector?: EnvironmentInjector;
+    }): ComponentRef<T>;
+    /**
+     * Three layers, narrowest last, each able to veto: the app-wide switch, this stack, and the page
+     * currently on top. Re-evaluated on every touch, so all three can change at runtime.
+     */
+    canSwipeBack(): boolean;
+    isRtl(): boolean;
+    beginSwipeBack(): InteractiveBack | null;
+    abortSwipeBack(back: InteractiveBack, ms: number): void;
+    /** The user let go past the threshold. The animation is done; make the pop real. */
+    abstract commitSwipeBack(back: InteractiveBack, ms: number): void;
+    /** `null` to defer to the app-wide {@link NgxStackSwipe}. */
+    protected abstract swipeBackOverride(): boolean | null;
+    /** Only routed pages can carry a `canDeactivate` guard, so only they need a policy for one. */
+    protected abstract guardPolicy(): GuardPolicy;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StackHostBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StackHostBase, never, never, {}, { "transitionStart": "transitionStart"; "transitionEnd": "transitionEnd"; }, never, never, true, never>;
+}
+
+/** Where a "back" would actually go. */
+interface BackTarget {
+    url: string;
+    /**
+     * Whether that URL is a page we already have mounted beneath the current one. When it isn't —
+     * a cold deep link, where there is nothing underneath — going back has to build it.
+     */
+    mounted: boolean;
+}
+/** Implemented by the outlet, so `back()` knows what is actually beneath the current page. */
+interface StackBackTarget {
+    backTarget(): BackTarget | null;
+}
+/**
+ * Navigation with an explicit stack intent.
+ *
+ * You don't have to use this for pushing — plain `router.navigate()` works, and the outlet infers
+ * the direction by checking whether the target URL is already on the stack. It's for the cases
+ * where that inference is wrong, and for going back, which is subtler than it looks.
+ */
+declare class NgxStackNav {
+    private readonly router;
+    private readonly location;
+    private readonly history;
+    private target;
+    /** @internal Called by `NgxStackOutlet`. */
+    registerStack(target: StackBackTarget): void;
+    /** @internal */
+    unregisterStack(target: StackBackTarget): void;
+    /**
+     * Is there anywhere to go back to *within the app*?
+     *
+     * Ask this, not the shell. Capacitor and Cordova both report whether the *webview* can go back,
+     * which is a statement about history — and history is a single linear thread while tabs are
+     * several stacks, so it says yes when the only thing behind you is a different tab.
+     */
+    canGoBack(): boolean;
+    /** Push a page on top, even if its URL is already somewhere on the stack. */
+    forward(commands: unknown[] | string, extras?: NavigationExtras): Promise<boolean>;
+    /**
+     * Go back one page. This is what the swipe gesture commits to, and what a back button should
+     * call. There are three quite different situations behind that one word, and this picks between
+     * them:
+     *
+     * 1. **There's a page below, and it's also the previous history entry.** The easy case. Use a
+     *    real `history.back()`, so the URL, the browser's back button and the stack all keep telling
+     *    the same story.
+     *
+     * 2. **There's a page below, but history disagrees.** This is what tabs do to you: history is a
+     *    single linear thread, tabs are several stacks, and switching tabs leaves an unrelated page
+     *    sitting behind you. `history.back()` would jump sideways out of the stack you're in, so
+     *    navigate to the page we actually mean instead, replacing the current entry so that popping
+     *    doesn't inflate history.
+     *
+     * 3. **There's nothing below at all.** A cold deep link — a push notification, a shared URL, a
+     *    refresh three screens in. `history.back()` here walks out of the app entirely, which is
+     *    almost never what the user meant by tapping a back arrow inside it. If the route declares
+     *    where it sits (`data: { parent: '/inbox' }`) we build that page and animate to it as a back,
+     *    exactly as though it had been there all along.
+     */
+    back(commands?: unknown[] | string, extras?: NavigationExtras): Promise<boolean>;
+    /** Throw every stack away and start again from this page. */
+    root(commands: unknown[] | string, extras?: NavigationExtras): Promise<boolean>;
+    private navigate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxStackNav, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgxStackNav>;
+}
+
+/**
+ * A `<router-outlet>` that keeps a stack instead of a single page.
+ *
+ * The stock outlet destroys the outgoing component the moment you navigate. That is the right
+ * default and completely incompatible with a swipe-back: the page you are swiping back to has to
+ * already be on screen, mounted and painted, *before* the navigation that reveals it happens —
+ * otherwise there is nothing to drag into view.
+ *
+ * So pages here are mounted once and stay. Which one you are looking at is decided by where you are
+ * in the history, and the direction of each transition is inferred by asking whether the incoming
+ * URL is already on the stack (going back) or not (going forward).
+ *
+ * With `tabs` configured, one outlet holds one stack per tab and shows the active one.
+ */
+declare class NgxStackOutlet extends StackHostBase implements OnInit, OnDestroy, RouterOutletContract, StackBackTarget {
+    /** Matches `<router-outlet name>`, for named outlets. */
+    readonly name: i0.InputSignal<string>;
+    /**
+     * Swipe-back for this stack specifically. `null` (the default) defers to `NgxStackSwipe`, the
+     * app-wide switch; `true` or `false` overrides it here.
+     */
+    readonly swipeBack: i0.InputSignal<boolean | null>;
+    private readonly parentContexts;
+    private readonly router;
+    private readonly nav;
+    private readonly document;
+    private systemTransition;
+    private activatedRouteRef;
+    private current;
+    private initialized;
+    /** A committed swipe, animated to the end, waiting for the router to catch up. */
+    private pendingSwipe;
+    readonly activateEvents: EventEmitter<unknown>;
+    readonly deactivateEvents: EventEmitter<unknown>;
+    readonly attachEvents: EventEmitter<unknown>;
+    readonly detachEvents: EventEmitter<unknown>;
+    readonly activeTab: Signal<string>;
+    /**
+     * Is there anywhere to go back to? Show your back button on this.
+     *
+     * True even with a single page on the stack, if that page has a parent it could go up to — which
+     * is exactly the cold-deep-link case, where nothing is beneath but obviously something should be.
+     */
+    readonly canGoBack: Signal<boolean>;
+    constructor();
+    ngOnInit(): void;
+    get isActivated(): boolean;
+    get component(): object | null;
+    get activatedRoute(): ActivatedRoute | null;
+    get activatedRouteData(): Data;
+    activateWith(route: ActivatedRoute, environmentInjector: EnvironmentInjector): void;
+    deactivate(): void;
+    detach(): ComponentRef<unknown>;
+    attach(): void;
+    protected swipeBackOverride(): boolean | null;
+    protected guardPolicy(): GuardPolicy;
+    commitSwipeBack(back: InteractiveBack, ms: number): void;
+    /**
+     * Where a "back" should actually go.
+     *
+     * Usually the page beneath the top of the *active* stack — which, with tabs, is emphatically not
+     * whatever the browser happens to have behind us in history. When nothing is beneath, we fall back
+     * to the page this one sits under. That page isn't mounted, so it has to be built; `mounted` is
+     * how {@link NgxStackNav.back} tells the two apart, because only one of them can be served by a
+     * plain `history.back()`.
+     */
+    backTarget(): BackTarget | null;
+    private rollBackPendingSwipe;
+    /**
+     * Where the top page sits, when nothing is mounted underneath it.
+     *
+     * Nobody normally has to say: `/inbox/item/12` obviously sits under `/inbox`, and the route config
+     * already knows it. `data: { parent }` is only for URLs that don't tell the truth.
+     */
+    private parentOfTop;
+    private createEntry;
+    /** Make `entry` the outlet's current page and give it back its nested outlets. */
+    private adopt;
+    private urlOf;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxStackOutlet, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxStackOutlet, "ngx-stack-outlet", ["ngxStackOutlet"], { "name": { "alias": "name"; "required": false; "isSignal": true; }; "swipeBack": { "alias": "swipeBack"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * A self-contained page stack with no URLs — the escape hatch for navigation that has no business
+ * being in the address bar.
+ *
+ * A multi-step filter sheet, a wizard inside a modal, a drill-down in one tab of a tab bar: these
+ * are all stacks, they all want the same push/pop transition and the same swipe-back, and none of
+ * them should push history entries that the browser's back button then has to unwind one at a time.
+ *
+ * ```html
+ * <ngx-stack [root]="FilterStep1" #filters />
+ * ```
+ * ```ts
+ * filters.push(FilterStep2, { category: 'shoes' });
+ * ```
+ *
+ * Pages reach the stack they are standing on with `inject(NgxStack)`. For anything the user should
+ * be able to link to, bookmark or reload, use `<ngx-stack-outlet>` instead.
+ */
+declare class NgxStack extends StackHostBase implements OnInit {
+    /** The bottom page. Mounted on init; use `setRoot()` to change it afterwards. */
+    readonly root: i0.InputSignal<Type<unknown> | null>;
+    /** Inputs for the root page, applied with `setInput`. */
+    readonly rootInputs: i0.InputSignal<Record<string, unknown> | undefined>;
+    /**
+     * Swipe-back for this stack specifically. `null` (the default) defers to `NgxStackSwipe`, the
+     * app-wide switch; `true` or `false` overrides it here.
+     */
+    readonly swipeBack: i0.InputSignal<boolean | null>;
+    /** The stack's own node injector, so pages can `inject(NgxStack)` and push further. */
+    private readonly pageInjector;
+    readonly canGoBack: Signal<boolean>;
+    ngOnInit(): void;
+    /** Push a page on top. Resolves when the transition has finished. */
+    push<T>(component: Type<T>, inputs?: Record<string, unknown>): Promise<void>;
+    /** Pop the top page. A no-op at the root, so it is safe to call blindly. */
+    pop(): Promise<void>;
+    /** Unwind to the page at `index` (0 is the root), destroying everything above it. */
+    popTo(index: number): Promise<void>;
+    popToRoot(): Promise<void>;
+    /** Throw the stack away and start again from `component`. */
+    setRoot<T>(component: Type<T>, inputs?: Record<string, unknown>): Promise<void>;
+    protected swipeBackOverride(): boolean | null;
+    /** No routes here, so no `canDeactivate` guards to be careful about. */
+    protected guardPolicy(): GuardPolicy;
+    commitSwipeBack(back: InteractiveBack, ms: number): void;
+    private mount;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxStack, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxStack, "ngx-stack", ["ngxStack"], { "root": { "alias": "root"; "required": false; "isSignal": true; }; "rootInputs": { "alias": "rootInputs"; "required": false; "isSignal": true; }; "swipeBack": { "alias": "swipeBack"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Remembers where you were in each tab.
+ *
+ * The stacks themselves are `NgxStackOutlet`'s job — configure `tabs` and it keeps one per tab,
+ * mounted and untouched while you're elsewhere. This is the other half: tapping "Search" should
+ * take you back to the search result you were reading three screens deep, not dump you at the
+ * search tab's front page. So we watch navigations, note the current URL of each tab, and
+ * `select()` returns you to it.
+ *
+ * The tab *bar* is yours to draw — the library ships no visual design. All you need from us:
+ *
+ * ```ts
+ * const tabs = inject(NgxStackTabs);
+ * ```
+ * ```html
+ * @for (tab of ['home', 'search', 'profile']; track tab) {
+ *   <button [class.active]="tabs.active() === tab" (click)="tabs.select(tab)">{{ tab }}</button>
+ * }
+ * ```
+ */
+declare class NgxStackTabs {
+    private readonly router;
+    private readonly config;
+    private readonly urls;
+    private readonly _active;
+    /** The tab currently on screen, or `''` before the first navigation into one. */
+    readonly active: Signal<string>;
+    /** The tabs you configured, in order. */
+    readonly tabs: Signal<readonly string[]>;
+    constructor();
+    /** The page that actually landed. */
+    private leaf;
+    /** Where `tab` was last seen, or its front page if it hasn't been visited yet. */
+    urlOf(tab: string): string;
+    /**
+     * Switch to `tab`, landing back on whatever page you last had open there.
+     *
+     * Tapping the tab you're already on takes you to its root, which is what every native tab bar
+     * does — it's the standard way back out of a deep drill-down.
+     */
+    select(tab: string): Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxStackTabs, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgxStackTabs>;
+}
+
+/**
+ * Turns off Angular's own route store/detach machinery, because the stack does that job
+ * instead — and better, for this purpose: Angular's version stores a detached view and
+ * gives it back on request, while the stack keeps every page mounted and on screen, which
+ * is what lets a swipe reveal the page underneath before any navigation has happened.
+ *
+ * The one thing we do care about is `shouldReuseRoute`. Angular's default reuses a route
+ * whose config matches, so `/item/1 → /item/2` would recycle the same component instance.
+ * On a stack those are two different pages, and going back from one to the other has to
+ * work, so a change of params means a new page.
+ */
+declare class NgxStackRouteReuseStrategy implements RouteReuseStrategy {
+    shouldDetach(): boolean;
+    shouldAttach(): boolean;
+    store(): void;
+    retrieve(): DetachedRouteHandle | null;
+    shouldReuseRoute(future: ActivatedRouteSnapshot, curr: ActivatedRouteSnapshot): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxStackRouteReuseStrategy, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgxStackRouteReuseStrategy>;
+}
+
+/**
+ * The iOS navigation-controller push/pop.
+ *
+ * The incoming page slides the full width of the screen over the outgoing one, which drifts the
+ * other way at a third of the speed and dims underneath it — the parallax that makes a UIKit stack
+ * feel like sheets of paper rather than slides.
+ *
+ * The easing is UIKit's own: almost no acceleration, and a very long tail.
+ */
+declare const iosTransition: ngx_stack.StackTransition;
+
+/**
+ * The Material push: the incoming page rises and fades in over the outgoing one, which stays where
+ * it is. Shorter and flatter than iOS — Material moves things a short distance quickly rather than a
+ * long distance smoothly.
+ *
+ * Deliberately has no horizontal component, which is why `swipeBack: 'auto'` doesn't arm the gesture
+ * here: a finger dragging sideways would scrub a page moving vertically. On Android the back gesture
+ * belongs to the OS anyway. If you do want an edge swipe, give this platform a `slideTransition()`.
+ */
+declare const androidTransition: ngx_stack.StackTransition;
+
+/**
+ * The browser default — the same rise-and-fade as Android, and identical to `androidTransition` down
+ * to the numbers.
+ *
+ * They are still two transitions rather than one, and that is the point: "what a phone does" and
+ * "what a browser does" are two separate decisions that merely happen to agree today. Retuning the
+ * web here changes nothing on Android, and vice versa. If they were the same object, the first person
+ * to want a different feel on the desktop would have to change both.
+ *
+ * Why Material rather than the iOS slide: a full-width slide says *"this screen came from over
+ * there"*, which is true of something you swiped into view and not of something you clicked — and on
+ * a wide monitor it is a great many pixels moving for no reason.
+ */
+declare const webTransition: ngx_stack.StackTransition;
+
+/**
+ * Pages swap instantly.
+ *
+ * Give it to a platform you'd rather not animate — `transitions: { web: noneTransition }` is a
+ * common choice, since a page slide on a desktop monitor mostly just moves a lot of pixels.
+ *
+ * Note this also disarms the swipe on that platform in practice: there are no keyframes for a finger
+ * to scrub, so a drag has nothing to follow.
+ */
+declare const noneTransition: StackTransition;
+
+interface SlideOptions {
+    /** How far the page riding on top travels, as a % of the host's width. */
+    travel: number;
+    /** How far the page underneath drifts the other way. Less than `travel` is what makes a parallax. */
+    parallax: number;
+    /** Peak opacity of the dim overlay on the covered page. `0` to skip it. */
+    scrim: number;
+    /** Fade the travelling page as well as moving it. iOS doesn't; a shorter web slide needs to. */
+    fade: boolean;
+    easing: string;
+    /** Multiplier on the configured duration. */
+    durationScale: number;
+}
+/**
+ * The shape both horizontal transitions share: one page rides in over another, which drifts the
+ * other way more slowly and dims underneath it.
+ *
+ * iOS and web are the same animation with different numbers — a full-width slide with a heavy
+ * parallax, versus a short drift carried mostly by opacity. Writing that twice invites them to
+ * quietly diverge, and the interesting parts here are subtle enough already:
+ *
+ * - `forward` and `back` are the same keyframes with the roles swapped. That symmetry is what makes
+ *   a swipe scrubbable at all — the gesture just seeks the `back` spec.
+ * - everything horizontal is signed by `rtl`, so a page pushed "forward" in Arabic arrives from the
+ *   left, which is the direction the language reads towards.
+ */
+declare function slideTransition(options: SlideOptions): StackTransition;
+
+interface RiseOptions {
+    /** How far the incoming page rises through, in px. Material moves a short distance, quickly. */
+    travel: number;
+    easing: string;
+    /** Multiplier on the configured duration. */
+    durationScale: number;
+}
+/**
+ * The Material shape: the incoming page rises a short distance and fades in over the outgoing one,
+ * which stays exactly where it is and is simply covered.
+ *
+ * The counterpart to {@link slideTransition}. `androidTransition` and `webTransition` are both
+ * instances of this, with the same numbers — but they remain two separate transitions you can point
+ * at different things, because "what Android does" and "what a browser does" are two decisions that
+ * merely happen to agree today.
+ *
+ * Note there is no horizontal component, and that has a consequence: an edge swipe would drag
+ * sideways while the page moved vertically. That is why `swipeBack: 'auto'` only arms the gesture on
+ * iOS. For a swipe on Android or the web, give that platform a {@link slideTransition} instead.
+ */
+declare function riseTransition(options: RiseOptions): StackTransition;
+
+/**
+ * Where a page sits, when it's the first thing the app opened.
+ *
+ * Two sources, in order:
+ *
+ * 1. **`data: { parent: '/inbox' }`** on the route. The same declaration the back button uses, so
+ *    you write it once and it drives both. Necessary whenever the URL doesn't tell the truth about
+ *    the hierarchy — flat routes like `/item/42`, or a detail page reachable from two places.
+ *
+ * 2. **The URL's own nesting.** `/inbox/item/12/notes` → `/inbox/item/12` → `/inbox`: drop
+ *    segments until what's left is a real page. Costs nothing to set up and is right most of the
+ *    time, because most apps already nest their URLs the way their screens nest.
+ */
+declare function deriveParentUrl(routes: Routes, url: string): string | null;
+
+export { NGX_STACK_PLATFORM, NgxStack, NgxStackNav, NgxStackOutlet, NgxStackRouteReuseStrategy, NgxStackSwipe, NgxStackTabs, androidTransition, deriveParentUrl, iosTransition, noneTransition, provideCapacitorBack, provideCordovaBack, provideNgxStack, riseTransition, scrimOf, slideTransition, webTransition };
+export type { CapacitorAppLike, ElementAnimation, GuardPolicy, NgxStackConfig, NgxStackPage, RiseOptions, SlideOptions, StackDirection, StackEntry, StackPlatform, StackPlatformKind, StackTransition, StackTransitionEvent, StackTransitionMap, SystemGesturePolicy, TransitionContext, TransitionSpec };