@kyralabs/m3e-motion 1.4.0 → 1.6.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,12 +76,22 @@ declare const fabMenuItemVisible: (index: number, itemCount: number, stagger: nu
  */
 declare function menuNavigationTarget(key: string, count: number, current: number): number | null;
 
+/** React Aria useTypeSelect clears the typed string after this long (TYPEAHEAD_DEBOUNCE_WAIT_MS). */
+declare const TYPEAHEAD_TIMEOUT_MS = 1000;
+/**
+ * Index of the first item in `texts` that starts with `search`, from `from` (the focused item,
+ * −1: none) to the end, then from the start; −1 when none does.
+ */
+declare function typeSelectTarget(texts: readonly string[], from: number, search: string): number;
+
 type ToolbarOrientation = 'horizontal' | 'vertical';
+/** A toolbar orientation, or `both`: both arrow key pairs move along the one item order. */
+type NavigationOrientation = ToolbarOrientation | 'both';
 /**
  * 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).
+ * null when the key does not navigate. At either end the index stays put unless `wrap`.
  */
-declare function toolbarNavigationTarget(key: string, count: number, current: number, orientation?: ToolbarOrientation, rtl?: boolean): number | null;
+declare function toolbarNavigationTarget(key: string, count: number, current: number, orientation?: NavigationOrientation, rtl?: boolean, wrap?: boolean): number | null;
 
 /** Where a floating toolbar leaves the screen (FloatingToolbarExitDirection), logical. */
 type FloatingToolbarExitDirection = 'bottom' | 'top' | 'start' | 'end';
@@ -591,4 +602,752 @@ declare function buttonGroupVisibleCount(widths: readonly number[], spacing: num
  */
 declare function buttonGroupWidths(items: readonly ButtonGroupItemSize[], pressed: readonly number[], expandedRatio: number, visibleCount?: number): number[];
 
-export { AmplitudeAnimation, type AmplitudeTween, type AppBarScrollBehavior, type AppBarScrollState, type ButtonGroupItemSize, type CircularIndeterminateFrame, type CircularIndeterminateTiming, DEFAULT_DISPLACEMENT_THRESHOLD, type Easing, FAST_OUT_LINEAR_IN_EASING, type FloatingToolbarExitDirection, type FloatingToolbarScrollState, type IndeterminateFrame, type LinearEasing, type LinearEasingOptions, type LinearIndeterminateTiming, type LoadingIndicatorTiming, type MenuAnchorPosition, type MenuPositionInput, type MenuPositionResult, type MenuRect, type Motion, SEARCH_BAR_EXPANDED_THRESHOLD, SEARCH_DROPDOWN_VISIBLE_PROGRESS, SearchBarAnimation, type SearchBarSample, type SearchBarSpecs, type SearchRect, type SearchViewFrame, type SearchViewInput, type SearchViewMetrics, type SearchViewVariant, SpringAnimatable, SpringSimulation, type SpringSpec, TOP_TITLE_ALPHA_EASING, type ToolbarExpansionScroll, type ToolbarOrientation, TweenAnimatable, type TweenSpec, type TwoRowsFrame, animatedInt, appBarScrollState, buttonGroupVisibleCount, buttonGroupWidths, circularIndeterminateFrame, collapsedFraction, cubicBezier, dampingCoefficient, dampingRatioFromCoefficient, estimateAnimationDurationMillis, estimateAnimationDurationMillisDouble, fabMenuItemVisible, floatingToolbarScrollState, indeterminateFrame, indicatorAmplitude, initialIndeterminateFrame, isScrolledUnder, linearIndeterminateFractions, menuNavigationTarget, menuPosition, menuTransformOrigin, morphSpringDurationMillis, overlappedFraction, parseCubicBezier, scrollAppBar, scrollFloatingToolbar, scrollToolbarExpansion, searchNavigationTarget, searchViewFrame, settleTarget, springDurationMillis, springToLinear, springValue, springVelocity, toolbarCollapsedFraction, toolbarExpansionScroll, toolbarNavigationTarget, toolbarSettleTarget, twoRowsFrame, waveOffset, waveTravelMillis, withHeight, withHeightOffset, withToolbarOffset, withToolbarOffsetLimit };
+/** 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;
+}
+
+/** No `steps`: a key moves 1 % of the range (slideOnKeyEvents: `if (steps > 0) steps + 1 else 100`). */
+declare const SLIDER_KEY_DIVISIONS = 100;
+/** PageUp / PageDown: `(actualSteps / 10).coerceIn(1, 10)` steps. */
+declare const SLIDER_PAGE_DIVISOR = 10;
+declare const SLIDER_PAGE_MAX_STEPS = 10;
+/**
+ * Compose `steps` for a web `step` (a value increment; 0, negative or absent = continuous):
+ * the stops between the ends, `round((max − min) / step) − 1`, at least 0. A `step` that does not
+ * divide the range gives evenly spaced ticks the nearest to it.
+ */
+declare function sliderSteps(min: number, max: number, step?: number): number;
+/** stepsToTickFractions: `steps + 2` fractions i / (steps + 1); none without steps. */
+declare function sliderTickFractions(steps: number): number[];
+/** calcFraction: the 0..1 fraction `value` is of min..max (0 for an empty range). */
+declare function sliderFraction(value: number, min: number, max: number): number;
+/** The value at `fraction` of min..max. */
+declare const sliderValueAt: (fraction: number, min: number, max: number) => number;
+/** snapValueToTick in value space: the nearest tick value (the first of equals), or `value`. */
+declare function sliderSnap(value: number, steps: number, min: number, max: number): number;
+/** The bounds of one thumb: the track, or for a range thumb up to / from the other thumb. */
+interface SliderThumbBounds {
+    readonly min: number;
+    readonly max: number;
+}
+/**
+ * The value a thumb takes for a requested `value`: coerced into its bounds, then snapped to the
+ * nearest tick of the whole track (SliderState.value / RangeSliderState.startValue / endValue).
+ */
+declare function sliderThumbValue(value: number, bounds: SliderThumbBounds, steps: number, min: number, max: number): number;
+/** The bounds of thumb `index` among `values` (one thumb, or a range's start and end). */
+declare function sliderThumbBounds(values: readonly number[], index: number, min: number, max: number): SliderThumbBounds;
+/** One key step: `rangeLength / actualSteps`. */
+declare function sliderKeyDelta(steps: number, min: number, max: number): number;
+/** PageUp / PageDown: how many key steps a page is. */
+declare function sliderPageSteps(steps: number): number;
+type SliderKeyAction = 'increment' | 'decrement' | 'page-increment' | 'page-decrement' | 'min' | 'max';
+interface SliderKeyOptions {
+    readonly vertical?: boolean;
+    /** Right-to-left layout: the horizontal arrows swap (Compose `sign = -1`). */
+    readonly rtl?: boolean;
+    /** Shift held: an arrow moves a page (m3.material.io "a larger interval"; React Aria). */
+    readonly shiftKey?: boolean;
+}
+/**
+ * What a key does. Compose: ArrowRight / ArrowLeft on a horizontal slider (swapped in RTL),
+ * ArrowUp / ArrowDown on a vertical one (minimum at the bottom: up increases, owner decision
+ * M8 #21), PageUp / PageDown, Home / End. The web adds the other arrow pair per the ARIA slider
+ * pattern (Up / Right increase) and Shift + arrow for a page (m3.material.io keyboard table);
+ * Compose ignores them. Other keys: null.
+ */
+declare function sliderKeyAction(key: string, options?: SliderKeyOptions): SliderKeyAction | null;
+/**
+ * The value a key action gives thumb `index` (the result is coerced into the thumb's bounds and
+ * snapped). Home / End go to the thumb's bounds: a range start thumb's End meets the end thumb.
+ */
+declare function sliderKeyValue(action: SliderKeyAction, values: readonly number[], index: number, steps: number, min: number, max: number): number;
+/**
+ * The range thumb a press at `value` moves (RangeSliderLogic): the closer one; when both are as
+ * close, the start thumb if it lies after the pointer (stacked thumbs pressed before them), else
+ * the end thumb.
+ */
+declare function sliderClosestThumb(values: readonly number[], value: number): number;
+/** Input of `sliderTrackGeometry` (one axis; slider.css mirrors it for RTL and vertical). */
+interface SliderTrackInput {
+    /** Track length: the slider's length less the thumb width. */
+    readonly length: number;
+    /** Outer corner size (the default Track: thickness / 2). */
+    readonly cornerSize: number;
+    /** TrackInsideCornerSize. */
+    readonly insideCornerSize: number;
+    /** ThumbWidth (the thumb's layout size along the track; its handle may be narrower). */
+    readonly thumbWidth: number;
+    /** ThumbTrackGapSize. */
+    readonly gapSize: number;
+    readonly steps: number;
+    /** The single thumb's fraction, or the range end's. */
+    readonly fraction: number;
+    /** A range's start fraction. */
+    readonly startFraction?: number;
+    readonly centered?: boolean;
+    /** Track(trackCornerSize) and CenteredTrack shrink corners; the default Track does not. */
+    readonly cornerShrinking?: boolean;
+    /** Stop indicators drawn (SliderWithTrackIconsSample passes null). Default true. */
+    readonly stopIndicator?: boolean;
+}
+type SliderTrackPartKind = 'inactive-start' | 'active' | 'inactive-end';
+interface SliderTrackPart {
+    readonly kind: SliderTrackPartKind;
+    readonly start: number;
+    readonly end: number;
+    readonly startRadius: number;
+    readonly endRadius: number;
+}
+interface SliderTick {
+    readonly position: number;
+    readonly active: boolean;
+}
+interface SliderTrackGeometry {
+    /** Thumb centres along the track (one, or a range's start and end). */
+    readonly thumbs: readonly number[];
+    readonly parts: readonly SliderTrackPart[];
+    /** Stop indicator centres. */
+    readonly stops: readonly number[];
+    readonly ticks: readonly SliderTick[];
+}
+/**
+ * SliderImpl's thumb placement and drawTrack (LTR, horizontal), in track coordinates: with steps,
+ * a value off the first and last tick sits between the corners
+ * ((length − 2 × corner) × fraction + corner), else length × fraction.
+ */
+declare function sliderTrackGeometry(input: SliderTrackInput): SliderTrackGeometry;
+
+/** 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 NavigationOrientation, 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, SLIDER_KEY_DIVISIONS, SLIDER_PAGE_DIVISOR, SLIDER_PAGE_MAX_STEPS, 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, type SliderKeyAction, type SliderKeyOptions, type SliderThumbBounds, type SliderTick, type SliderTrackGeometry, type SliderTrackInput, type SliderTrackPart, type SliderTrackPartKind, SpringAnimatable, SpringSimulation, type SpringSpec, SupportingPaneScaffoldRole, TAB_INDICATOR_MIN_WIDTH, THREE_PANE_SCAFFOLD_ROLES, TOP_TITLE_ALPHA_EASING, TYPEAHEAD_TIMEOUT_MS, 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, sliderClosestThumb, sliderFraction, sliderKeyAction, sliderKeyDelta, sliderKeyValue, sliderPageSteps, sliderSnap, sliderSteps, sliderThumbBounds, sliderThumbValue, sliderTickFractions, sliderTrackGeometry, sliderValueAt, springDurationMillis, springToLinear, springValue, springVelocity, tabIndicatorShift, tabIndicatorTarget, tabPositions, threePaneScaffoldDirective, threePaneScaffoldLayout, toolbarCollapsedFraction, toolbarExpansionScroll, toolbarNavigationTarget, toolbarSettleTarget, twoRowsFrame, typeSelectTarget, waveOffset, waveTravelMillis, wideNavigationRailItemWidth, wideNavigationRailWidth, windowHeightSizeClass, windowSizeClass, windowWidthSizeClass, withHeight, withHeightOffset, withToolbarOffset, withToolbarOffsetLimit };