@kyralabs/m3e-motion 1.3.0 → 1.5.0

package/dist/index.d.ts

@@ -57,9 +57,10 @@ declare class SpringAnimatable {
     snapTo(value: number): void;
     /**
      * Animates to `target` from the value and velocity at `now` (ms); a null spec (e.g. a spatial
-     * spring under reduced motion) jumps there.
+     * spring under reduced motion) jumps there. `velocity` (units per second) overrides the current
+     * velocity, e.g. after the value was driven by something else (a drag, a tween).
      */
-    animateTo(target: number, spec: SpringSpec | null, now: number): void;
+    animateTo(target: number, spec: SpringSpec | null, now: number, velocity?: number): void;
     /** Advances to `now` (ms) and returns the value; the animation ends once its duration is up. */
     sample(now: number): number;
 }
@@ -75,6 +76,142 @@ declare const fabMenuItemVisible: (index: number, itemCount: number, stagger: nu
  */
 declare function menuNavigationTarget(key: string, count: number, current: number): number | null;
 
+type ToolbarOrientation = 'horizontal' | 'vertical';
+/**
+ * The item index `key` moves focus to from `current` (−1: none focused) among `count` items, or
+ * null when the key does not navigate. At either end the index stays put (no wrapping).
+ */
+declare function toolbarNavigationTarget(key: string, count: number, current: number, orientation?: ToolbarOrientation, rtl?: boolean): number | null;
+
+/** Where a floating toolbar leaves the screen (FloatingToolbarExitDirection), logical. */
+type FloatingToolbarExitDirection = 'bottom' | 'top' | 'start' | 'end';
+interface FloatingToolbarScrollState {
+    /** Most negative offset: minus the distance that takes the toolbar off its container. */
+    readonly offsetLimit: number;
+    /** Current offset, between offsetLimit and 0. */
+    readonly offset: number;
+    /** Total content scrolled under the toolbar (sum of the deltas). */
+    readonly contentOffset: number;
+}
+/** rememberFloatingToolbarState() defaults: no limit known yet, fully shown. */
+declare function floatingToolbarScrollState(offsetLimit?: number, offset?: number, contentOffset?: number): FloatingToolbarScrollState;
+/** FloatingToolbarState.offset setter: coerced between offsetLimit and 0. */
+declare function withToolbarOffset(state: FloatingToolbarScrollState, offset: number): FloatingToolbarScrollState;
+/**
+ * The offset limit from the toolbar's layout (onGloballyPositioned): `distance` is how far the
+ * toolbar must travel along its exit direction to leave its container, i.e. its size plus its gap
+ * to that edge, measured without the current offset. The offset stays in range.
+ */
+declare function withToolbarOffsetLimit(state: FloatingToolbarScrollState, distance: number): FloatingToolbarScrollState;
+/** exitAlways onPostScroll: the content offset and the toolbar offset both move by `delta`. */
+declare function scrollFloatingToolbar(state: FloatingToolbarScrollState, delta: number): FloatingToolbarScrollState;
+/** 0 = fully shown, 1 = fully hidden (FloatingToolbarState.collapsedFraction()). */
+declare function toolbarCollapsedFraction(state: FloatingToolbarScrollState): number;
+/**
+ * Where a partly hidden toolbar snaps when scrolling stops (settleFloatingToolbar): shown below
+ * half, hidden from half, or null when it is already (within 1%) settled. The decision is the
+ * same as the top app bar's settleAppBar, so it reuses that port.
+ */
+declare function toolbarSettleTarget(state: FloatingToolbarScrollState): number | null;
+/**
+ * floatingToolbarVerticalNestedScroll: collapses the toolbar after scrolling down by the collapse
+ * threshold and expands it after scrolling up by the expand threshold (both
+ * FloatingToolbarDefaults.ScrollDistanceThreshold by default).
+ */
+interface ToolbarExpansionScroll {
+    readonly contentOffset: number;
+    /** The content offset that triggers the next change. */
+    readonly threshold: number;
+}
+/** A tracker for a toolbar that is `expanded` (updateThreshold). */
+declare function toolbarExpansionScroll(expanded: boolean, collapseThreshold: number, expandThreshold: number, contentOffset?: number): ToolbarExpansionScroll;
+/**
+ * onPostScroll: moves the content offset by `delta`; returns the new tracker and `'collapse'` /
+ * `'expand'` when a threshold was crossed (Compose calls onCollapse / onExpand then).
+ */
+declare function scrollToolbarExpansion(state: ToolbarExpansionScroll, delta: number, collapseThreshold: number, expandThreshold: number): {
+    state: ToolbarExpansionScroll;
+    change: 'collapse' | 'expand' | null;
+};
+
+type Easing = (fraction: number) => number;
+/** `cubic-bezier(a, b, c, d)` as an easing function. */
+declare const cubicBezier: (a: number, b: number, c: number, d: number) => Easing;
+/** Parses a resolved CSS `cubic-bezier(a, b, c, d)` (e.g. a motion easing token); null otherwise. */
+declare function parseCubicBezier(css: string): Easing | null;
+
+interface LinearIndeterminateTiming {
+    /** `LinearAnimationDuration`: one cycle. */
+    readonly durationMillis: number;
+    /** `[delay, duration]` of each keyframe pair. */
+    readonly firstHead: readonly [number, number];
+    readonly firstTail: readonly [number, number];
+    readonly secondHead: readonly [number, number];
+    readonly secondTail: readonly [number, number];
+    /** `LinearIndeterminateProgressEasing`. */
+    readonly easing: Easing;
+}
+/**
+ * The indeterminate linear indicator's fractions at `elapsedMillis`, in the order the wavy indicator
+ * draws them (`getProgressFractions`): first tail, first head, second tail, second head (0–1 each).
+ */
+declare function linearIndeterminateFractions(elapsedMillis: number, timing: LinearIndeterminateTiming): [number, number, number, number];
+interface CircularIndeterminateTiming {
+    /** `CircularAnimationProgressDuration`: one cycle. */
+    readonly durationMillis: number;
+    /** `CircularGlobalRotationDegreesTarget`: linear rotation per cycle (degrees). */
+    readonly rotation: number;
+    /** `CircularAdditionalRotationDegreesTarget`: the steps' total per cycle (degrees). */
+    readonly additionalRotation: number;
+    /** `CircularAnimationAdditionalRotationDelay`: a step starts every this. */
+    readonly additionalDelayMillis: number;
+    /** `CircularAnimationAdditionalRotationDuration`: and moves for this. */
+    readonly additionalDurationMillis: number;
+    /** `CircularIndeterminateMinProgress` / `MaxProgress`: the sweep range (0–1). */
+    readonly minProgress: number;
+    readonly maxProgress: number;
+    /** `CircularProgressEasing`: the shrinking half of the sweep. */
+    readonly easing: Easing;
+}
+interface CircularIndeterminateFrame {
+    /** Global + additional rotation, degrees clockwise. */
+    rotation: number;
+    /** Sweep, 0–1 of a full turn. */
+    sweep: number;
+}
+/** The indeterminate circular indicator at `elapsedMillis`. */
+declare function circularIndeterminateFrame(elapsedMillis: number, timing: CircularIndeterminateTiming): CircularIndeterminateFrame;
+/**
+ * The wave offset tween's duration: `((wavelength / waveSpeed) * 1000 * vertexCount)` rounded and
+ * floored at `minMillis`; `Infinity` (the offset holds at 0) when either is not positive.
+ */
+declare function waveTravelMillis(wavelength: number, waveSpeed: number, minMillis: number, vertexCount?: number): number;
+/** The wave offset (0–1) after `elapsedMillis` of a tween of `travelMillis`. */
+declare const waveOffset: (elapsedMillis: number, travelMillis: number) => number;
+/** `WavyProgressIndicatorDefaults.indicatorAmplitude`: no wave near the start and the end. */
+declare const indicatorAmplitude: (progress: number, minProgress: number, maxProgress: number) => number;
+interface AmplitudeTween {
+    readonly durationMillis: number;
+    readonly easing: Easing;
+}
+/**
+ * The amplitude Animatable of the wavy modifiers: starts at its first target without animating;
+ * a new target tweens with `increase` or `decrease` (by direction), but only once the running
+ * tween has finished (`amplitudeAnimationJob == null || isCompleted`); a target set meanwhile is
+ * ignored, as in Compose, until the next `update` after it finishes.
+ */
+declare class AmplitudeAnimation {
+    #private;
+    constructor(initial: number);
+    get value(): number;
+    get target(): number;
+    get isRunning(): boolean;
+    /** Advances to `now` (ms). */
+    sample(now: number): number;
+    /** Requests `target` at `now`; returns true when a tween started. */
+    update(target: number, now: number, increase: AmplitudeTween, decrease: AmplitudeTween): boolean;
+}
+
 interface LoadingIndicatorTiming {
     /** `MorphIntervalMillis`: how often a morph starts. */
     readonly morphIntervalMillis: number;
@@ -210,7 +347,7 @@ declare function menuTransformOrigin(anchor: MenuRect, menu: MenuRect): {
 declare function menuPosition(input: MenuPositionInput): MenuPositionResult;
 
 /** How the bar reacts to its scroll container (TopAppBarDefaults.*ScrollBehavior). */
-type AppBarScrollBehavior = 'pinned' | 'enter-always';
+type AppBarScrollBehavior = 'pinned' | 'enter-always' | 'exit-until-collapsed';
 interface AppBarScrollState {
     /** Most negative height offset: minus the bar's full height (adjustHeightOffsetLimit). */
     readonly heightOffsetLimit: number;
@@ -242,6 +379,13 @@ declare function isScrolledUnder(state: AppBarScrollState): boolean;
  * - pinned: only the content offset moves (PinnedScrollBehavior.onPostScroll).
  * - enter-always: the bar also collapses/expands by the same amount
  *   (EnterAlwaysScrollBehavior.onPreScroll: `heightOffset += available.y`).
+ * - exit-until-collapsed: scrolling down collapses the bar by the same amount
+ *   (ExitUntilCollapsedScrollBehavior.onPreScroll); scrolling up expands it only by what the
+ *   content cannot take (onPostScroll: `heightOffset += available.y` once the content is at its
+ *   start). On the web the content scrolls by the whole delta, so the part of an upward scroll
+ *   that lies within the collapsed distance of the top (scroll position below -heightOffset) is
+ *   the part Compose hands to the bar: the bar is fully expanded when the content reaches its
+ *   start, and a bar that collapsed together with the content stays attached to it.
  */
 declare function scrollAppBar(state: AppBarScrollState, behavior: AppBarScrollBehavior, scrollTop: number, delta: number): AppBarScrollState;
 /**
@@ -249,6 +393,177 @@ declare function scrollAppBar(state: AppBarScrollState, behavior: AppBarScrollBe
  * half, fully collapsed from half, or null when it is already (within 1%) settled.
  */
 declare function settleTarget(state: AppBarScrollState): number | null;
+/** TopTitleAlphaEasing (AppBar.kt L3604): CubicBezierEasing(.8f, 0f, .8f, .15f). */
+declare const TOP_TITLE_ALPHA_EASING: readonly [0.8, 0, 0.8, 0.15];
+/** FastOutLinearInEasing (Easing.kt L66): CubicBezierEasing(0.4f, 0.0f, 1.0f, 1.0f). */
+declare const FAST_OUT_LINEAR_IN_EASING: readonly [0.4, 0, 1, 1];
+/** What a two-rows bar (medium / large flexible, TwoRowsTopAppBar) draws at a collapsed fraction. */
+interface TwoRowsFrame {
+    /** Alpha of the collapsed (top row) title and subtitle: TopTitleAlphaEasing(fraction). */
+    readonly collapsedTitleAlpha: number;
+    /** Alpha of the expanded (bottom row) title and subtitle: 1 - fraction. */
+    readonly expandedTitleAlpha: number;
+    /** Container → scrolled container color mix (TopAppBarColors.containerColor): FastOutLinearIn. */
+    readonly containerColorFraction: number;
+    /** Below 0.5 the collapsed title is hidden from accessibility, from 0.5 the expanded one. */
+    readonly collapsedTitleHidden: boolean;
+}
+/** TwoRowsTopAppBar (L2818-2836): the color, both title alphas and semantics follow the fraction. */
+declare function twoRowsFrame(fraction: number): TwoRowsFrame;
+
+/** SearchBarState.currentValue is Expanded above this (L1535, "tolerance for spring anim"). */
+declare const SEARCH_BAR_EXPANDED_THRESHOLD = 0.02;
+/** ExpandedDockedSearchBarWithGap shows its results once progress passes this (L3667). */
+declare const SEARCH_DROPDOWN_VISIBLE_PROGRESS = 0.1;
+/** A Compose `tween(durationMillis, delayMillis, easing)`. */
+interface TweenSpec {
+    readonly duration: number;
+    readonly delay: number;
+    readonly easing: Easing;
+}
+/**
+ * A float with Compose `Animatable.animateTo(tween)` semantics: each target starts a tween from the
+ * current value (velocity is not carried), held for `delay`, then eased over `duration`. A null
+ * spec is Compose's `snap()`: the value jumps.
+ */
+declare class TweenAnimatable {
+    #private;
+    constructor(value: number);
+    get value(): number;
+    get target(): number;
+    get isRunning(): boolean;
+    snapTo(value: number): void;
+    animateTo(target: number, spec: TweenSpec | null, now: number): void;
+    sample(now: number): number;
+}
+/** The four animation specs of a SearchBarState (null springs / tweens jump, as `snap()`). */
+interface SearchBarSpecs {
+    readonly expand: SpringSpec | null;
+    readonly collapse: SpringSpec | null;
+    readonly contentFadeIn: TweenSpec | null;
+    readonly contentFadeOut: TweenSpec | null;
+}
+/** One sampled frame of a {@link SearchBarAnimation}. */
+interface SearchBarSample {
+    /** `animatable.value`: may overshoot 1 (expressive spatial springs). */
+    readonly value: number;
+    /** `progress`: the value clamped to [0, 1]. */
+    readonly progress: number;
+    /** `contentProgress` (the contained / with-gap results' alpha). */
+    readonly contentProgress: number;
+    /** The with-gap drop-down's slide offset in px (0 at rest, minus half its height hidden). */
+    readonly slide: number;
+    /** Whether the with-gap drop-down is shown (AnimatedVisibility is entering, visible or exiting). */
+    readonly dropdownShown: boolean;
+}
+/**
+ * SearchBarState's animation: `animateToExpanded` / `animateToCollapsed` run the progress spring
+ * and the content tween together; a new target starts from the current value and velocity
+ * (Animatable). Optionally (ExpandedDockedSearchBarWithGap) it also runs the drop-down's
+ * slide-in / slide-out on the same springs, from progress 0.1.
+ */
+declare class SearchBarAnimation {
+    #private;
+    constructor(expanded?: boolean);
+    /** SearchBarState.targetValue. */
+    get isTargetExpanded(): boolean;
+    /** SearchBarState.currentValue: expanded until the value drops to the 0.02 tolerance. */
+    get isExpanded(): boolean;
+    get isRunning(): boolean;
+    /** animateToExpanded() at `now` (ms). */
+    expand(specs: SearchBarSpecs, now: number): void;
+    /** animateToCollapsed() at `now` (ms). */
+    collapse(specs: SearchBarSpecs, now: number): void;
+    /** Jumps to collapsed (0) or expanded (1), stopping every animation. */
+    snapTo(expanded: boolean): void;
+    /**
+     * Advances to `now`. `dropdownHeight` (px, the drop-down's full height) enables the with-gap
+     * slide: AnimatedVisibility(visible = progress > 0.1 && target == Expanded) slides in from minus
+     * half the height on the expand spring and out to it on the collapse spring.
+     */
+    sample(now: number, dropdownHeight?: number): SearchBarSample;
+}
+/** The expanded views Compose offers for a SearchBarState. */
+type SearchViewVariant = 'full-screen' | 'full-screen-contained' | 'docked' | 'docked-with-gap';
+interface SearchRect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+/** The SearchBar.kt measurements the layouts read (px; search-defaults.css). */
+interface SearchViewMetrics {
+    /** SearchBarVerticalPadding (8dp). */
+    readonly verticalPadding: number;
+    /** AppBarWithSearchVerticalPadding (4dp): the contained view's top padding. */
+    readonly containedTopPadding: number;
+    /** FullScreenExpandedHorizontalPadding (8dp). */
+    readonly containedHorizontalPadding: number;
+    /** SearchBarCornerRadius = InputFieldHeight / 2 (28dp). */
+    readonly cornerRadius: number;
+    /** DockedExpandedTableMinHeight (240dp). */
+    readonly dockedMinHeight: number;
+    /** DockedExpandedTableMaxHeightScreenRatio (2/3). */
+    readonly dockedMaxHeightRatio: number;
+    /** DockedExpandedWithGapTableMaxHeightScreenRatio (1/2). */
+    readonly withGapMaxHeightRatio: number;
+    /** dockedDropdownGapSize (2dp). */
+    readonly dropdownGap: number;
+}
+interface SearchViewInput {
+    readonly variant: SearchViewVariant;
+    /** The collapsed search bar (`collapsedBounds`), viewport px. */
+    readonly collapsed: SearchRect;
+    /** The window (viewport) size. */
+    readonly window: {
+        readonly width: number;
+        readonly height: number;
+    };
+    /** The unconsumed top window inset (safe area). */
+    readonly insetTop: number;
+    readonly sample: Pick<SearchBarSample, 'value' | 'progress'>;
+    readonly metrics: SearchViewMetrics;
+}
+/** Where everything of an expanded view goes in one frame (viewport px). */
+interface SearchViewFrame {
+    /**
+     * The surface: full-screen, the growing container (with `radius`); contained, the window,
+     * faded in by `alpha`; docked, the panel holding field and results (height between `minHeight`
+     * and `maxHeight`); with gap, the scrim (drawn at `alpha` × the scrim opacity).
+     */
+    readonly surface: SearchRect & {
+        readonly radius: number;
+        readonly alpha: number;
+        readonly minHeight: number;
+        readonly maxHeight: number;
+    };
+    /** The input field (collapsed height). */
+    readonly field: {
+        readonly x: number;
+        readonly y: number;
+        readonly width: number;
+    };
+    /** The results: top-left, width and the height they may take. */
+    readonly results: {
+        readonly x: number;
+        readonly y: number;
+        readonly width: number;
+        readonly maxHeight: number;
+    };
+}
+/**
+ * The layout of an expanded view at one animation frame: FullScreenSearchBarLayout (`isContained`
+ * false / true), DockedSearchBarLayoutImpl (docked) and the with-gap popup. Predictive back is not
+ * ported (the web has no back gesture progress).
+ */
+declare function searchViewFrame(input: SearchViewInput): SearchViewFrame;
+/**
+ * The combobox's next active option for a key (React Aria / APG list autocomplete): ArrowDown
+ * from the input goes to the first option and then down, stopping at the last; ArrowUp from the
+ * input goes to the last option and then up, and from the first option back to the input (-1).
+ * Returns null for keys it does not handle or an empty list. `enabled` filters disabled options.
+ */
+declare function searchNavigationTarget(key: string, enabled: readonly boolean[], active: number): number | null;
 
 interface ButtonGroupItemSize {
     /** Resting width (Compose: the item's max intrinsic width). */
@@ -277,4 +592,640 @@ declare function buttonGroupVisibleCount(widths: readonly number[], spacing: num
  */
 declare function buttonGroupWidths(items: readonly ButtonGroupItemSize[], pressed: readonly number[], expandedRatio: number, visibleCount?: number): number[];
 
-export { type AppBarScrollBehavior, type AppBarScrollState, type ButtonGroupItemSize, DEFAULT_DISPLACEMENT_THRESHOLD, type IndeterminateFrame, type LinearEasing, type LinearEasingOptions, type LoadingIndicatorTiming, type MenuAnchorPosition, type MenuPositionInput, type MenuPositionResult, type MenuRect, type Motion, SpringAnimatable, SpringSimulation, type SpringSpec, animatedInt, appBarScrollState, buttonGroupVisibleCount, buttonGroupWidths, collapsedFraction, dampingCoefficient, dampingRatioFromCoefficient, estimateAnimationDurationMillis, estimateAnimationDurationMillisDouble, fabMenuItemVisible, indeterminateFrame, initialIndeterminateFrame, isScrolledUnder, menuNavigationTarget, menuPosition, menuTransformOrigin, morphSpringDurationMillis, overlappedFraction, scrollAppBar, settleTarget, springDurationMillis, springToLinear, springValue, springVelocity, withHeight, withHeightOffset };
+/** Width size classes, smallest first (DpWidthSizeClasses). */
+type WindowWidthSizeClass = 'compact' | 'medium' | 'expanded' | 'large' | 'extra-large';
+/** Height size classes, smallest first (DpHeightSizeClasses). */
+type WindowHeightSizeClass = 'compact' | 'medium' | 'expanded';
+/** Lower bound (min-width, dp = CSS px) of each width size class (WindowSizeClass L146-155). */
+declare const WINDOW_WIDTH_BREAKPOINTS: Readonly<Record<WindowWidthSizeClass, number>>;
+/** Lower bound (min-height, dp = CSS px) of each height size class (WindowSizeClass L158-161). */
+declare const WINDOW_HEIGHT_BREAKPOINTS: Readonly<Record<WindowHeightSizeClass, number>>;
+/** A window's (or container's) size class: androidx `WindowSizeClass` plus its bucket names. */
+interface WindowSizeClass {
+    readonly widthClass: WindowWidthSizeClass;
+    readonly heightClass: WindowHeightSizeClass;
+    /** Lower bound of the width class in CSS px (`minWidthDp`). */
+    readonly minWidth: number;
+    /** Lower bound of the height class in CSS px (`minHeightDp`). */
+    readonly minHeight: number;
+}
+interface WindowSizeClassOptions {
+    /**
+     * Classify widths into the large and extra-large classes (currentWindowAdaptiveInfoV2; default
+     * `true`). `false` keeps the V1 set, where every width from 840 is `expanded`.
+     */
+    largeAndExtraLargeWidth?: boolean | undefined;
+}
+/**
+ * The width size class of a window `widthPx` CSS px wide. Negative or NaN widths (androidx
+ * rejects them) classify as compact.
+ */
+declare function windowWidthSizeClass(widthPx: number, options?: WindowSizeClassOptions): WindowWidthSizeClass;
+/** The height size class of a window `heightPx` CSS px tall. */
+declare function windowHeightSizeClass(heightPx: number): WindowHeightSizeClass;
+/** The size class of a `width` × `height` CSS px window or container. */
+declare function windowSizeClass(size: {
+    readonly width: number;
+    readonly height: number;
+}, options?: WindowSizeClassOptions): WindowSizeClass;
+/** Whether two size classes are the same bucket (WindowSizeClass.equals). */
+declare function sameWindowSizeClass(a: WindowSizeClass, b: WindowSizeClass): boolean;
+/**
+ * `minWidth >= breakpoint` (isWidthAtLeastBreakpoint, L98-100). `breakpoint` is a class name or a
+ * px lower bound. Like androidx, check from the largest breakpoint down.
+ */
+declare function isWidthAtLeastBreakpoint(sizeClass: WindowSizeClass, breakpoint: WindowWidthSizeClass | number): boolean;
+/** `minHeight >= breakpoint` (isHeightAtLeastBreakpoint, L107-109). */
+declare function isHeightAtLeastBreakpoint(sizeClass: WindowSizeClass, breakpoint: WindowHeightSizeClass | number): boolean;
+/** Both of the above (isAtLeastBreakpoint, L117-120). */
+declare function isAtLeastBreakpoint(sizeClass: WindowSizeClass, widthBreakpoint: WindowWidthSizeClass | number, heightBreakpoint: WindowHeightSizeClass | number): boolean;
+/** Posture input for the directive and the navigation suite (Compose `Posture.isTabletop`). */
+interface WindowPostureOptions {
+    /** A half-folded device with a horizontal hinge. Default `false`. */
+    isTabletop?: boolean | undefined;
+}
+/** Material's recommended pane layout for a size class (PaneScaffoldDirective, without hinges). */
+interface PaneScaffoldDirective {
+    /** Panes side by side at most: 1 at compact/medium, 2 at expanded, 3 from large. */
+    readonly maxHorizontalPartitions: number;
+    /** Spacer between side-by-side panes, CSS px. */
+    readonly horizontalPartitionSpacerSize: number;
+    /** Panes stacked at most: 2 on a tabletop posture or a single-pane expanded-height window. */
+    readonly maxVerticalPartitions: number;
+    readonly verticalPartitionSpacerSize: number;
+    /** Default preferred pane width, CSS px (the fixed pane of a fixed-and-flexible layout). */
+    readonly defaultPanePreferredWidth: number;
+    readonly defaultPanePreferredHeight: number;
+}
+/** calculatePaneScaffoldDirective (PaneScaffoldDirective.kt L48-106), without hinge bounds. */
+declare function paneScaffoldDirective(sizeClass: WindowSizeClass, options?: WindowPostureOptions): PaneScaffoldDirective;
+/**
+ * NavigationSuiteType (NavigationSuiteScaffold.kt L1068-1155) without the types of deprecated
+ * components (`NavigationBar`, `NavigationRail`: the legacy bar / rail, D4): which navigation
+ * component a navigation suite shows. `none` shows none.
+ */
+type NavigationSuiteType = 'short-navigation-bar-compact' | 'short-navigation-bar-medium' | 'wide-navigation-rail-collapsed' | 'wide-navigation-rail-expanded' | 'navigation-drawer' | 'none';
+/** The suite types, in NavigationSuiteType's order. */
+declare const NAVIGATION_SUITE_TYPES: readonly NavigationSuiteType[];
+/** Whether a type puts the navigation at the bottom (`NavigationSuiteType.isNavigationBar`). */
+declare function isNavigationBarType(type: NavigationSuiteType): boolean;
+interface NavigationSuiteTypeOptions extends WindowPostureOptions {
+    /**
+     * From this width class (or px lower bound, compared with the class's lower bound like
+     * `isWidthAtLeastBreakpoint`) on, windows that would get the collapsed rail get `expandedType`
+     * instead. Compose's default never expands (`undefined` / `null`); the navigation suite scaffold
+     * passes {@link NAVIGATION_SUITE_EXPANDED_FROM}. The bar rules (compact width, then tabletop or
+     * compact height) still come first, as in Compose's custom configuration sample.
+     */
+    expandedFrom?: WindowWidthSizeClass | number | null | undefined;
+    /** What the expanded suite shows: the expanded wide navigation rail (default) or a drawer. */
+    expandedType?: 'wide-navigation-rail-expanded' | 'navigation-drawer' | undefined;
+}
+/**
+ * The navigation suite scaffold's default `expandedFrom`: the expanded wide navigation rail at
+ * large and extra-large widths (m3.material.io guidance, owner decision 2026-10-17, COMPONENT_SPEC
+ * §16). Not a Compose default: Compose's navigationSuiteType never returns the expanded rail.
+ */
+declare const NAVIGATION_SUITE_EXPANDED_FROM: WindowWidthSizeClass;
+/**
+ * NavigationSuiteScaffoldDefaults.navigationSuiteType (L1167-1180): a short navigation bar at
+ * compact width (compact arrangement), a short navigation bar with the medium (horizontal item)
+ * arrangement on a tabletop posture or at compact height, otherwise a collapsed wide navigation
+ * rail. With `expandedFrom`, the collapsed rail becomes `expandedType` (default: the expanded wide
+ * navigation rail) from that width on.
+ */
+declare function navigationSuiteType(sizeClass: WindowSizeClass, options?: NavigationSuiteTypeOptions): NavigationSuiteType;
+
+interface NavigationSuiteSample {
+    /** The layout's animationProgress: 0 hidden … 1 shown. */
+    readonly progress: number;
+    /** Either spring is still moving (the caller keeps its frame loop going). */
+    readonly running: boolean;
+}
+/**
+ * NavigationSuiteScaffoldState plus its layout's progress, driven by the caller's clock (ms).
+ * `spec` is the scaffold's AnimationSpec (`--m3e-comp-navigation-suite-scaffold-visibility-*`), or
+ * null to jump (the spatial spring under reduced motion).
+ */
+declare class NavigationSuiteScaffoldAnimation {
+    #private;
+    /** `hidden`: rememberNavigationSuiteScaffoldState(initialValue = Hidden); rendered at rest. */
+    constructor(hidden?: boolean);
+    /** NavigationSuiteScaffoldState.targetValue == Hidden. */
+    get targetHidden(): boolean;
+    /** NavigationSuiteScaffoldState.currentValue == Hidden (anything but exactly Visible). */
+    get currentHidden(): boolean;
+    /** NavigationSuiteScaffoldState.isAnimating (the state's spring, not the layout's). */
+    get isAnimating(): boolean;
+    /** NavigationSuiteScaffoldState.hide(). */
+    hide(spec: SpringSpec | null, now: number): void;
+    /** NavigationSuiteScaffoldState.show(). */
+    show(spec: SpringSpec | null, now: number): void;
+    /** NavigationSuiteScaffoldState.toggle(): towards the opposite of the target. */
+    toggle(spec: SpringSpec | null, now: number): void;
+    /** NavigationSuiteScaffoldState.snapTo(): the state jumps; the layout animates from `now`. */
+    snapTo(hidden: boolean, spec: SpringSpec | null, now: number): void;
+    /** Advances both springs to `now`; the layout retargets when currentValue changes. */
+    sample(now: number): NavigationSuiteSample;
+}
+/**
+ * How far the navigation is pushed out of the layout (px) for `size` (its height with a bar, its
+ * width otherwise) at `progress`: `size − (size × progress).toInt()`. The content gets the rest of
+ * the layout; the navigation sits at `layoutHeight − (height × progress).toInt()` (bar types) or
+ * `−(width × (1 − progress)).toInt()` (L417-479).
+ */
+declare function navigationSuiteOffset(size: number, progress: number): number;
+
+/** ModalWideNavigationRail: the window rail expands once positionProgress reaches this (L600). */
+declare const MODAL_RAIL_EXPANDED_PROGRESS = 0.3;
+/** The springs of a wide navigation rail (null jumps: reduced motion snaps spatial springs). */
+interface WideNavigationRailSpecs {
+    /** WideNavigationRailLayout `animationSpec` (L324): non-modal width, item spacing / min height. */
+    readonly width: SpringSpec | null;
+    /** `modalAnimationSpec` (L325): the modal window rail's width. */
+    readonly modalWidth: SpringSpec | null;
+    /** AnimatedNavigationItem `iconPositionProgress` (NavigationItem.kt L488-493). */
+    readonly iconPosition: SpringSpec | null;
+    /** ModalWideNavigationRail `positionProgress` (L593-598). */
+    readonly position: SpringSpec | null;
+    /** The modal scrim alpha (L826-831). */
+    readonly scrim: SpringSpec | null;
+    /** hideOnCollapse: ModalWideNavigationRailState (L732-736). */
+    readonly slide: SpringSpec | null;
+}
+/** One frame of a {@link WideNavigationRailAnimation}. */
+interface WideNavigationRailSample {
+    /** The items' iconPositionProgress (0 top icon … 1 start icon); expressive springs overshoot. */
+    readonly item: number;
+    /** The rail's minWidth / widthFullRange progress (0 collapsed … 1 expanded). */
+    readonly width: number;
+    /** itemVerticalSpacedBy / itemMinHeight progress (0 collapsed … 1 expanded). */
+    readonly layout: number;
+    /** Modal: the window (scrim + rail in the top layer) is shown. */
+    readonly open: boolean;
+    /**
+     * The `expanded` WideNavigationRailLayout measures with: the target (non-modal); in the modal
+     * window `hideOnCollapse || modalExpanded`; false for the collapsed rail of a modal one.
+     */
+    readonly railExpanded: boolean;
+    /** Modal: the scrim alpha, 0…1. */
+    readonly scrim: number;
+    /** hideOnCollapse: 0 off screen (offset −width) … 1 in place. */
+    readonly slide: number;
+    /** Any value is still moving. */
+    readonly running: boolean;
+}
+interface WideNavigationRailAnimationOptions {
+    readonly expanded: boolean;
+    /** ModalWideNavigationRail. */
+    readonly modal?: boolean;
+    /** ModalWideNavigationRail(hideOnCollapse = true): slides in expanded instead of expanding. */
+    readonly hideOnCollapse?: boolean;
+    /**
+     * Visibility threshold of the width spring in progress units: animateDpAsState uses
+     * Spring.DefaultDisplacementThreshold (0.01dp) over the width range (default: 0.01 / 264dp).
+     */
+    readonly widthThreshold?: number;
+    /** Likewise for spacing / min height (default: 0.01 / 16dp, the min-height range). */
+    readonly layoutThreshold?: number;
+}
+/**
+ * WideNavigationRailState plus the animations it drives. `setExpanded` retargets every value from
+ * its current value and velocity (Compose `animate*AsState` / `Animatable.animateTo`).
+ */
+declare class WideNavigationRailAnimation {
+    #private;
+    readonly modal: boolean;
+    readonly hideOnCollapse: boolean;
+    constructor(options: WideNavigationRailAnimationOptions);
+    /** WideNavigationRailState.targetValue. */
+    get expanded(): boolean;
+    get isRunning(): boolean;
+    /** expand() / collapse() at `now` (ms). */
+    setExpanded(expanded: boolean, specs: WideNavigationRailSpecs, now: number): void;
+    /** WideNavigationRailState.snapTo. */
+    snapTo(expanded: boolean): void;
+    sample(now: number): WideNavigationRailSample;
+}
+/** The dp values WideNavigationRailLayout and AnimatedNavigationItem measure with. */
+interface WideNavigationRailMetrics {
+    /** NavigationRailCollapsedTokens.ContainerWidth (96dp). */
+    readonly collapsedWidth: number;
+    /** NavigationRailExpandedTokens.ContainerWidthMinimum (220dp). */
+    readonly expandedMinWidth: number;
+    /** NavigationRailExpandedTokens.ContainerWidthMaximum (360dp). */
+    readonly expandedMaxWidth: number;
+    /** WNRItemHorizontalPadding (20dp). */
+    readonly itemHorizontalPadding: number;
+    /** NavigationRailBaselineItemTokens.IconSize (24dp). */
+    readonly iconSize: number;
+    /** NavigationRailHorizontalItemTokens.IconLabelSpace (8dp). */
+    readonly iconLabelSpace: number;
+    /** Indicator horizontal padding per side, collapsed: (ActiveIndicatorWidth − IconSize) / 2. */
+    readonly collapsedIndicatorPadding: number;
+    /** Expanded: NavigationRailHorizontalItemTokens.FullWidthLeadingSpace. */
+    readonly expandedIndicatorPadding: number;
+}
+/**
+ * An item's measured width (placeAnimatedLabelAndIcon, NavigationItem.kt L1119-1133). `content` is
+ * the item's start-icon pill width (icon + gap + label + both expanded paddings), or null for an
+ * icon-only item (TopIconOrIconOnlyMeasurePolicy: the 56dp circle plus the padding on both sides).
+ * `maxWidth` is the rail's item constraint (expanded: rail maximum − item padding).
+ */
+declare function wideNavigationRailItemWidth(content: number | null, progress: number, m: WideNavigationRailMetrics, maxWidth: number): number;
+interface WideNavigationRailWidthInput {
+    /** `expanded` passed to WideNavigationRailLayout (the state's target, or modalExpanded). */
+    readonly expanded: boolean;
+    /** minWidth / widthFullRange progress. */
+    readonly widthProgress: number;
+    /** The items' iconPositionProgress. */
+    readonly itemProgress: number;
+    /** Each item's start-icon pill width (null: icon only). */
+    readonly items: readonly (number | null)[];
+    /** The header's width (0 without one). */
+    readonly header: number;
+    /** The width of the previous frame (`currentWidth`). */
+    readonly previousWidth: number;
+    /** `actualMaxExpandedWidth > 0`: the rail was wider than its expanded minimum. */
+    readonly wide: boolean;
+    /** The available width (the rail's maximum when unconstrained). */
+    readonly maxWidth?: number;
+    readonly metrics: WideNavigationRailMetrics;
+}
+/**
+ * WideNavigationRailLayout's measured width (L373-476): expanding, `widthFullRange` up to the
+ * widest item (+ padding) or header when that is wider than the expanded minimum, else
+ * `minWidth`; collapsing from such a rail, `widthFullRange` kept between `minWidth` and the previous
+ * width. Returns the width and whether the rail is now `wide`.
+ */
+declare function wideNavigationRailWidth(input: WideNavigationRailWidthInput): {
+    width: number;
+    wide: boolean;
+};
+
+/** NavigationDrawer.kt `DrawerPositionalThreshold` (L1339): a fraction of the sheet width. */
+declare const DRAWER_POSITIONAL_THRESHOLD = 0.5;
+/** NavigationDrawer.kt `DrawerVelocityThreshold` (L1340-1341), in dp (= CSS px) per second. */
+declare const DRAWER_VELOCITY_THRESHOLD = 400;
+/** NavigationDrawer.kt `AnchoredDraggableDefaultAnimationSpec` (L1354): the settle tween. */
+declare const DRAWER_SETTLE_MILLIS = 256;
+/** The springs and settle tween of a drawer (null jumps: reduced motion). */
+interface DrawerSpecs {
+    readonly open: SpringSpec | null;
+    readonly close: SpringSpec | null;
+    /** AnchoredDraggableDefaultAnimationSpec; null (0ms) jumps. */
+    readonly settle: {
+        readonly duration: number;
+        readonly easing: Easing;
+    } | null;
+}
+/** FloatExponentialDecaySpec.getTargetValue (L132-141). */
+declare function exponentialDecayTarget(value: number, velocity: number): number;
+/**
+ * DraggableAnchors.computeTarget (AnchoredDraggable.kt L1485-1514) for the drawer's two anchors:
+ * whether a release at `offset` (px, −width…0) with `velocity` (px/s, positive towards open)
+ * settles open. `velocityThreshold` is px/s.
+ */
+declare function drawerSettlesOpen(offset: number, velocity: number, width: number, velocityThreshold?: number): boolean;
+/** One frame of a {@link DrawerAnimation}. */
+interface DrawerSample {
+    /** Sheet offset in px: −width (closed) … 0 (open); above 0 while an open spring overshoots. */
+    readonly offset: number;
+    /** calculateFraction(closed, open, offset): 0 closed … 1 open (the scrim alpha). */
+    readonly fraction: number;
+    /** Something is moving (an animation or a drag). */
+    readonly running: boolean;
+    /** The sheet is visible (fraction > 0): Compose only places it then. */
+    readonly visible: boolean;
+}
+/** DrawerState: the offset, its animations, drags and the settle after a release. */
+declare class DrawerAnimation {
+    #private;
+    /** @param open initial value (at rest); @param width the sheet width in px. */
+    constructor(open: boolean, width: number);
+    /** DrawerState.targetValue === Open. */
+    get isOpen(): boolean;
+    /** DrawerState.currentValue === Open: the last anchor it settled on. */
+    get isSettledOpen(): boolean;
+    get isDragging(): boolean;
+    get width(): number;
+    /** Units: px per second, positive towards open (AnchoredDraggableState.lastVelocity). */
+    get velocity(): number;
+    /** New anchors (the sheet was measured): at rest the offset follows its anchor. */
+    setWidth(width: number): void;
+    /** Jumps (DrawerState.snapTo). */
+    snapTo(open: boolean): void;
+    /** DrawerState.open() / close() at `now` (ms): springs from the current offset and velocity. */
+    animateTo(open: boolean, specs: DrawerSpecs, now: number): void;
+    /** Grabs the sheet (pointer down past the slop): stops any animation where it is. */
+    startDrag(now: number): void;
+    /** Moves the offset by `delta` px (positive towards open), coerced between the anchors. */
+    dragBy(delta: number): void;
+    /**
+     * Ends a drag with the pointer `velocity` (px/s, positive towards open): picks the target
+     * (computeTarget) and settles on it (animateToWithDecay). Returns whether it settles open.
+     * `velocityThreshold`: DrawerVelocityThreshold in px/s.
+     */
+    release(velocity: number, specs: DrawerSpecs, now: number, velocityThreshold?: number, confirm?: (open: boolean) => boolean): boolean;
+    /** Advances to `now` (ms). */
+    sample(now: number): DrawerSample;
+}
+
+/** TabRow.kt L461 / L608: `maxOf(contentWidth, 24.dp)` ("Enforce minimum touch target of 24.dp"). */
+declare const TAB_INDICATOR_MIN_WIDTH = 24;
+type TabRowVariant = 'primary' | 'secondary';
+/** What the caller measures per tab: its laid-out width and its content's width. */
+interface TabMeasure {
+    readonly width: number;
+    readonly contentWidth: number;
+}
+/** Compose `TabPosition`. */
+interface TabPosition {
+    readonly left: number;
+    readonly width: number;
+    readonly contentWidth: number;
+}
+/** The tabs' positions from `start` (a scrollable row's edge padding; 0 for a fixed row). */
+declare function tabPositions(tabs: readonly TabMeasure[], start?: number, minIndicatorWidth?: number): TabPosition[];
+/** The indicator's target: offset (the tab's left) and width (per variant). */
+declare function tabIndicatorTarget(position: TabPosition, variant: TabRowVariant): {
+    offset: number;
+    width: number;
+};
+/** One frame of the indicator. */
+interface TabIndicatorSample {
+    /** The animated offset (a tab's left edge). */
+    readonly offset: number;
+    readonly width: number;
+    readonly running: boolean;
+}
+/** TabIndicatorOffsetNode: the offset and width Animatables. */
+declare class TabIndicatorAnimation {
+    #private;
+    /** Starts at rest on the first layout's target (Compose: initialOffset / initialWidth). */
+    constructor(offset: number, width: number);
+    get offset(): SpringAnimatable;
+    get width(): SpringAnimatable;
+    get running(): boolean;
+    /**
+     * Retargets each Animatable whose target changed, from its value and velocity at `now`; a null
+     * spec (reduced motion) jumps.
+     */
+    animateTo(offset: number, width: number, spec: SpringSpec | null, now: number): void;
+    snapTo(offset: number, width: number): void;
+    sample(now: number): TabIndicatorSample;
+}
+/**
+ * The indicator's shift from where the selected tab draws it at rest (centred in the tab), in the
+ * row's logical direction: the centre is offset + tab width / 2 in both cases, so the shift is the
+ * animated offset less the tab's left.
+ */
+declare const tabIndicatorShift: (sample: {
+    offset: number;
+}, selected: TabPosition) => number;
+/**
+ * ScrollableTabData.calculateTabOffset: the scroll position centring `tab` (its left includes the
+ * edge padding) in a row `scrollWidth` wide (edge padding × 2 + the tabs) seen through
+ * `visibleWidth`, clamped to the scroll range.
+ */
+declare function scrollableTabOffset(tab: Pick<TabPosition, 'left' | 'width'>, scrollWidth: number, visibleWidth: number): number;
+/** animateScrollTo: a Float animation from the current scroll position, from rest. */
+declare class TabScrollAnimation {
+    readonly value: SpringAnimatable;
+    constructor(position: number);
+    /** Starts a new scroll from `from` (the scroll state's value), velocity 0. */
+    animateTo(from: number, target: number, spec: SpringSpec | null, now: number): void;
+}
+
+/** ThreePaneScaffoldRole. */
+type ThreePaneScaffoldRole = 'primary' | 'secondary' | 'tertiary';
+/** Roles in priority order (forEachPaneByPriority's tail, ThreePaneScaffoldValue.kt L187-189). */
+declare const THREE_PANE_SCAFFOLD_ROLES: readonly ThreePaneScaffoldRole[];
+/** AdaptStrategy.Hide, or AdaptStrategy.Reflow(reflowUnder). */
+type AdaptStrategy = 'hide' | {
+    readonly reflowUnder: ThreePaneScaffoldRole;
+};
+type ThreePaneScaffoldAdaptStrategies = Readonly<Record<ThreePaneScaffoldRole, AdaptStrategy>>;
+/** ListDetailPaneScaffoldDefaults.adaptStrategies() (L208-217): every pane hides. */
+declare const LIST_DETAIL_ADAPT_STRATEGIES: ThreePaneScaffoldAdaptStrategies;
+/**
+ * SupportingPaneScaffoldDefaults.adaptStrategies() (L190-200): the supporting pane reflows under
+ * the main pane; the others hide.
+ */
+declare const SUPPORTING_PANE_ADAPT_STRATEGIES: ThreePaneScaffoldAdaptStrategies;
+/** ListDetailPaneScaffoldRole (ListDetailPaneScaffold.kt L238-259). */
+declare const ListDetailPaneScaffoldRole: Readonly<{
+    readonly List: "secondary";
+    readonly Detail: "primary";
+    readonly Extra: "tertiary";
+}>;
+/** SupportingPaneScaffoldRole (SupportingPaneScaffold.kt L221-243). */
+declare const SupportingPaneScaffoldRole: Readonly<{
+    readonly Main: "primary";
+    readonly Supporting: "secondary";
+    readonly Extra: "tertiary";
+}>;
+/** Start-to-end order: list (secondary), detail (primary), extra (ListDetailPaneScaffold L224-229). */
+declare const LIST_DETAIL_PANE_ORDER: readonly ThreePaneScaffoldRole[];
+/** Start-to-end order: main, supporting, extra (SupportingPaneScaffold L207-212). */
+declare const SUPPORTING_PANE_ORDER: readonly ThreePaneScaffoldRole[];
+/** PaneAdaptedValue (Levitated is not ported). */
+type PaneAdaptedValue = 'expanded' | 'reflowed' | 'hidden';
+/** ThreePaneScaffoldValue. */
+interface ThreePaneScaffoldValue {
+    readonly primary: PaneAdaptedValue;
+    readonly secondary: PaneAdaptedValue;
+    readonly tertiary: PaneAdaptedValue;
+    /** The destination the value was calculated for (internal in Compose; not part of equality). */
+    readonly currentDestination: ThreePaneScaffoldRole | null;
+}
+/** ThreePaneScaffoldValue.equals (L260-267): the three adapted values. */
+declare function sameThreePaneScaffoldValue(a: ThreePaneScaffoldValue, b: ThreePaneScaffoldValue): boolean;
+/** ThreePaneScaffoldDestinationItem. */
+interface ThreePaneScaffoldDestinationItem<T = unknown> {
+    readonly pane: ThreePaneScaffoldRole;
+    readonly contentKey?: T | undefined;
+}
+/**
+ * calculateThreePaneScaffoldValue (ThreePaneScaffoldValue.kt L86-179): the last destination
+ * first, then the earlier ones (newest first), then primary, secondary, tertiary each take a free
+ * horizontal partition; with a single partition and `maxVerticalPartitions` ≥ 2, the first pane
+ * whose strategy is Reflow goes under its (expanded) anchor instead.
+ */
+declare function calculateThreePaneScaffoldValue(maxHorizontalPartitions: number, adaptStrategies: ThreePaneScaffoldAdaptStrategies, destinationHistory: readonly ThreePaneScaffoldDestinationItem[], maxVerticalPartitions?: number): ThreePaneScaffoldValue;
+/** The roles a value expands, in `order` (start to end). */
+declare function expandedPanes(value: ThreePaneScaffoldValue, order: readonly ThreePaneScaffoldRole[]): ThreePaneScaffoldRole[];
+/**
+ * How many panes may sit side by side: `recommended` (the default, owner decision 2026-10-18) =
+ * m3.material.io Breakpoints (1 / 1 / 2 / 2 / 3: two panes at large, three at extra-large), never
+ * more than Compose allows; `compose` = calculatePaneScaffoldDirective (1 / 1 / 2 / 3 / 3 by width
+ * class: three panes from large).
+ */
+type PaneRule = 'compose' | 'recommended';
+/** m3.material.io Foundations › Layout › Breakpoints, "recommended" pane counts (FOUNDATIONS §9). */
+declare const RECOMMENDED_MAX_PANES: Readonly<Record<WindowWidthSizeClass, number>>;
+interface ThreePaneScaffoldDirectiveOptions {
+    /** Default `recommended`; `compose` keeps calculatePaneScaffoldDirective's counts. */
+    paneRule?: PaneRule | undefined;
+    isTabletop?: boolean | undefined;
+}
+/**
+ * paneScaffoldDirective (calculatePaneScaffoldDirective) with the `paneRule` cap applied: capped by
+ * RECOMMENDED_MAX_PANES unless `paneRule` is `compose`.
+ */
+declare function threePaneScaffoldDirective(sizeClass: WindowSizeClass, options?: ThreePaneScaffoldDirectiveOptions): PaneScaffoldDirective;
+/** BackNavigationBehavior (BackNavigationBehavior.kt L40-75). */
+type BackNavigationBehavior = 'pop-latest' | 'pop-until-scaffold-value-change' | 'pop-until-current-destination-change' | 'pop-until-content-change';
+interface ThreePaneScaffoldNavigatorOptions<T> {
+    scaffoldDirective: PaneScaffoldDirective;
+    adaptStrategies: ThreePaneScaffoldAdaptStrategies;
+    /** Default `true` (rememberListDetailPaneScaffoldNavigator). */
+    isDestinationHistoryAware?: boolean | undefined;
+    /** Default: the list pane (list-detail) or main pane (supporting pane); see the defaults below. */
+    initialDestinationHistory: readonly ThreePaneScaffoldDestinationItem<T>[];
+}
+/** DefaultListDetailPaneHistory (ThreePaneScaffoldNavigator.kt L536-537): the list. */
+declare const LIST_DETAIL_INITIAL_HISTORY: readonly ThreePaneScaffoldDestinationItem<never>[];
+/** DefaultSupportingPaneHistory (L540-541): the main pane. */
+declare const SUPPORTING_PANE_INITIAL_HISTORY: readonly ThreePaneScaffoldDestinationItem<never>[];
+/**
+ * DefaultThreePaneScaffoldNavigator (ThreePaneScaffoldNavigator.kt L359-490) without Compose's
+ * transition state: navigateTo / navigateBack change the history and the value at once; the
+ * caller animates (and Compose's directive change snaps, L349-354: so does setting
+ * `scaffoldDirective` here). Content keys compare with Object.is (Kotlin `equals` for data
+ * classes: use primitives or shared objects).
+ */
+declare class ThreePaneScaffoldNavigator<T = unknown> {
+    #private;
+    constructor(options: ThreePaneScaffoldNavigatorOptions<T>);
+    get scaffoldDirective(): PaneScaffoldDirective;
+    set scaffoldDirective(directive: PaneScaffoldDirective);
+    get adaptStrategies(): ThreePaneScaffoldAdaptStrategies;
+    set adaptStrategies(strategies: ThreePaneScaffoldAdaptStrategies);
+    get isDestinationHistoryAware(): boolean;
+    set isDestinationHistoryAware(aware: boolean);
+    /** The destination history, oldest first. */
+    get destinationHistory(): readonly ThreePaneScaffoldDestinationItem<T>[];
+    get currentDestination(): ThreePaneScaffoldDestinationItem<T> | null;
+    get scaffoldValue(): ThreePaneScaffoldValue;
+    /** Calls `listener` after every change of the history or the value; returns the unsubscriber. */
+    subscribe(listener: () => void): () => void;
+    peekPreviousScaffoldValue(behavior?: BackNavigationBehavior): ThreePaneScaffoldValue;
+    navigateTo(pane: ThreePaneScaffoldRole, contentKey?: T): void;
+    canNavigateBack(behavior?: BackNavigationBehavior): boolean;
+    /** Returns true when there was a destination to go back to (else the history is cleared). */
+    navigateBack(behavior?: BackNavigationBehavior): boolean;
+}
+/** A pane's bounds in the scaffold, CSS px, physical (x from the left edge). */
+interface PaneRect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+/** PaneExpansionState as the layout reads it (all CSS px). */
+interface PaneExpansionLayout {
+    /** currentDraggingOffset: the handle's centre while dragging or settling. */
+    readonly draggingOffset?: number | undefined;
+    /** firstPaneWidth: a resting split (set from an anchor or a released drag). */
+    readonly firstPaneWidth?: number | undefined;
+}
+interface ThreePaneScaffoldLayoutInput {
+    readonly width: number;
+    readonly height: number;
+    readonly directive: PaneScaffoldDirective;
+    readonly value: ThreePaneScaffoldValue;
+    /** Start to end, already mirrored for RTL (physical left to right). */
+    readonly order: readonly ThreePaneScaffoldRole[];
+    readonly adaptStrategies: ThreePaneScaffoldAdaptStrategies;
+    /** Panes that exist (a scaffold without an extra pane has no tertiary pane). Default: all. */
+    readonly present?: readonly ThreePaneScaffoldRole[] | undefined;
+    /** PaneScaffoldScope.preferredWidth per pane (px); default the directive's. */
+    readonly preferredWidths?: Partial<Record<ThreePaneScaffoldRole, number>> | undefined;
+    /** PaneScaffoldScope.preferredHeight per pane (px); default the directive's. */
+    readonly preferredHeights?: Partial<Record<ThreePaneScaffoldRole, number>> | undefined;
+    readonly expansion?: PaneExpansionLayout | undefined;
+}
+interface ThreePaneScaffoldLayout {
+    /** Bounds of the expanded and reflowed panes (a collapsed pane of a split has width 0). */
+    readonly panes: Partial<Record<ThreePaneScaffoldRole, PaneRect>>;
+    /** The drag handle's centre x when exactly two panes are expanded, else null. */
+    readonly handleOffset: number | null;
+}
+/** ThreePaneContentMeasurePolicy.measure (ThreePaneScaffold.kt L256-594), no hinges. */
+declare function threePaneScaffoldLayout(input: ThreePaneScaffoldLayoutInput): ThreePaneScaffoldLayout;
+/** PaneMotion (PaneMotion.kt L556-632; EnterAsModal / ExitAsModal belong to Levitate). */
+type PaneMotion = 'none' | 'animate-bounds' | 'enter-from-left' | 'enter-from-right' | 'enter-from-left-delayed' | 'enter-from-right-delayed' | 'exit-to-left' | 'exit-to-right' | 'enter-with-expand' | 'exit-with-shrink';
+/** calculatePaneMotion (PaneMotion.kt L636-750) for the panes in `order` (physical, LTR). */
+declare function calculatePaneMotion(previous: ThreePaneScaffoldValue, current: ThreePaneScaffoldValue, order: readonly ThreePaneScaffoldRole[]): Record<ThreePaneScaffoldRole, PaneMotion>;
+/** Where each pane animates from and to for a motion (the default enter / exit transitions). */
+interface PaneTransition {
+    readonly motion: PaneMotion;
+    readonly from: PaneRect;
+    readonly to: PaneRect;
+    /** EnterFrom*Delayed: DelayedSpringSpec's delayedRatio (PaneMotionDefaults L167-173). */
+    readonly delayed: boolean;
+}
+/** PaneMotionDefaults.DelayedAnimationSpec's delayedRatio (PaneMotion.kt L171). */
+declare const PANE_MOTION_DELAYED_RATIO = 0.1;
+/**
+ * calculateDefaultEnterTransition / calculateDefaultExitTransition (PaneMotion.kt L425-476) with
+ * the slide offsets (L276-414): `origin` holds the bounds before the change (the panes shown
+ * then), `target` the bounds after it, both from threePaneScaffoldLayout. Entering panes slide (or
+ * expand) from outside to `target`; exiting panes slide (or shrink) from `origin` out; panes shown
+ * before and after animate their bounds.
+ */
+declare function paneTransitions(motions: Readonly<Record<ThreePaneScaffoldRole, PaneMotion>>, order: readonly ThreePaneScaffoldRole[], origin: Partial<Record<ThreePaneScaffoldRole, PaneRect>>, target: Partial<Record<ThreePaneScaffoldRole, PaneRect>>, scaffoldWidth: number): Partial<Record<ThreePaneScaffoldRole, PaneTransition>>;
+/** PaneExpansionAnchor: Proportion, Offset.fromStart or Offset.fromEnd (px). */
+type PaneExpansionAnchor = {
+    readonly proportion: number;
+} | {
+    readonly offsetFromStart: number;
+} | {
+    readonly offsetFromEnd: number;
+};
+/**
+ * The samples' anchors (ThreePaneScaffoldSample.kt L1102-1109): 0 %, 240dp from the start, 50 %,
+ * 240dp from the end, 100 %. Compose's own default is no anchors.
+ */
+declare const PANE_EXPANSION_SAMPLE_ANCHORS: readonly PaneExpansionAnchor[];
+/** PaneExpansionState.AnchoringVelocityThreshold (px/s, L648). */
+declare const PANE_EXPANSION_ANCHORING_VELOCITY_THRESHOLD = 200;
+/** PaneExpansionAnchor.positionIn (L700-712, L754-755, L835-856): the handle's centre x. */
+declare function paneExpansionAnchorPosition(anchor: PaneExpansionAnchor, width: number, rtl?: boolean): number;
+/**
+ * The anchor a release settles to (getPositionOfTheClosestAnchor, L610-646): the closest one, or
+ * with |velocity| ≥ 200 px/s the closest in the direction of the fling (the closest overall when
+ * none lies that way). Returns the index into `anchors`, or -1 without anchors. Compose first runs
+ * the fling's decay and settles from where it stops; this picks from the release position.
+ */
+declare function closestPaneExpansionAnchor(anchors: readonly PaneExpansionAnchor[], width: number, position: number, velocity: number, rtl?: boolean): number;
+/**
+ * PaneExpansionState.nextAnchor (L345-366): the first anchor (by position) right of `position`,
+ * wrapping to the leftmost. The drag handle's click action moves there. -1 without anchors.
+ */
+declare function nextPaneExpansionAnchor(anchors: readonly PaneExpansionAnchor[], width: number, position: number, rtl?: boolean): number;
+/** PaneMotionDefaults' IntRect / IntOffset visibility threshold (PaneMotion.kt L148): 1px. */
+declare const PANE_MOTION_VISIBILITY_THRESHOLD = 1;
+interface ThreePaneScaffoldSample {
+    /** The animated bounds of every pane in the transition (entering, shown, exiting). */
+    readonly panes: Partial<Record<ThreePaneScaffoldRole, PaneRect>>;
+    readonly running: boolean;
+}
+/**
+ * The pane transitions of one scaffold change, driven by the caller's clock (ms): each pane's
+ * bounds run on PaneMotionDefaults.AnimationSpec (spring 0.8 / 380 at a 1px threshold, each
+ * component on its own, as Compose's IntRect / IntOffset springs), EnterFrom*Delayed after 10 % of
+ * that spring's duration (DelayedSpringSpec, PaneMotion.kt L822-908). A new `start` mid-flight
+ * continues every pane still in the transition from its current bounds and velocity. `spec` null
+ * (reduced motion) jumps to the end.
+ */
+declare class ThreePaneScaffoldAnimation {
+    #private;
+    start(transitions: Partial<Record<ThreePaneScaffoldRole, PaneTransition>>, spec: SpringSpec | null, now: number): void;
+    /** Jumps every pane to its target. */
+    finish(): void;
+    sample(now: number): ThreePaneScaffoldSample;
+}
+
+export { type AdaptStrategy, AmplitudeAnimation, type AmplitudeTween, type AppBarScrollBehavior, type AppBarScrollState, type BackNavigationBehavior, type ButtonGroupItemSize, type CircularIndeterminateFrame, type CircularIndeterminateTiming, DEFAULT_DISPLACEMENT_THRESHOLD, DRAWER_POSITIONAL_THRESHOLD, DRAWER_SETTLE_MILLIS, DRAWER_VELOCITY_THRESHOLD, DrawerAnimation, type DrawerSample, type DrawerSpecs, type Easing, FAST_OUT_LINEAR_IN_EASING, type FloatingToolbarExitDirection, type FloatingToolbarScrollState, type IndeterminateFrame, LIST_DETAIL_ADAPT_STRATEGIES, LIST_DETAIL_INITIAL_HISTORY, LIST_DETAIL_PANE_ORDER, type LinearEasing, type LinearEasingOptions, type LinearIndeterminateTiming, ListDetailPaneScaffoldRole, type LoadingIndicatorTiming, MODAL_RAIL_EXPANDED_PROGRESS, type MenuAnchorPosition, type MenuPositionInput, type MenuPositionResult, type MenuRect, type Motion, NAVIGATION_SUITE_EXPANDED_FROM, NAVIGATION_SUITE_TYPES, type NavigationSuiteSample, NavigationSuiteScaffoldAnimation, type NavigationSuiteType, type NavigationSuiteTypeOptions, PANE_EXPANSION_ANCHORING_VELOCITY_THRESHOLD, PANE_EXPANSION_SAMPLE_ANCHORS, PANE_MOTION_DELAYED_RATIO, PANE_MOTION_VISIBILITY_THRESHOLD, type PaneAdaptedValue, type PaneExpansionAnchor, type PaneExpansionLayout, type PaneMotion, type PaneRect, type PaneRule, type PaneScaffoldDirective, type PaneTransition, RECOMMENDED_MAX_PANES, SEARCH_BAR_EXPANDED_THRESHOLD, SEARCH_DROPDOWN_VISIBLE_PROGRESS, SUPPORTING_PANE_ADAPT_STRATEGIES, SUPPORTING_PANE_INITIAL_HISTORY, SUPPORTING_PANE_ORDER, SearchBarAnimation, type SearchBarSample, type SearchBarSpecs, type SearchRect, type SearchViewFrame, type SearchViewInput, type SearchViewMetrics, type SearchViewVariant, SpringAnimatable, SpringSimulation, type SpringSpec, SupportingPaneScaffoldRole, TAB_INDICATOR_MIN_WIDTH, THREE_PANE_SCAFFOLD_ROLES, TOP_TITLE_ALPHA_EASING, TabIndicatorAnimation, type TabIndicatorSample, type TabMeasure, type TabPosition, type TabRowVariant, TabScrollAnimation, type ThreePaneScaffoldAdaptStrategies, ThreePaneScaffoldAnimation, type ThreePaneScaffoldDestinationItem, type ThreePaneScaffoldDirectiveOptions, type ThreePaneScaffoldLayout, type ThreePaneScaffoldLayoutInput, ThreePaneScaffoldNavigator, type ThreePaneScaffoldNavigatorOptions, type ThreePaneScaffoldRole, type ThreePaneScaffoldSample, type ThreePaneScaffoldValue, type ToolbarExpansionScroll, type ToolbarOrientation, TweenAnimatable, type TweenSpec, type TwoRowsFrame, WINDOW_HEIGHT_BREAKPOINTS, WINDOW_WIDTH_BREAKPOINTS, WideNavigationRailAnimation, type WideNavigationRailAnimationOptions, type WideNavigationRailMetrics, type WideNavigationRailSample, type WideNavigationRailSpecs, type WideNavigationRailWidthInput, type WindowHeightSizeClass, type WindowPostureOptions, type WindowSizeClass, type WindowSizeClassOptions, type WindowWidthSizeClass, animatedInt, appBarScrollState, buttonGroupVisibleCount, buttonGroupWidths, calculatePaneMotion, calculateThreePaneScaffoldValue, circularIndeterminateFrame, closestPaneExpansionAnchor, collapsedFraction, cubicBezier, dampingCoefficient, dampingRatioFromCoefficient, drawerSettlesOpen, estimateAnimationDurationMillis, estimateAnimationDurationMillisDouble, expandedPanes, exponentialDecayTarget, fabMenuItemVisible, floatingToolbarScrollState, indeterminateFrame, indicatorAmplitude, initialIndeterminateFrame, isAtLeastBreakpoint, isHeightAtLeastBreakpoint, isNavigationBarType, isScrolledUnder, isWidthAtLeastBreakpoint, linearIndeterminateFractions, menuNavigationTarget, menuPosition, menuTransformOrigin, morphSpringDurationMillis, navigationSuiteOffset, navigationSuiteType, nextPaneExpansionAnchor, overlappedFraction, paneExpansionAnchorPosition, paneScaffoldDirective, paneTransitions, parseCubicBezier, sameThreePaneScaffoldValue, sameWindowSizeClass, scrollAppBar, scrollFloatingToolbar, scrollToolbarExpansion, scrollableTabOffset, searchNavigationTarget, searchViewFrame, settleTarget, springDurationMillis, springToLinear, springValue, springVelocity, tabIndicatorShift, tabIndicatorTarget, tabPositions, threePaneScaffoldDirective, threePaneScaffoldLayout, toolbarCollapsedFraction, toolbarExpansionScroll, toolbarNavigationTarget, toolbarSettleTarget, twoRowsFrame, waveOffset, waveTravelMillis, wideNavigationRailItemWidth, wideNavigationRailWidth, windowHeightSizeClass, windowSizeClass, windowWidthSizeClass, withHeight, withHeightOffset, withToolbarOffset, withToolbarOffsetLimit };