react-ui-animate 5.2.0-next.6 → 5.3.0-next.0

package/dist/index.d.ts

@@ -1,5 +1,651 @@
-export { combine, Easing, makeMotion as makeAnimated, motion as animate, } from '@raidipesh78/re-motion';
-export * from './animation';
-export * from './hooks';
-export * from './gestures/hooks';
-export * from './utils';
+import * as react from 'react';
+import { RefObject, AllHTMLAttributes, SVGAttributes, CSSProperties, ReactNode, ReactElement, DependencyList } from 'react';
+
+interface AnimateController {
+    start(): void;
+    pause(): void;
+    resume(): void;
+    cancel(): void;
+    reset(): void;
+    setOnComplete?(fn: () => void): void;
+}
+interface AnimateHooks {
+    onStart?(): void;
+    onPause?(): void;
+    onResume?(): void;
+    onComplete?(): void;
+}
+
+type Primitive = number | string;
+type ExtrapolateType = 'identity' | 'extend' | 'clamp';
+interface ExtrapolateConfig {
+    extrapolate?: ExtrapolateType;
+    extrapolateRight?: ExtrapolateType;
+    extrapolateLeft?: ExtrapolateType;
+    easing?: (t: number) => number;
+}
+interface Callbacks {
+    onStart?: () => void;
+    onChange?: (v: number) => void;
+    onComplete?: () => void;
+}
+interface SpringOptions$1 {
+    stiffness?: number;
+    damping?: number;
+    mass?: number;
+    from?: number;
+}
+interface TimingOptions$1 {
+    duration?: number;
+    easing?: (t: number) => number;
+    from?: number;
+}
+interface DecayOptions$1 {
+    velocity?: number;
+    clamp?: [number, number];
+    elastic?: boolean | number;
+}
+interface SequenceOptions {
+    animations?: Descriptor[];
+}
+interface DelayOptions {
+    delay?: number;
+}
+interface LoopOptions {
+    iterations?: number;
+    animation?: Descriptor;
+}
+type DriverType = 'spring' | 'timing' | 'decay' | 'delay' | 'sequence' | 'loop';
+interface Descriptor {
+    type: DriverType;
+    to?: Primitive | Primitive[] | Record<string, Primitive>;
+    options?: SpringOptions$1 & TimingOptions$1 & DecayOptions$1 & SequenceOptions & DelayOptions & LoopOptions & Callbacks;
+}
+interface Controls {
+    start(): void;
+    pause(): void;
+    resume(): void;
+    cancel(): void;
+    reset(): void;
+}
+
+type Subscriber<T> = (value: T) => void;
+declare class AnimateValue<T = number> {
+    private subscribers;
+    private _current;
+    private _initial;
+    private controller?;
+    constructor(initial: T);
+    get current(): T;
+    get initial(): T;
+    set(value: T): void;
+    /**
+     * @internal only use internally
+     */
+    _internalSet(value: T): void;
+    subscribe(fn: Subscriber<T>): () => void;
+    reset(): void;
+    destroy(): void;
+    to<U>(mapperFn: (value: T) => U): AnimateValue<U>;
+    to(inRange: number[], outRange: (number | string)[], config?: ExtrapolateConfig): AnimateValue<number | string>;
+    setAnimationController(controller: AnimateController): void;
+    getAnimationController(): AnimateController | undefined;
+}
+declare function isAnimateValue(value: any): value is AnimateValue<any>;
+
+declare const transformKeys: readonly ["translateX", "translateY", "translateZ", "rotate", "rotateX", "rotateY", "rotateZ", "scale", "scaleX", "scaleY", "skewX", "skewY", "perspective"];
+
+interface UseInViewOptions extends IntersectionObserverInit {
+    once?: boolean;
+}
+declare function useInView(ref: RefObject<Element>, options?: UseInViewOptions): boolean;
+
+type AnimateValueCompatible = AnimateValue<number> | AnimateValue<string> | AnimateValue<number | string>;
+type CSSPropertiesWithoutTransforms = Omit<CSSProperties, (typeof transformKeys)[number]>;
+type AnimateStyle = {
+    [K in keyof CSSPropertiesWithoutTransforms]?: CSSPropertiesWithoutTransforms[K] | AnimateValueCompatible;
+} & {
+    [key in (typeof transformKeys)[number]]?: AnimateValueCompatible | number | string;
+};
+type AnimateHTMLAttributes<T> = {
+    [K in keyof AllHTMLAttributes<T>]?: AllHTMLAttributes<T>[K] | AnimateValueCompatible;
+};
+type AnimateSVGAttributes<T> = {
+    [K in keyof SVGAttributes<T>]?: SVGAttributes<T>[K] | AnimateValueCompatible;
+};
+type AnimateProp = {
+    [K in keyof AnimateStyle]?: Descriptor | Primitive;
+};
+type AnimateAttributes<T extends EventTarget> = Omit<AnimateHTMLAttributes<T> & AnimateSVGAttributes<T>, 'style' | 'animate' | 'exit' | 'hover' | 'press' | 'focus' | 'view' | 'viewOptions'> & {
+    style?: AnimateStyle;
+    /**
+     * Declarative animations to run when the component mounts or updates.
+     */
+    animate?: AnimateProp;
+    /**
+     * Declarative animations to run when the component exits (inside AnimatePresence).
+     */
+    exit?: AnimateProp;
+    /**
+     * Animations or styles to apply when the element is hovered.
+     */
+    hover?: AnimateProp;
+    /**
+     * Animations or styles to apply when the element is pressed (mouse down or touch start).
+     */
+    press?: AnimateProp;
+    /**
+     * Animations or styles to apply when the element is focused.
+     */
+    focus?: AnimateProp;
+    /**
+     * Animations or styles to apply when the element enters the viewport.
+     */
+    view?: AnimateProp;
+    /**
+     * Options for the IntersectionObserver used by view animations.
+     */
+    viewOptions?: UseInViewOptions;
+};
+
+declare function makeAnimated<Tag extends keyof JSX.IntrinsicElements>(tag: Tag): react.ForwardRefExoticComponent<Omit<AnimateHTMLAttributes<HTMLElement> & AnimateSVGAttributes<HTMLElement>, "style" | "animate" | "exit" | "hover" | "press" | "focus" | "view" | "viewOptions"> & {
+    style?: AnimateStyle;
+    animate?: AnimateProp;
+    exit?: AnimateProp;
+    hover?: AnimateProp;
+    press?: AnimateProp;
+    focus?: AnimateProp;
+    view?: AnimateProp;
+    viewOptions?: UseInViewOptions;
+} & react.RefAttributes<HTMLElement>>;
+
+declare const animate: { [K in keyof JSX.IntrinsicElements]: ReturnType<typeof makeAnimated<K>>; };
+
+interface TimingOptions extends AnimateHooks {
+    duration?: number;
+    easing?: (t: number) => number;
+    from?: number;
+    onChange?: (value: number) => void;
+}
+declare function timing(value: AnimateValue<number> | AnimateValue<string> | AnimateValue<number | string>, target: number | string, options?: TimingOptions): AnimateController;
+
+interface SpringOptions extends AnimateHooks {
+    stiffness?: number;
+    damping?: number;
+    mass?: number;
+    from?: number;
+    onChange?(value: number): void;
+}
+declare function spring(value: AnimateValue<number> | AnimateValue<string> | AnimateValue<number | string>, target: number | string, options?: SpringOptions): AnimateController;
+
+interface DecayOptions extends AnimateHooks {
+    decay?: number;
+    clamp?: [number, number];
+    elastic?: boolean | number;
+    onChange?(value: number): void;
+}
+declare class DecayController implements AnimateController {
+    private value;
+    private velocity;
+    private deceleration;
+    private hooks;
+    private startTime;
+    private from;
+    private frameId;
+    private position;
+    private readonly restSpeed;
+    private isPaused;
+    private isCancelled;
+    private pausedAt;
+    private clampBounds?;
+    private elasticConstant?;
+    constructor(value: AnimateValue<number>, velocity: number, deceleration: number, hooks: DecayOptions);
+    start(): void;
+    private animate;
+    pause(): void;
+    resume(): void;
+    cancel(): void;
+    reset(): void;
+    setOnComplete(fn: () => void): void;
+}
+declare function decay(value: AnimateValue<number>, velocity: number, options?: DecayOptions): DecayController;
+
+declare function parallel(controllers: AnimateController[], hooks?: AnimateHooks): AnimateController;
+declare function sequence(controllers: AnimateController[], hooks?: AnimateHooks): AnimateController;
+declare function loop(controller: AnimateController, iterations: number, hooks?: AnimateHooks): AnimateController;
+declare function delay(duration: number): AnimateController;
+
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+/**
+ * This class implements common easing functions. The math is pretty obscure,
+ * but this cool website has nice visual illustrations of what they represent:
+ * http://xaedes.de/dev/transitions/
+ */
+declare class Easing {
+    static step0(n: number): 1 | 0;
+    static step1(n: number): 1 | 0;
+    static linear(t: number): number;
+    static ease(t: number): number;
+    static quad(t: number): number;
+    static cubic(t: number): number;
+    static poly(n: number): (t: number) => number;
+    static sin(t: number): number;
+    static circle(t: number): number;
+    static exp(t: number): number;
+    /**
+     * A simple elastic interaction, similar to a spring.  Default bounciness
+     * is 1, which overshoots a little bit once.  0 bounciness doesn't overshoot
+     * at all, and bounciness of N > 1 will overshoot about N times.
+     *
+     * Wolfram Plots:
+     *
+     *   http://tiny.cc/elastic_b_1 (default bounciness = 1)
+     *   http://tiny.cc/elastic_b_3 (bounciness = 3)
+     */
+    static elastic(bounciness?: number): (t: number) => number;
+    static back(s: number): (t: number) => number;
+    static bounce(t: number): number;
+    static bezier(x1: number, y1: number, x2: number, y2: number): (t: number) => number;
+    static in(easing: (t: number) => number): (t: number) => number;
+    /**
+     * Runs an easing function backwards.
+     */
+    static out(easing: (t: number) => number): (t: number) => number;
+    /**
+     * Makes any easing function symmetrical.
+     */
+    static inOut(easing: (t: number) => number): (t: number) => number;
+}
+
+/**
+ * Combines multiple AnimateValue instances into a single AnimateValue
+ * using a combiner function.
+ */
+declare function combine<T extends any[], U>(inputs: {
+    [K in keyof T]: AnimateValue<T[K]>;
+}, combiner: (...values: T) => U): AnimateValue<U>;
+
+declare function to(input: number, inRange: number[], outRange: (number | string)[], config?: ExtrapolateConfig): number | string;
+
+declare const withSpring: (to: Descriptor["to"], opts?: SpringOptions$1 & Callbacks) => Descriptor;
+declare const withTiming: (to: Descriptor["to"], opts?: TimingOptions$1 & Callbacks) => Descriptor;
+declare const withDecay: (velocity: number, opts?: DecayOptions$1 & Callbacks) => Descriptor;
+declare const withDelay: (ms: number) => Descriptor;
+declare const withSequence: (animations: Descriptor[], opts?: Omit<Callbacks, "onChange">) => Descriptor;
+declare const withLoop: (animation: Descriptor, iterations?: number, opts?: Omit<Callbacks, "onChange">) => Descriptor;
+
+declare const Config: {
+    Timing: {
+        BOUNCE: {
+            duration: number;
+            easing: typeof Easing.bounce;
+        };
+        EASE_IN: {
+            duration: number;
+            easing: (t: number) => number;
+        };
+        EASE_OUT: {
+            duration: number;
+            easing: (t: number) => number;
+        };
+        EASE_IN_OUT: {
+            duration: number;
+            easing: (t: number) => number;
+        };
+        POWER1: {
+            duration: number;
+            easing: (t: number) => number;
+        };
+        POWER2: {
+            duration: number;
+            easing: (t: number) => number;
+        };
+        POWER3: {
+            duration: number;
+            easing: (t: number) => number;
+        };
+        POWER4: {
+            duration: number;
+            easing: (t: number) => number;
+        };
+        LINEAR: {
+            duration: number;
+            easing: typeof Easing.linear;
+        };
+    };
+    Spring: {
+        ELASTIC: {
+            mass: number;
+            damping: number;
+            stiffness: number;
+        };
+        EASE: {
+            mass: number;
+            damping: number;
+            stiffness: number;
+        };
+        STIFF: {
+            mass: number;
+            damping: number;
+            stiffness: number;
+        };
+        WOBBLE: {
+            mass: number;
+            damping: number;
+            stiffness: number;
+        };
+    };
+};
+
+type Widen<T> = T extends number ? number : T extends string ? string : T;
+type ValueReturn<T> = T extends Primitive ? AnimateValue<Widen<T>> : T extends Primitive[] ? AnimateValue<Widen<Primitive>>[] : {
+    [K in keyof T]: AnimateValue<Widen<T[K]>>;
+};
+type Base = Primitive | Primitive[] | Record<string, Primitive>;
+declare function useValue<T extends Base>(initial: T): [ValueReturn<T>, (to: Base | Descriptor) => void, Controls];
+
+interface PresenceProps {
+    /**
+     * Children to animate. Each direct child should have a unique `key` prop.
+     */
+    children?: ReactNode;
+    /**
+     * When true, the initial render will skip the enter animation.
+     * @default true
+     */
+    initial?: boolean;
+    /**
+     * Callback when all exiting nodes have completed animating out.
+     */
+    onExitComplete?: () => void;
+    /**
+     * When a new child enters, determines behavior of existing children.
+     * - "sync": (default) Exiting and entering children animate simultaneously.
+     * - "wait": Exiting children complete before entering children start.
+     * - "popLayout": Exiting children are removed from layout flow immediately.
+     */
+    mode?: 'sync' | 'wait' | 'popLayout';
+}
+interface PresenceContextValue {
+    /**
+     * Whether this is the initial mount (skip enter animation if Presence.initial=false)
+     */
+    isInitialMount: boolean;
+    /**
+     * Whether this element is exiting
+     */
+    isExiting: boolean;
+    /**
+     * Call this when exit animation completes to remove the element
+     */
+    onExitComplete: () => void;
+    /**
+     * Internal: Counter to force re-renders when exit state changes
+     */
+    _forceUpdate?: number;
+}
+declare const PresenceContext: react.Context<PresenceContextValue | null>;
+/**
+ * Hook to access presence state from within an animated component.
+ */
+declare function usePresence(): [boolean, () => void];
+/**
+ * Hook to check if this is the initial mount (for skipping initial animations).
+ */
+declare function useIsPresent(): boolean;
+/**
+ * Presence enables exit animations when children are removed from the tree.
+ *
+ * @example
+ * ```tsx
+ * <Presence>
+ *   {isVisible && (
+ *     <animate.div
+ *       key="modal"
+ *       style={{ opacity: 0 }}
+ *       animate={{ opacity: withTiming(1) }}
+ *       exit={{ opacity: withTiming(0) }}
+ *     />
+ *   )}
+ * </Presence>
+ * ```
+ */
+declare function Presence({ children, initial, onExitComplete, mode, }: PresenceProps): ReactElement;
+
+/**
+ * Animation Recipes - Pre-built, tested animations for common use cases
+ */
+declare const fadeIn: AnimateProp;
+declare const fadeOut: AnimateProp;
+declare const fadeInUp: AnimateProp;
+declare const fadeInDown: AnimateProp;
+declare const fadeInLeft: AnimateProp;
+declare const fadeInRight: AnimateProp;
+declare const slideInUp: AnimateProp;
+declare const slideInDown: AnimateProp;
+declare const slideInLeft: AnimateProp;
+declare const slideInRight: AnimateProp;
+declare const slideOutUp: AnimateProp;
+declare const slideOutDown: AnimateProp;
+declare const slideOutLeft: AnimateProp;
+declare const slideOutRight: AnimateProp;
+declare const scaleIn: AnimateProp;
+declare const scaleOut: AnimateProp;
+declare const scaleUp: AnimateProp;
+declare const scaleDown: AnimateProp;
+declare const bounceIn: AnimateProp;
+declare const bounceOut: AnimateProp;
+declare const rotateIn: AnimateProp;
+declare const rotateOut: AnimateProp;
+declare const spin: AnimateProp;
+declare const zoomIn: AnimateProp;
+declare const zoomOut: AnimateProp;
+declare const flipX: AnimateProp;
+declare const flipY: AnimateProp;
+declare const slideFadeIn: AnimateProp;
+declare const slideFadeOut: AnimateProp;
+declare const scaleFadeIn: AnimateProp;
+declare const scaleFadeOut: AnimateProp;
+declare const hoverScale: AnimateProp;
+declare const hoverLift: AnimateProp;
+declare const hoverGlow: AnimateProp;
+declare const pressScale: AnimateProp;
+declare const pressDown: AnimateProp;
+declare const exitFade: AnimateProp;
+declare const exitSlideUp: AnimateProp;
+declare const exitSlideDown: AnimateProp;
+declare const exitScale: AnimateProp;
+declare const recipes: {
+    readonly fadeIn: AnimateProp;
+    readonly fadeOut: AnimateProp;
+    readonly fadeInUp: AnimateProp;
+    readonly fadeInDown: AnimateProp;
+    readonly fadeInLeft: AnimateProp;
+    readonly fadeInRight: AnimateProp;
+    readonly slideInUp: AnimateProp;
+    readonly slideInDown: AnimateProp;
+    readonly slideInLeft: AnimateProp;
+    readonly slideInRight: AnimateProp;
+    readonly slideOutUp: AnimateProp;
+    readonly slideOutDown: AnimateProp;
+    readonly slideOutLeft: AnimateProp;
+    readonly slideOutRight: AnimateProp;
+    readonly scaleIn: AnimateProp;
+    readonly scaleOut: AnimateProp;
+    readonly scaleUp: AnimateProp;
+    readonly scaleDown: AnimateProp;
+    readonly bounceIn: AnimateProp;
+    readonly bounceOut: AnimateProp;
+    readonly rotateIn: AnimateProp;
+    readonly rotateOut: AnimateProp;
+    readonly spin: AnimateProp;
+    readonly zoomIn: AnimateProp;
+    readonly zoomOut: AnimateProp;
+    readonly flipX: AnimateProp;
+    readonly flipY: AnimateProp;
+    readonly slideFadeIn: AnimateProp;
+    readonly slideFadeOut: AnimateProp;
+    readonly scaleFadeIn: AnimateProp;
+    readonly scaleFadeOut: AnimateProp;
+    readonly hoverScale: AnimateProp;
+    readonly hoverLift: AnimateProp;
+    readonly hoverGlow: AnimateProp;
+    readonly pressScale: AnimateProp;
+    readonly pressDown: AnimateProp;
+    readonly exitFade: AnimateProp;
+    readonly exitSlideUp: AnimateProp;
+    readonly exitSlideDown: AnimateProp;
+    readonly exitScale: AnimateProp;
+};
+
+declare function useOutsideClick(ref: RefObject<HTMLElement>, callback: (event: MouseEvent | TouchEvent) => void, deps?: DependencyList): void;
+
+interface DragEvent {
+    down: boolean;
+    movement: {
+        x: number;
+        y: number;
+    };
+    offset: {
+        x: number;
+        y: number;
+    };
+    velocity: {
+        x: number;
+        y: number;
+    };
+    event: PointerEvent;
+    cancel: () => void;
+}
+interface DragConfig {
+    threshold?: number;
+    axis?: 'x' | 'y';
+    initial?: () => {
+        x: number;
+        y: number;
+    };
+}
+
+declare function useDrag<T extends HTMLElement>(refs: RefObject<T> | Array<RefObject<T>>, onDrag: (e: DragEvent & {
+    index: number;
+}) => void, config?: DragConfig): void;
+
+interface MoveEvent {
+    movement: {
+        x: number;
+        y: number;
+    };
+    offset: {
+        x: number;
+        y: number;
+    };
+    velocity: {
+        x: number;
+        y: number;
+    };
+    event: PointerEvent;
+    cancel?: () => void;
+}
+
+declare function useMove(refs: Window, onMove: (e: MoveEvent & {
+    index: 0;
+}) => void): void;
+declare function useMove<T extends HTMLElement>(refs: RefObject<T> | Array<RefObject<T>>, onMove: (e: MoveEvent & {
+    index: number;
+}) => void): void;
+
+interface ScrollEvent {
+    movement: {
+        x: number;
+        y: number;
+    };
+    offset: {
+        x: number;
+        y: number;
+    };
+    velocity: {
+        x: number;
+        y: number;
+    };
+    event: Event;
+    cancel?: () => void;
+}
+
+type SupportedEdgeUnit = 'px' | 'vw' | 'vh' | '%';
+type EdgeUnit = `${number}${SupportedEdgeUnit}`;
+type NamedEdges = 'start' | 'end' | 'center';
+type EdgeString = NamedEdges | EdgeUnit | `${number}`;
+type Edge = EdgeString | number;
+type ProgressIntersection = [number, number];
+type Intersection = `${Edge} ${Edge}`;
+type ScrollOffset = Array<Edge | Intersection | ProgressIntersection>;
+interface UseScrollProgressOptions {
+    target?: RefObject<HTMLElement>;
+    axis?: 'x' | 'y';
+    offset?: ScrollOffset;
+    animate?: boolean;
+    toDescriptor?: (t: number) => Descriptor;
+}
+declare function useScrollProgress(refs: Window | RefObject<HTMLElement>, { target, axis, offset, animate, toDescriptor, }?: UseScrollProgressOptions): {
+    scrollYProgress: AnimateValue<number>;
+    scrollXProgress: AnimateValue<number>;
+};
+
+declare function useScroll<T extends HTMLElement>(refs: Window | RefObject<T> | RefObject<T>[], onScroll: (e: ScrollEvent & {
+    index: number;
+}) => void): void;
+declare function useScroll<T extends HTMLElement>(refs: Window | RefObject<T> | RefObject<T>[], options?: UseScrollProgressOptions): {
+    scrollYProgress: AnimateValue<number>;
+    scrollXProgress: AnimateValue<number>;
+};
+
+interface WheelEvent {
+    movement: {
+        x: number;
+        y: number;
+    };
+    offset: {
+        x: number;
+        y: number;
+    };
+    velocity: {
+        x: number;
+        y: number;
+    };
+    event: globalThis.WheelEvent;
+    cancel?: () => void;
+}
+
+declare function useWheel(refs: Window, onWheel: (e: WheelEvent & {
+    index: 0;
+}) => void): void;
+declare function useWheel<T extends HTMLElement>(refs: RefObject<T> | Array<RefObject<T>>, onWheel: (e: WheelEvent & {
+    index: number;
+}) => void): void;
+
+interface GestureInstance<E> {
+    onChange(handler: (event: E) => void): this;
+    onEnd(handler: (event: E) => void): this;
+    attach(target: Window | HTMLElement): () => void;
+}
+interface GestureConstructor<C, E> {
+    new (config?: C): GestureInstance<E>;
+}
+declare function useRecognizer<T extends HTMLElement, C, E>(GestureClass: GestureConstructor<C, E>, refs: Window | RefObject<T> | Array<RefObject<T>>, onEvent: (e: E & {
+    index: number;
+}) => void, config?: C): void;
+
+declare function clamp(value: number, lowerbound: number, upperbound: number): number;
+declare function rubberClamp(value: number, lowerbound: number, upperbound: number, constant?: number): number;
+declare function snapTo(value: number, velocity: number, snapPoints: Array<number>): number;
+declare function move(array: Array<any>, moveIndex: number, toIndex: number): any[];
+
+export { AnimateValue, Config, Easing, Presence, PresenceContext, animate, bounceIn, bounceOut, clamp, combine, decay, delay, exitFade, exitScale, exitSlideDown, exitSlideUp, fadeIn, fadeInDown, fadeInLeft, fadeInRight, fadeInUp, fadeOut, flipX, flipY, hoverGlow, hoverLift, hoverScale, isAnimateValue, loop, makeAnimated, move, parallel, pressDown, pressScale, recipes, rotateIn, rotateOut, rubberClamp, scaleDown, scaleFadeIn, scaleFadeOut, scaleIn, scaleOut, scaleUp, sequence, slideFadeIn, slideFadeOut, slideInDown, slideInLeft, slideInRight, slideInUp, slideOutDown, slideOutLeft, slideOutRight, slideOutUp, snapTo, spin, spring, timing, to, useDrag, useInView, useIsPresent, useMove, useOutsideClick, usePresence, useRecognizer, useScroll, useScrollProgress, useValue, useWheel, withDecay, withDelay, withLoop, withSequence, withSpring, withTiming, zoomIn, zoomOut };
+export type { AnimateAttributes, AnimateController, AnimateHTMLAttributes, AnimateHooks, AnimateProp, AnimateSVGAttributes, AnimateStyle, Callbacks, Controls, DecayOptions$1 as DecayOptions, DelayOptions, Descriptor, DragConfig, DragEvent, DriverType, ExtrapolateConfig, ExtrapolateType, LoopOptions, MoveEvent, PresenceContextValue, PresenceProps, Primitive, ScrollEvent, SequenceOptions, SpringOptions$1 as SpringOptions, TimingOptions$1 as TimingOptions, UseInViewOptions, UseScrollProgressOptions, WheelEvent };