framer-motion 7.6.4 → 7.6.6

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="react" />
 import * as React$1 from 'react';
-import { RefObject, CSSProperties, SVGAttributes, ForwardRefExoticComponent, PropsWithoutRef, RefAttributes, ReactHTML, DetailedHTMLFactory, HTMLAttributes, useEffect } from 'react';
+import { SVGAttributes, CSSProperties, RefObject, ForwardRefExoticComponent, PropsWithoutRef, RefAttributes, ReactHTML, DetailedHTMLFactory, HTMLAttributes, useEffect } from 'react';
+import * as framesync from 'framesync';
 import { Easing as Easing$1, SpringOptions } from 'popmotion';
 import { ScrollOptions, InViewOptions } from '@motionone/dom';
 
@@ -140,2555 +141,2653 @@ declare function motionValue<V>(init: V): MotionValue<V>;
 /**
  * @public
  */
-declare type ControlsAnimationDefinition = string | string[] | TargetAndTransition | TargetResolver;
+declare type ResolvedKeyframesTarget = [null, ...number[]] | number[] | [null, ...string[]] | string[];
 /**
  * @public
  */
-interface AnimationControls {
-    /**
-     * Starts an animation on all linked components.
-     *
-     * @remarks
-     *
-     * ```jsx
-     * controls.start("variantLabel")
-     * controls.start({
-     *   x: 0,
-     *   transition: { duration: 1 }
-     * })
-     * ```
-     *
-     * @param definition - Properties or variant label to animate to
-     * @param transition - Optional `transtion` to apply to a variant
-     * @returns - A `Promise` that resolves when all animations have completed.
-     *
-     * @public
-     */
-    start(definition: ControlsAnimationDefinition, transitionOverride?: Transition): Promise<any>;
-    /**
-     * Instantly set to a set of properties or a variant.
-     *
-     * ```jsx
-     * // With properties
-     * controls.set({ opacity: 0 })
-     *
-     * // With variants
-     * controls.set("hidden")
-     * ```
-     *
-     * @privateRemarks
-     * We could perform a similar trick to `.start` where this can be called before mount
-     * and we maintain a list of of pending actions that get applied on mount. But the
-     * expectation of `set` is that it happens synchronously and this would be difficult
-     * to do before any children have even attached themselves. It's also poor practise
-     * and we should discourage render-synchronous `.start` calls rather than lean into this.
-     *
-     * @public
-     */
-    set(definition: ControlsAnimationDefinition): void;
-    /**
-     * Stops animations on all linked components.
-     *
-     * ```jsx
-     * controls.stop()
-     * ```
-     *
-     * @public
-     */
-    stop(): void;
-    mount(): () => void;
-}
-
-interface Point {
-    x: number;
-    y: number;
-}
-interface Axis {
-    min: number;
-    max: number;
-}
-interface Box {
-    x: Axis;
-    y: Axis;
-}
-interface BoundingBox {
-    top: number;
-    right: number;
-    bottom: number;
-    left: number;
-}
-interface AxisDelta {
-    translate: number;
-    scale: number;
-    origin: number;
-    originPoint: number;
-}
-interface Delta {
-    x: AxisDelta;
-    y: AxisDelta;
-}
-declare type TransformPoint = (point: Point) => Point;
-
+declare type KeyframesTarget = ResolvedKeyframesTarget | [null, ...CustomValueType[]] | CustomValueType[];
 /**
- * Passed in to pan event handlers like `onPan` the `PanInfo` object contains
- * information about the current state of the tap gesture such as its
- * `point`, `delta`, `offset` and `velocity`.
+ * @public
+ */
+declare type ResolvedSingleTarget = string | number;
+/**
+ * @public
+ */
+declare type SingleTarget = ResolvedSingleTarget | CustomValueType;
+/**
+ * @public
+ */
+declare type ResolvedValueTarget = ResolvedSingleTarget | ResolvedKeyframesTarget;
+/**
+ * @public
+ */
+declare type ValueTarget = SingleTarget | KeyframesTarget;
+/**
+ * A function that accepts a progress value between `0` and `1` and returns a
+ * new one.
  *
  * ```jsx
- * <motion.div onPan={(event, info) => {
- *   console.log(info.point.x, info.point.y)
- * }} />
+ * <motion.div
+ *   animate={{ opacity: 0 }}
+ *   transition={{
+ *     duration: 1,
+ *     ease: progress => progress * progress
+ *   }}
+ * />
  * ```
  *
  * @public
  */
-interface PanInfo {
+declare type EasingFunction = (v: number) => number;
+/**
+ * The easing function to use. Set as one of:
+ *
+ * - The name of an in-built easing function.
+ * - An array of four numbers to define a cubic bezier curve.
+ * - An easing function, that accepts and returns a progress value between `0` and `1`.
+ *
+ * @public
+ */
+declare type Easing = [number, number, number, number] | "linear" | "easeIn" | "easeOut" | "easeInOut" | "circIn" | "circOut" | "circInOut" | "backIn" | "backOut" | "backInOut" | "anticipate" | EasingFunction;
+/**
+ * Options for orchestrating the timing of animations.
+ *
+ * @public
+ */
+interface Orchestration {
     /**
-     * Contains `x` and `y` values for the current pan position relative
-     * to the device or page.
+     * Delay the animation by this duration (in seconds). Defaults to `0`.
      *
-     * ```jsx
-     * function onPan(event, info) {
-     *   console.log(info.point.x, info.point.y)
+     * @remarks
+     * ```javascript
+     * const transition = {
+     *   delay: 0.2
      * }
-     *
-     * <motion.div onPan={onPan} />
      * ```
      *
      * @public
      */
-    point: Point;
+    delay?: number;
     /**
-     * Contains `x` and `y` values for the distance moved since
-     * the last event.
+     * Describes the relationship between the transition and its children. Set
+     * to `false` by default.
+     *
+     * @remarks
+     * When using variants, the transition can be scheduled in relation to its
+     * children with either `"beforeChildren"` to finish this transition before
+     * starting children transitions, `"afterChildren"` to finish children
+     * transitions before starting this transition.
      *
      * ```jsx
-     * function onPan(event, info) {
-     *   console.log(info.delta.x, info.delta.y)
+     * const list = {
+     *   hidden: {
+     *     opacity: 0,
+     *     transition: { when: "afterChildren" }
+     *   }
      * }
      *
-     * <motion.div onPan={onPan} />
+     * const item = {
+     *   hidden: {
+     *     opacity: 0,
+     *     transition: { duration: 2 }
+     *   }
+     * }
+     *
+     * return (
+     *   <motion.ul variants={list} animate="hidden">
+     *     <motion.li variants={item} />
+     *     <motion.li variants={item} />
+     *   </motion.ul>
+     * )
      * ```
      *
      * @public
      */
-    delta: Point;
+    when?: false | "beforeChildren" | "afterChildren" | string;
     /**
-     * Contains `x` and `y` values for the distance moved from
-     * the first pan event.
+     * When using variants, children animations will start after this duration
+     * (in seconds). You can add the `transition` property to both the `Frame` and the `variant` directly. Adding it to the `variant` generally offers more flexibility, as it allows you to customize the delay per visual state.
      *
      * ```jsx
-     * function onPan(event, info) {
-     *   console.log(info.offset.x, info.offset.y)
+     * const container = {
+     *   hidden: { opacity: 0 },
+     *   show: {
+     *     opacity: 1,
+     *     transition: {
+     *       delayChildren: 0.5
+     *     }
+     *   }
      * }
      *
-     * <motion.div onPan={onPan} />
+     * const item = {
+     *   hidden: { opacity: 0 },
+     *   show: { opacity: 1 }
+     * }
+     *
+     * return (
+     *   <motion.ul
+     *     variants={container}
+     *     initial="hidden"
+     *     animate="show"
+     *   >
+     *     <motion.li variants={item} />
+     *     <motion.li variants={item} />
+     *   </motion.ul>
+     * )
      * ```
      *
      * @public
      */
-    offset: Point;
+    delayChildren?: number;
     /**
-     * Contains `x` and `y` values for the current velocity of the pointer, in px/ms.
+     * When using variants, animations of child components can be staggered by this
+     * duration (in seconds).
+     *
+     * For instance, if `staggerChildren` is `0.01`, the first child will be
+     * delayed by `0` seconds, the second by `0.01`, the third by `0.02` and so
+     * on.
+     *
+     * The calculated stagger delay will be added to `delayChildren`.
      *
      * ```jsx
-     * function onPan(event, info) {
-     *   console.log(info.velocity.x, info.velocity.y)
+     * const container = {
+     *   hidden: { opacity: 0 },
+     *   show: {
+     *     opacity: 1,
+     *     transition: {
+     *       staggerChildren: 0.5
+     *     }
+     *   }
      * }
      *
-     * <motion.div onPan={onPan} />
+     * const item = {
+     *   hidden: { opacity: 0 },
+     *   show: { opacity: 1 }
+     * }
+     *
+     * return (
+     *   <motion.ol
+     *     variants={container}
+     *     initial="hidden"
+     *     animate="show"
+     *   >
+     *     <motion.li variants={item} />
+     *     <motion.li variants={item} />
+     *   </motion.ol>
+     * )
      * ```
      *
      * @public
      */
-    velocity: Point;
-}
-
-interface DragControlOptions {
-    snapToCursor?: boolean;
-    cursorProgress?: Point;
-}
-
-/**
- * Can manually trigger a drag gesture on one or more `drag`-enabled `motion` components.
- *
- * ```jsx
- * const dragControls = useDragControls()
- *
- * function startDrag(event) {
- *   dragControls.start(event, { snapToCursor: true })
- * }
- *
- * return (
- *   <>
- *     <div onPointerDown={startDrag} />
- *     <motion.div drag="x" dragControls={dragControls} />
- *   </>
- * )
- * ```
- *
- * @public
- */
-declare class DragControls {
-    private componentControls;
+    staggerChildren?: number;
     /**
-     * Start a drag gesture on every `motion` component that has this set of drag controls
-     * passed into it via the `dragControls` prop.
+     * The direction in which to stagger children.
+     *
+     * A value of `1` staggers from the first to the last while `-1`
+     * staggers from the last to the first.
      *
      * ```jsx
-     * dragControls.start(e, {
-     *   snapToCursor: true
-     * })
-     * ```
+     * const container = {
+     *   hidden: { opacity: 0 },
+     *   show: {
+     *     opacity: 1,
+     *     transition: {
+     *       delayChildren: 0.5,
+     *       staggerDirection: -1
+     *     }
+     *   }
+     * }
      *
-     * @param event - PointerEvent
-     * @param options - Options
+     * const item = {
+     *   hidden: { opacity: 0 },
+     *   show: { opacity: 1 }
+     * }
+     *
+     * return (
+     *   <motion.ul
+     *     variants={container}
+     *     initial="hidden"
+     *     animate="show"
+     *   >
+     *     <motion.li variants={item} size={50} />
+     *     <motion.li variants={item} size={50} />
+     *   </motion.ul>
+     * )
+     * ```
      *
      * @public
      */
-    start(event: React$1.MouseEvent | React$1.TouchEvent | React$1.PointerEvent | MouseEvent | TouchEvent | PointerEvent, options?: DragControlOptions): void;
+    staggerDirection?: number;
 }
-/**
- * Usually, dragging is initiated by pressing down on a `motion` component with a `drag` prop
- * and moving it. For some use-cases, for instance clicking at an arbitrary point on a video scrubber, we
- * might want to initiate that dragging from a different component than the draggable one.
- *
- * By creating a `dragControls` using the `useDragControls` hook, we can pass this into
- * the draggable component's `dragControls` prop. It exposes a `start` method
- * that can start dragging from pointer events on other components.
- *
- * ```jsx
- * const dragControls = useDragControls()
- *
- * function startDrag(event) {
- *   dragControls.start(event, { snapToCursor: true })
- * }
- *
- * return (
- *   <>
- *     <div onPointerDown={startDrag} />
- *     <motion.div drag="x" dragControls={dragControls} />
- *   </>
- * )
- * ```
- *
- * @public
- */
-declare function useDragControls(): DragControls;
-
-declare type DragElastic = boolean | number | Partial<BoundingBox>;
-/**
- * @public
- */
-interface DragHandlers {
+interface Repeat {
     /**
-     * Callback function that fires when dragging starts.
+     * The number of times to repeat the transition. Set to `Infinity` for perpetual repeating.
+     *
+     * Without setting `repeatType`, this will loop the animation.
      *
      * ```jsx
      * <motion.div
-     *   drag
-     *   onDragStart={
-     *     (event, info) => console.log(info.point.x, info.point.y)
-     *   }
+     *   animate={{ rotate: 180 }}
+     *   transition={{ repeat: Infinity, duration: 2 }}
      * />
      * ```
      *
      * @public
      */
-    onDragStart?(event: MouseEvent | TouchEvent | PointerEvent, info: PanInfo): void;
+    repeat?: number;
     /**
-     * Callback function that fires when dragging ends.
+     * How to repeat the animation. This can be either:
+     *
+     * "loop": Repeats the animation from the start
+     *
+     * "reverse": Alternates between forward and backwards playback
+     *
+     * "mirror": Switches `from` and `to` alternately
      *
      * ```jsx
      * <motion.div
-     *   drag
-     *   onDragEnd={
-     *     (event, info) => console.log(info.point.x, info.point.y)
-     *   }
+     *   animate={{ rotate: 180 }}
+     *   transition={{
+     *     repeat: 1,
+     *     repeatType: "reverse",
+     *     duration: 2
+     *   }}
      * />
      * ```
      *
      * @public
      */
-    onDragEnd?(event: MouseEvent | TouchEvent | PointerEvent, info: PanInfo): void;
+    repeatType?: "loop" | "reverse" | "mirror";
     /**
-     * Callback function that fires when the component is dragged.
+     * When repeating an animation, `repeatDelay` will set the
+     * duration of the time to wait, in seconds, between each repetition.
      *
      * ```jsx
      * <motion.div
-     *   drag
-     *   onDrag={
-     *     (event, info) => console.log(info.point.x, info.point.y)
-     *   }
+     *   animate={{ rotate: 180 }}
+     *   transition={{ repeat: Infinity, repeatDelay: 1 }}
      * />
      * ```
      *
      * @public
      */
-    onDrag?(event: MouseEvent | TouchEvent | PointerEvent, info: PanInfo): void;
+    repeatDelay?: number;
+}
+/**
+ * An animation that animates between two or more values over a specific duration of time.
+ * This is the default animation for non-physical values like `color` and `opacity`.
+ *
+ * @public
+ */
+interface Tween extends Repeat {
     /**
-     * Callback function that fires a drag direction is determined.
+     * Set `type` to `"tween"` to use a duration-based tween animation.
+     * If any non-orchestration `transition` values are set without a `type` property,
+     * this is used as the default animation.
      *
      * ```jsx
-     * <motion.div
-     *   drag
-     *   dragDirectionLock
-     *   onDirectionLock={axis => console.log(axis)}
+     * <motion.path
+     *   animate={{ pathLength: 1 }}
+     *   transition={{ duration: 2, type: "tween" }}
      * />
      * ```
      *
      * @public
      */
-    onDirectionLock?(axis: "x" | "y"): void;
+    type?: "tween";
     /**
-     * Callback function that fires when drag momentum/bounce transition finishes.
+     * The duration of the tween animation. Set to `0.3` by default, 0r `0.8` if animating a series of keyframes.
      *
      * ```jsx
-     * <motion.div
-     *   drag
-     *   onDragTransitionEnd={() => console.log('Drag transition complete')}
-     * />
+     * const variants = {
+     *   visible: {
+     *     opacity: 1,
+     *     transition: { duration: 2 }
+     *   }
+     * }
      * ```
      *
      * @public
      */
-    onDragTransitionEnd?(): void;
-}
-/**
- * @public
- */
-declare type InertiaOptions = Partial<Omit<Inertia, "velocity" | "type">>;
-/**
- * @public
- */
-interface DraggableProps extends DragHandlers {
+    duration?: number;
     /**
-     * Enable dragging for this element. Set to `false` by default.
-     * Set `true` to drag in both directions.
-     * Set `"x"` or `"y"` to only drag in a specific direction.
+     * The easing function to use. Set as one of the below.
+     *
+     * - The name of an existing easing function.
+     *
+     * - An array of four numbers to define a cubic bezier curve.
+     *
+     * - An easing function, that accepts and returns a value `0-1`.
+     *
+     * If the animating value is set as an array of multiple values for a keyframes
+     * animation, `ease` can be set as an array of easing functions to set different easings between
+     * each of those values.
      *
-     * ```jsx
-     * <motion.div drag="x" />
-     * ```
-     */
-    drag?: boolean | "x" | "y";
-    /**
-     * Properties or variant label to animate to while the drag gesture is recognised.
      *
      * ```jsx
-     * <motion.div whileDrag={{ scale: 1.2 }} />
+     * <motion.div
+     *   animate={{ opacity: 0 }}
+     *   transition={{ ease: [0.17, 0.67, 0.83, 0.67] }}
+     * />
      * ```
+     *
+     * @public
      */
-    whileDrag?: VariantLabels | TargetAndTransition;
+    ease?: Easing | Easing[];
     /**
-     * If `true`, this will lock dragging to the initially-detected direction. Defaults to `false`.
+     * When animating keyframes, `times` can be used to determine where in the animation each keyframe is reached.
+     * Each value in `times` is a value between `0` and `1`, representing `duration`.
+     *
+     * There must be the same number of `times` as there are keyframes.
+     * Defaults to an array of evenly-spread durations.
      *
      * ```jsx
-     * <motion.div drag dragDirectionLock />
+     * <motion.div
+     *   animate={{ scale: [0, 1, 0.5, 1] }}
+     *   transition={{ times: [0, 0.1, 0.9, 1] }}
+     * />
      * ```
+     *
+     * @public
      */
-    dragDirectionLock?: boolean;
+    times?: number[];
     /**
-     * Allows drag gesture propagation to child components. Set to `false` by
-     * default.
+     * When animating keyframes, `easings` can be used to define easing functions between each keyframe. This array should be one item fewer than the number of keyframes, as these easings apply to the transitions between the keyframes.
      *
      * ```jsx
-     * <motion.div drag="x" dragPropagation />
+     * <motion.div
+     *   animate={{ backgroundColor: ["#0f0", "#00f", "#f00"] }}
+     *   transition={{ easings: ["easeIn", "easeOut"] }}
+     * />
      * ```
+     *
+     * @public
      */
-    dragPropagation?: boolean;
+    easings?: Easing[];
     /**
-     * Applies constraints on the permitted draggable area.
-     *
-     * It can accept an object of optional `top`, `left`, `right`, and `bottom` values, measured in pixels.
-     * This will define a distance the named edge of the draggable component.
-     *
-     * Alternatively, it can accept a `ref` to another component created with React's `useRef` hook.
-     * This `ref` should be passed both to the draggable component's `dragConstraints` prop, and the `ref`
-     * of the component you want to use as constraints.
+     * The value to animate from.
+     * By default, this is the current state of the animating value.
      *
      * ```jsx
-     * // In pixels
      * <motion.div
-     *   drag="x"
-     *   dragConstraints={{ left: 0, right: 300 }}
+     *   animate={{ rotate: 180 }}
+     *   transition={{ from: 90, duration: 2 }}
      * />
+     * ```
      *
-     * // As a ref to another component
-     * const MyComponent = () => {
-     *   const constraintsRef = useRef(null)
+     * @public
+     */
+    from?: number | string;
+}
+/**
+ * An animation that simulates spring physics for realistic motion.
+ * This is the default animation for physical values like `x`, `y`, `scale` and `rotate`.
+ *
+ * @public
+ */
+interface Spring extends Repeat {
+    /**
+     * Set `type` to `"spring"` to animate using spring physics for natural
+     * movement. Type is set to `"spring"` by default.
      *
-     *   return (
-     *      <motion.div ref={constraintsRef}>
-     *          <motion.div drag dragConstraints={constraintsRef} />
-     *      </motion.div>
-     *   )
-     * }
+     * ```jsx
+     * <motion.div
+     *   animate={{ rotate: 180 }}
+     *   transition={{ type: 'spring' }}
+     * />
      * ```
+     *
+     * @public
      */
-    dragConstraints?: false | Partial<BoundingBox> | RefObject<Element>;
+    type: "spring";
     /**
-     * The degree of movement allowed outside constraints. 0 = no movement, 1 =
-     * full movement.
+     * Stiffness of the spring. Higher values will create more sudden movement.
+     * Set to `100` by default.
      *
-     * Set to `0.5` by default. Can also be set as `false` to disable movement.
+     * ```jsx
+     * <motion.section
+     *   animate={{ rotate: 180 }}
+     *   transition={{ type: 'spring', stiffness: 50 }}
+     * />
+     * ```
      *
-     * By passing an object of `top`/`right`/`bottom`/`left`, individual values can be set
-     * per constraint. Any missing values will be set to `0`.
+     * @public
+     */
+    stiffness?: number;
+    /**
+     * Strength of opposing force. If set to 0, spring will oscillate
+     * indefinitely. Set to `10` by default.
      *
      * ```jsx
-     * <motion.div
-     *   drag
-     *   dragConstraints={{ left: 0, right: 300 }}
-     *   dragElastic={0.2}
+     * <motion.a
+     *   animate={{ rotate: 180 }}
+     *   transition={{ type: 'spring', damping: 300 }}
      * />
      * ```
+     *
+     * @public
      */
-    dragElastic?: DragElastic;
+    damping?: number;
     /**
-     * Apply momentum from the pan gesture to the component when dragging
-     * finishes. Set to `true` by default.
+     * Mass of the moving object. Higher values will result in more lethargic
+     * movement. Set to `1` by default.
      *
      * ```jsx
-     * <motion.div
-     *   drag
-     *   dragConstraints={{ left: 0, right: 300 }}
-     *   dragMomentum={false}
+     * <motion.feTurbulence
+     *   animate={{ baseFrequency: 0.5 } as any}
+     *   transition={{ type: "spring", mass: 0.5 }}
      * />
      * ```
+     *
+     * @public
      */
-    dragMomentum?: boolean;
+    mass?: number;
     /**
-     * Allows you to change dragging inertia parameters.
-     * When releasing a draggable Frame, an animation with type `inertia` starts. The animation is based on your dragging velocity. This property allows you to customize it.
-     * See {@link https://framer.com/api/animation/#inertia | Inertia} for all properties you can use.
+     * The duration of the animation, defined in seconds. Spring animations can be a maximum of 10 seconds.
+     *
+     * If `bounce` is set, this defaults to `0.8`.
+     *
+     * Note: `duration` and `bounce` will be overridden if `stiffness`, `damping` or `mass` are set.
      *
      * ```jsx
      * <motion.div
-     *   drag
-     *   dragTransition={{ bounceStiffness: 600, bounceDamping: 10 }}
+     *   animate={{ x: 100 }}
+     *   transition={{ type: "spring", duration: 0.8 }}
      * />
      * ```
+     *
+     * @public
      */
-    dragTransition?: InertiaOptions;
+    duration?: number;
     /**
-     * Usually, dragging is initiated by pressing down on a component and moving it. For some
-     * use-cases, for instance clicking at an arbitrary point on a video scrubber, we
-     * might want to initiate dragging from a different component than the draggable one.
+     * `bounce` determines the "bounciness" of a spring animation.
      *
-     * By creating a `dragControls` using the `useDragControls` hook, we can pass this into
-     * the draggable component's `dragControls` prop. It exposes a `start` method
-     * that can start dragging from pointer events on other components.
+     * `0` is no bounce, and `1` is extremely bouncy.
      *
-     * ```jsx
-     * const dragControls = useDragControls()
+     * If `duration` is set, this defaults to `0.25`.
      *
-     * function startDrag(event) {
-     *   dragControls.start(event, { snapToCursor: true })
-     * }
+     * Note: `bounce` and `duration` will be overridden if `stiffness`, `damping` or `mass` are set.
      *
-     * return (
-     *   <>
-     *     <div onPointerDown={startDrag} />
-     *     <motion.div drag="x" dragControls={dragControls} />
-     *   </>
-     * )
+     * ```jsx
+     * <motion.div
+     *   animate={{ x: 100 }}
+     *   transition={{ type: "spring", bounce: 0.25 }}
+     * />
      * ```
-     */
-    dragControls?: DragControls;
-    /**
-     * If true, element will snap back to its origin when dragging ends.
      *
-     * Enabling this is the equivalent of setting all `dragConstraints` axes to `0`
-     * with `dragElastic={1}`, but when used together `dragConstraints` can define
-     * a wider draggable area and `dragSnapToOrigin` will ensure the element
-     * animates back to its origin on release.
+     * @public
      */
-    dragSnapToOrigin?: boolean;
+    bounce?: number;
     /**
-     * By default, if `drag` is defined on a component then an event listener will be attached
-     * to automatically initiate dragging when a user presses down on it.
-     *
-     * By setting `dragListener` to `false`, this event listener will not be created.
+     * End animation if absolute speed (in units per second) drops below this
+     * value and delta is smaller than `restDelta`. Set to `0.01` by default.
      *
      * ```jsx
-     * const dragControls = useDragControls()
-     *
-     * function startDrag(event) {
-     *   dragControls.start(event, { snapToCursor: true })
-     * }
-     *
-     * return (
-     *   <>
-     *     <div onPointerDown={startDrag} />
-     *     <motion.div
-     *       drag="x"
-     *       dragControls={dragControls}
-     *       dragListener={false}
-     *     />
-     *   </>
-     * )
+     * <motion.div
+     *   animate={{ rotate: 180 }}
+     *   transition={{ type: 'spring', restSpeed: 0.5 }}
+     * />
      * ```
+     *
+     * @public
      */
-    dragListener?: boolean;
+    restSpeed?: number;
     /**
-     * If `dragConstraints` is set to a React ref, this callback will call with the measured drag constraints.
+     * End animation if distance is below this value and speed is below
+     * `restSpeed`. When animation ends, spring gets “snapped” to. Set to
+     * `0.01` by default.
+     *
+     * ```jsx
+     * <motion.div
+     *   animate={{ rotate: 180 }}
+     *   transition={{ type: 'spring', restDelta: 0.5 }}
+     * />
+     * ```
      *
      * @public
      */
-    onMeasureDragConstraints?: (constraints: BoundingBox) => BoundingBox | void;
+    restDelta?: number;
     /**
-     * Usually, dragging uses the layout project engine, and applies transforms to the underlying VisualElement.
-     * Passing MotionValues as _dragX and _dragY instead applies drag updates to these motion values.
-     * This allows you to manually control how updates from a drag gesture on an element is applied.
+     * The value to animate from.
+     * By default, this is the initial state of the animating value.
+     *
+     * ```jsx
+     * <motion.div
+     *   animate={{ rotate: 180 }}
+     *   transition={{ type: 'spring', from: 90 }}
+     * />
+     * ```
      *
      * @public
      */
-    _dragX?: MotionValue<number>;
+    from?: number | string;
     /**
-     * Usually, dragging uses the layout project engine, and applies transforms to the underlying VisualElement.
-     * Passing MotionValues as _dragX and _dragY instead applies drag updates to these motion values.
-     * This allows you to manually control how updates from a drag gesture on an element is applied.
+     * The initial velocity of the spring. By default this is the current velocity of the component.
+     *
+     * ```jsx
+     * <motion.div
+     *   animate={{ rotate: 180 }}
+     *   transition={{ type: 'spring', velocity: 2 }}
+     * />
+     * ```
      *
      * @public
      */
-    _dragY?: MotionValue<number>;
+    velocity?: number;
 }
-
 /**
+ * An animation that decelerates a value based on its initial velocity,
+ * usually used to implement inertial scrolling.
+ *
+ * Optionally, `min` and `max` boundaries can be defined, and inertia
+ * will snap to these with a spring animation.
+ *
+ * This animation will automatically precalculate a target value,
+ * which can be modified with the `modifyTarget` property.
+ *
+ * This allows you to add snap-to-grid or similar functionality.
+ *
+ * Inertia is also the animation used for `dragTransition`, and can be configured via that prop.
+ *
  * @public
  */
-interface LayoutProps {
+interface Inertia {
     /**
-     * If `true`, this component will automatically animate to its new position when
-     * its layout changes.
+     * Set `type` to animate using the inertia animation. Set to `"tween"` by
+     * default. This can be used for natural deceleration, like momentum scrolling.
      *
      * ```jsx
-     * <motion.div layout />
+     * <motion.div
+     *   animate={{ rotate: 180 }}
+     *   transition={{ type: "inertia", velocity: 50 }}
+     * />
      * ```
      *
-     * This will perform a layout animation using performant transforms. Part of this technique
-     * involved animating an element's scale. This can introduce visual distortions on children,
-     * `boxShadow` and `borderRadius`.
-     *
-     * To correct distortion on immediate children, add `layout` to those too.
-     *
-     * `boxShadow` and `borderRadius` will automatically be corrected if they are already being
-     * animated on this component. Otherwise, set them directly via the `initial` prop.
-     *
-     * If `layout` is set to `"position"`, the size of the component will change instantly and
-     * only its position will animate. If `layout` is set to `"size"`, the position of the
-     * component will change instantly but its size will animate.
-     *
-     * If `layout` is set to `"size"`, the position of the component will change instantly and
-     * only its size will animate.
-     *
-     * If `layout` is set to `"preserve-aspect"`, the component will animate size & position if
-     * the aspect ratio remains the same between renders, and just position if the ratio changes.
-     *
      * @public
      */
-    layout?: boolean | "position" | "size" | "preserve-aspect";
+    type: "inertia";
     /**
-     * Enable shared layout transitions between different components with the same `layoutId`.
-     *
-     * When a component with a layoutId is removed from the React tree, and then
-     * added elsewhere, it will visually animate from the previous component's bounding box
-     * and its latest animated values.
+     * A function that receives the automatically-calculated target and returns a new one. Useful for snapping the target to a grid.
      *
      * ```jsx
-     *   {items.map(item => (
-     *      <motion.li layout>
-     *         {item.name}
-     *         {item.isSelected && <motion.div layoutId="underline" />}
-     *      </motion.li>
-     *   ))}
+     * <motion.div
+     *   drag
+     *   dragTransition={{
+     *     power: 0,
+     *     // Snap calculated target to nearest 50 pixels
+     *     modifyTarget: target => Math.round(target / 50) * 50
+     *   }}
+     * />
      * ```
      *
-     * If the previous component remains in the tree it will crossfade with the new component.
-     *
      * @public
      */
-    layoutId?: string;
+    modifyTarget?(v: number): number;
     /**
-     * A callback that will fire when a layout animation on this component starts.
+     * If `min` or `max` is set, this affects the stiffness of the bounce
+     * spring. Higher values will create more sudden movement. Set to `500` by
+     * default.
+     *
+     * ```jsx
+     * <motion.div
+     *   drag
+     *   dragTransition={{
+     *     min: 0,
+     *     max: 100,
+     *     bounceStiffness: 100
+     *   }}
+     * />
+     * ```
      *
      * @public
      */
-    onLayoutAnimationStart?(): void;
+    bounceStiffness?: number;
     /**
-     * A callback that will fire when a layout animation on this component completes.
+     * If `min` or `max` is set, this affects the damping of the bounce spring.
+     * If set to `0`, spring will oscillate indefinitely. Set to `10` by
+     * default.
+     *
+     * ```jsx
+     * <motion.div
+     *   drag
+     *   dragTransition={{
+     *     min: 0,
+     *     max: 100,
+     *     bounceDamping: 8
+     *   }}
+     * />
+     * ```
      *
      * @public
      */
-    onLayoutAnimationComplete?(): void;
+    bounceDamping?: number;
     /**
+     * A higher power value equals a further target. Set to `0.8` by default.
+     *
+     * ```jsx
+     * <motion.div
+     *   drag
+     *   dragTransition={{ power: 0.2 }}
+     * />
+     * ```
+     *
      * @public
      */
-    layoutDependency?: any;
+    power?: number;
     /**
-     * Wether a projection node should measure its scroll when it or its descendants update their layout.
+     * Adjusting the time constant will change the duration of the
+     * deceleration, thereby affecting its feel. Set to `700` by default.
+     *
+     * ```jsx
+     * <motion.div
+     *   drag
+     *   dragTransition={{ timeConstant: 200 }}
+     * />
+     * ```
      *
      * @public
      */
-    layoutScroll?: boolean;
-}
-
-declare enum AnimationType {
-    Animate = "animate",
-    Hover = "whileHover",
-    Tap = "whileTap",
-    Drag = "whileDrag",
-    Focus = "whileFocus",
-    InView = "whileInView",
-    Exit = "exit"
-}
-
-declare type AnimationDefinition = VariantLabels | TargetAndTransition | TargetResolver;
-declare type AnimationOptions$1 = {
-    delay?: number;
-    transitionOverride?: Transition;
-    custom?: any;
-    type?: AnimationType;
-};
-declare function animateVisualElement(visualElement: VisualElement, definition: AnimationDefinition, options?: AnimationOptions$1): Promise<void>;
-
-declare type LayoutMeasureListener = (layout: Box, prevLayout?: Box) => void;
-declare type BeforeLayoutMeasureListener = () => void;
-declare type LayoutUpdateListener = (layout: Axis, prevLayout: Axis) => void;
-declare type UpdateListener = (latest: ResolvedValues) => void;
-declare type AnimationStartListener = (definition: AnimationDefinition) => void;
-declare type AnimationCompleteListener = (definition: AnimationDefinition) => void;
-declare type LayoutAnimationStartListener = () => void;
-declare type LayoutAnimationCompleteListener = () => void;
-declare type SetAxisTargetListener = () => void;
-declare type RenderListener = () => void;
-interface LayoutLifecycles {
-    onBeforeLayoutMeasure?(box: Box): void;
-    onLayoutMeasure?(box: Box, prevBox: Box): void;
-}
-interface AnimationLifecycles {
+    timeConstant?: number;
     /**
-     * Callback with latest motion values, fired max once per frame.
+     * End the animation if the distance to the animation target is below this value, and the absolute speed is below `restSpeed`.
+     * When the animation ends, the value gets snapped to the animation target. Set to `0.01` by default.
+     * Generally the default values provide smooth animation endings, only in rare cases should you need to customize these.
      *
      * ```jsx
-     * function onUpdate(latest) {
-     *   console.log(latest.x, latest.opacity)
-     * }
-     *
-     * <motion.div animate={{ x: 100, opacity: 0 }} onUpdate={onUpdate} />
+     * <motion.div
+     *   drag
+     *   dragTransition={{ restDelta: 10 }}
+     * />
      * ```
+     *
+     * @public
      */
-    onUpdate?(latest: ResolvedValues): void;
+    restDelta?: number;
     /**
-     * Callback when animation defined in `animate` begins.
-     *
-     * The provided callback will be called with the triggering animation definition.
-     * If this is a variant, it'll be the variant name, and if a target object
-     * then it'll be the target object.
-     *
-     * This way, it's possible to figure out which animation has started.
+     * Minimum constraint. If set, the value will "bump" against this value (or immediately spring to it if the animation starts as less than this value).
      *
      * ```jsx
-     * function onStart() {
-     *   console.log("Animation started")
-     * }
-     *
-     * <motion.div animate={{ x: 100 }} onAnimationStart={onStart} />
+     * <motion.div
+     *   drag
+     *   dragTransition={{ min: 0, max: 100 }}
+     * />
      * ```
+     *
+     * @public
      */
-    onAnimationStart?(definition: AnimationDefinition): void;
+    min?: number;
     /**
-     * Callback when animation defined in `animate` is complete.
-     *
-     * The provided callback will be called with the triggering animation definition.
-     * If this is a variant, it'll be the variant name, and if a target object
-     * then it'll be the target object.
-     *
-     * This way, it's possible to figure out which animation has completed.
+     * Maximum constraint. If set, the value will "bump" against this value (or immediately snap to it, if the initial animation value exceeds this value).
      *
      * ```jsx
-     * function onComplete() {
-     *   console.log("Animation completed")
-     * }
-     *
      * <motion.div
-     *   animate={{ x: 100 }}
-     *   onAnimationComplete={definition => {
-     *     console.log('Completed animating', definition)
-     *   }}
+     *   drag
+     *   dragTransition={{ min: 0, max: 100 }}
      * />
      * ```
+     *
+     * @public
      */
-    onAnimationComplete?(definition: AnimationDefinition): void;
-}
-declare type VisualElementLifecycles = LayoutLifecycles & AnimationLifecycles;
-interface LifecycleManager {
-    onLayoutMeasure: (callback: LayoutMeasureListener) => () => void;
-    notifyLayoutMeasure: LayoutMeasureListener;
-    onBeforeLayoutMeasure: (callback: BeforeLayoutMeasureListener) => () => void;
-    notifyBeforeLayoutMeasure: BeforeLayoutMeasureListener;
-    onLayoutUpdate: (callback: LayoutUpdateListener) => () => void;
-    notifyLayoutUpdate: LayoutUpdateListener;
-    onUpdate: (callback: UpdateListener) => () => void;
-    notifyUpdate: UpdateListener;
-    onAnimationStart: (callback: AnimationStartListener) => () => void;
-    notifyAnimationStart: AnimationStartListener;
-    onAnimationComplete: (callback: AnimationCompleteListener) => () => void;
-    notifyAnimationComplete: AnimationCompleteListener;
-    onLayoutAnimationStart: (callback: LayoutAnimationStartListener) => () => void;
-    notifyLayoutAnimationStart: LayoutAnimationStartListener;
-    onLayoutAnimationComplete: (callback: LayoutAnimationCompleteListener) => () => void;
-    notifyLayoutAnimationComplete: LayoutAnimationCompleteListener;
-    onSetAxisTarget: (callback: SetAxisTargetListener) => () => void;
-    notifySetAxisTarget: SetAxisTargetListener;
-    onRender: (callback: RenderListener) => () => void;
-    notifyRender: RenderListener;
-    onUnmount: (callback: () => void) => () => void;
-    notifyUnmount: () => void;
-    clearAllListeners: () => void;
-    updatePropListeners: (props: MotionProps) => void;
-}
-
-/** @public */
-interface EventInfo {
-    point: Point;
-}
-
-/**
- * @public
- */
-interface FocusHandlers {
+    max?: number;
     /**
-     * Properties or variant label to animate to while the focus gesture is recognised.
+     * The value to animate from. By default, this is the current state of the animating value.
      *
      * ```jsx
-     * <motion.input whileFocus={{ scale: 1.2 }} />
+     * <Frame
+     *   drag
+     *   dragTransition={{ from: 50 }}
+     * />
      * ```
+     *
+     * @public
      */
-    whileFocus?: VariantLabels | TargetAndTransition;
-}
-/**
- * Passed in to tap event handlers like `onTap` the `TapInfo` object contains
- * information about the tap gesture such as it‘s location.
- *
- * ```jsx
- * function onTap(event, info) {
- *   console.log(info.point.x, info.point.y)
- * }
- *
- * <motion.div onTap={onTap} />
- * ```
- *
- * @public
- */
-interface TapInfo {
+    from?: number | string;
     /**
-     * Contains `x` and `y` values for the tap gesture relative to the
-     * device or page.
+     * The initial velocity of the animation.
+     * By default this is the current velocity of the component.
      *
      * ```jsx
-     * function onTapStart(event, info) {
-     *   console.log(info.point.x, info.point.y)
-     * }
-     *
-     * <motion.div onTapStart={onTapStart} />
+     * <motion.div
+     *   animate={{ rotate: 180 }}
+     *   transition={{ type: 'inertia', velocity: 200 }}
+     * />
      * ```
      *
      * @public
      */
-    point: Point;
+    velocity?: number;
 }
 /**
- * @public
+ * Keyframes tweens between multiple `values`.
+ *
+ * These tweens can be arranged using the `duration`, `easings`, and `times` properties.
  */
-interface TapHandlers {
+interface Keyframes {
     /**
-     * Callback when the tap gesture successfully ends on this element.
+     * Set `type` to `"keyframes"` to animate using the keyframes animation.
+     * Set to `"tween"` by default. This can be used to animate between a series of values.
      *
-     * ```jsx
-     * function onTap(event, info) {
-     *   console.log(info.point.x, info.point.y)
-     * }
+     * @public
+     */
+    type: "keyframes";
+    /**
+     * An array of numbers between 0 and 1, where `1` represents the `total` duration.
      *
-     * <motion.div onTap={onTap} />
-     * ```
+     * Each value represents at which point during the animation each item in the animation target should be hit, so the array should be the same length as `values`.
      *
-     * @param event - The originating pointer event.
-     * @param info - An {@link TapInfo} object containing `x` and `y` values for the `point` relative to the device or page.
+     * Defaults to an array of evenly-spread durations.
+     *
+     * @public
      */
-    onTap?(event: MouseEvent | TouchEvent | PointerEvent, info: TapInfo): void;
+    times?: number[];
     /**
-     * Callback when the tap gesture starts on this element.
+     * An array of easing functions for each generated tween, or a single easing function applied to all tweens.
+     *
+     * This array should be one item less than `values`, as these easings apply to the transitions *between* the `values`.
      *
      * ```jsx
-     * function onTapStart(event, info) {
-     *   console.log(info.point.x, info.point.y)
+     * const transition = {
+     *   backgroundColor: {
+     *     type: 'keyframes',
+     *     easings: ['circIn', 'circOut']
+     *   }
      * }
-     *
-     * <motion.div onTapStart={onTapStart} />
      * ```
      *
-     * @param event - The originating pointer event.
-     * @param info - An {@link TapInfo} object containing `x` and `y` values for the `point` relative to the device or page.
+     * @public
      */
-    onTapStart?(event: MouseEvent | TouchEvent | PointerEvent, info: TapInfo): void;
+    ease?: Easing | Easing[];
     /**
-     * Callback when the tap gesture ends outside this element.
+     * The total duration of the animation. Set to `0.3` by default.
      *
      * ```jsx
-     * function onTapCancel(event, info) {
-     *   console.log(info.point.x, info.point.y)
+     * const transition = {
+     *   type: "keyframes",
+     *   duration: 2
      * }
      *
-     * <motion.div onTapCancel={onTapCancel} />
+     * <Frame
+     *   animate={{ opacity: 0 }}
+     *   transition={transition}
+     * />
      * ```
      *
-     * @param event - The originating pointer event.
-     * @param info - An {@link TapInfo} object containing `x` and `y` values for the `point` relative to the device or page.
+     * @public
      */
-    onTapCancel?(event: MouseEvent | TouchEvent | PointerEvent, info: TapInfo): void;
+    duration?: number;
     /**
-     * Properties or variant label to animate to while the component is pressed.
-     *
-     * ```jsx
-     * <motion.div whileTap={{ scale: 0.8 }} />
-     * ```
+     * @public
      */
-    whileTap?: VariantLabels | TargetAndTransition;
+    repeatDelay?: number;
 }
 /**
  * @public
  */
-interface PanHandlers {
-    /**
-     * Callback function that fires when the pan gesture is recognised on this element.
-     *
-     * **Note:** For pan gestures to work correctly with touch input, the element needs
-     * touch scrolling to be disabled on either x/y or both axis with the
-     * [touch-action](https://developer.mozilla.org/en-US/docs/Web/CSS/touch-action) CSS rule.
-     *
-     * ```jsx
-     * function onPan(event, info) {
-     *   console.log(info.point.x, info.point.y)
-     * }
-     *
-     * <motion.div onPan={onPan} />
-     * ```
-     *
-     * @param event - The originating pointer event.
-     * @param info - A {@link PanInfo} object containing `x` and `y` values for:
-     *
-     *   - `point`: Relative to the device or page.
-     *   - `delta`: Distance moved since the last event.
-     *   - `offset`: Offset from the original pan event.
-     *   - `velocity`: Current velocity of the pointer.
-     */
-    onPan?(event: MouseEvent | TouchEvent | PointerEvent, info: PanInfo): void;
-    /**
-     * Callback function that fires when the pan gesture begins on this element.
-     *
-     * ```jsx
-     * function onPanStart(event, info) {
-     *   console.log(info.point.x, info.point.y)
-     * }
-     *
-     * <motion.div onPanStart={onPanStart} />
-     * ```
-     *
-     * @param event - The originating pointer event.
-     * @param info - A {@link PanInfo} object containing `x`/`y` values for:
-     *
-     *   - `point`: Relative to the device or page.
-     *   - `delta`: Distance moved since the last event.
-     *   - `offset`: Offset from the original pan event.
-     *   - `velocity`: Current velocity of the pointer.
-     */
-    onPanStart?(event: MouseEvent | TouchEvent | PointerEvent, info: PanInfo): void;
-    /**
-     * Callback function that fires when we begin detecting a pan gesture. This
-     * is analogous to `onMouseStart` or `onTouchStart`.
-     *
-     * ```jsx
-     * function onPanSessionStart(event, info) {
-     *   console.log(info.point.x, info.point.y)
-     * }
-     *
-     * <motion.div onPanSessionStart={onPanSessionStart} />
-     * ```
-     *
-     * @param event - The originating pointer event.
-     * @param info - An {@link EventInfo} object containing `x`/`y` values for:
-     *
-     *   - `point`: Relative to the device or page.
-     */
-    onPanSessionStart?(event: MouseEvent | TouchEvent | PointerEvent, info: EventInfo): void;
+interface Just {
     /**
-     * Callback function that fires when the pan gesture ends on this element.
-     *
-     * ```jsx
-     * function onPanEnd(event, info) {
-     *   console.log(info.point.x, info.point.y)
-     * }
-     *
-     * <motion.div onPanEnd={onPanEnd} />
-     * ```
-     *
-     * @param event - The originating pointer event.
-     * @param info - A {@link PanInfo} object containing `x`/`y` values for:
-     *
-     *   - `point`: Relative to the device or page.
-     *   - `delta`: Distance moved since the last event.
-     *   - `offset`: Offset from the original pan event.
-     *   - `velocity`: Current velocity of the pointer.
+     * @public
      */
-    onPanEnd?(event: MouseEvent | TouchEvent | PointerEvent, info: PanInfo): void;
+    type: "just";
 }
 /**
  * @public
  */
-interface HoverHandlers {
-    /**
-     * Properties or variant label to animate to while the hover gesture is recognised.
-     *
-     * ```jsx
-     * <motion.div whileHover={{ scale: 1.2 }} />
-     * ```
-     */
-    whileHover?: VariantLabels | TargetAndTransition;
-    /**
-     * Callback function that fires when pointer starts hovering over the component.
-     *
-     * ```jsx
-     * <motion.div onHoverStart={() => console.log('Hover starts')} />
-     * ```
-     */
-    onHoverStart?(event: MouseEvent, info: EventInfo): void;
+interface None {
     /**
-     * Callback function that fires when pointer stops hovering over the component.
+     * Set `type` to `false` for an instant transition.
      *
-     * ```jsx
-     * <motion.div onHoverEnd={() => console.log("Hover ends")} />
-     * ```
+     * @public
      */
-    onHoverEnd?(event: MouseEvent, info: EventInfo): void;
-}
-
-declare type ViewportEventHandler = (entry: IntersectionObserverEntry | null) => void;
-interface ViewportOptions {
-    root?: RefObject<Element>;
-    once?: boolean;
-    margin?: string;
-    amount?: "some" | "all" | number;
-    fallback?: boolean;
-}
-interface ViewportProps {
-    whileInView?: VariantLabels | TargetAndTransition;
-    onViewportEnter?: ViewportEventHandler;
-    onViewportLeave?: ViewportEventHandler;
-    viewport?: ViewportOptions;
+    type: false;
 }
-
 /**
- * Either a string, or array of strings, that reference variants defined via the `variants` prop.
  * @public
  */
-declare type VariantLabels = string | string[];
-interface TransformProperties {
-    x?: string | number;
-    y?: string | number;
-    z?: string | number;
-    translateX?: string | number;
-    translateY?: string | number;
-    translateZ?: string | number;
-    rotate?: string | number;
-    rotateX?: string | number;
-    rotateY?: string | number;
-    rotateZ?: string | number;
-    scale?: string | number;
-    scaleX?: string | number;
-    scaleY?: string | number;
-    scaleZ?: string | number;
-    skew?: string | number;
-    skewX?: string | number;
-    skewY?: string | number;
-    originX?: string | number;
-    originY?: string | number;
-    originZ?: string | number;
-    perspective?: string | number;
-    transformPerspective?: string | number;
-}
+declare type PermissiveTransitionDefinition = {
+    [key: string]: any;
+};
 /**
  * @public
  */
-interface SVGPathProperties {
-    pathLength?: number;
-    pathOffset?: number;
-    pathSpacing?: number;
-}
-interface CustomStyles {
-    /**
-     * Framer Library custom prop types. These are not actually supported in Motion - preferably
-     * we'd have a way of external consumers injecting supported styles into this library.
-     */
-    size?: string | number;
-    radius?: string | number;
-    shadow?: string;
-    image?: string;
-}
-declare type MakeMotion<T> = MakeCustomValueType<{
-    [K in keyof T]: T[K] | MotionValue<number> | MotionValue<string> | MotionValue<any>;
-}>;
-declare type MotionCSS = MakeMotion<Omit$1<CSSProperties, "rotate" | "scale" | "perspective">>;
+declare type TransitionDefinition = Tween | Spring | Keyframes | Inertia | Just | None | PermissiveTransitionDefinition;
+declare type TransitionMap = Orchestration & {
+    [key: string]: TransitionDefinition;
+};
 /**
+ * Transition props
+ *
  * @public
  */
-declare type MotionTransform = MakeMotion<TransformProperties>;
+declare type Transition = (Orchestration & Repeat & TransitionDefinition) | (Orchestration & Repeat & TransitionMap);
+declare type Omit$1<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+declare type CSSPropertiesWithoutTransitionOrSingleTransforms = Omit$1<CSSProperties, "transition" | "rotate" | "scale" | "perspective">;
+declare type TargetProperties = CSSPropertiesWithoutTransitionOrSingleTransforms & SVGAttributes<SVGElement> & TransformProperties & CustomStyles & SVGPathProperties;
 /**
  * @public
  */
-declare type MotionStyle = MotionCSS & MotionTransform & MakeMotion<SVGPathProperties> & MakeCustomValueType<CustomStyles>;
+declare type MakeCustomValueType<T> = {
+    [K in keyof T]: T[K] | CustomValueType;
+};
 /**
  * @public
  */
-interface RelayoutInfo {
-    delta: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-}
+declare type Target = MakeCustomValueType<TargetProperties>;
 /**
  * @public
  */
-declare type ResolveLayoutTransition = (info: RelayoutInfo) => Transition | boolean;
+declare type MakeKeyframes<T> = {
+    [K in keyof T]: T[K] | T[K][] | [null, ...T[K][]];
+};
 /**
  * @public
  */
-interface AnimationProps {
-    /**
-     * Properties, variant label or array of variant labels to start in.
-     *
-     * Set to `false` to initialise with the values in `animate` (disabling the mount animation)
-     *
-     * ```jsx
-     * // As values
-     * <motion.div initial={{ opacity: 1 }} />
-     *
-     * // As variant
-     * <motion.div initial="visible" variants={variants} />
-     *
-     * // Multiple variants
-     * <motion.div initial={["visible", "active"]} variants={variants} />
-     *
-     * // As false (disable mount animation)
-     * <motion.div initial={false} animate={{ opacity: 0 }} />
-     * ```
-     */
-    initial?: boolean | Target | VariantLabels;
-    /**
-     * Values to animate to, variant label(s), or `AnimationControls`.
-     *
-     * ```jsx
-     * // As values
-     * <motion.div animate={{ opacity: 1 }} />
-     *
-     * // As variant
-     * <motion.div animate="visible" variants={variants} />
-     *
-     * // Multiple variants
-     * <motion.div animate={["visible", "active"]} variants={variants} />
-     *
-     * // AnimationControls
-     * <motion.div animate={animation} />
-     * ```
-     */
-    animate?: AnimationControls | TargetAndTransition | VariantLabels | boolean;
+declare type TargetWithKeyframes = MakeKeyframes<Target>;
+/**
+ * An object that specifies values to animate to. Each value may be set either as
+ * a single value, or an array of values.
+ *
+ * It may also option contain these properties:
+ *
+ * - `transition`: Specifies transitions for all or individual values.
+ * - `transitionEnd`: Specifies values to set when the animation finishes.
+ *
+ * ```jsx
+ * const target = {
+ *   x: "0%",
+ *   opacity: 0,
+ *   transition: { duration: 1 },
+ *   transitionEnd: { display: "none" }
+ * }
+ * ```
+ *
+ * @public
+ */
+declare type TargetAndTransition = TargetWithKeyframes & {
+    transition?: Transition;
+    transitionEnd?: Target;
+};
+declare type TargetResolver = (custom: any, current: Target, velocity: Target) => TargetAndTransition | string;
+/**
+ * @public
+ */
+declare type Variant = TargetAndTransition | TargetResolver;
+/**
+ * @public
+ */
+declare type Variants = {
+    [key: string]: Variant;
+};
+/**
+ * @public
+ */
+interface CustomValueType {
+    mix: (from: any, to: any) => (p: number) => number | string;
+    toValue: () => number | string;
+}
+
+/**
+ * @public
+ */
+declare type ControlsAnimationDefinition = string | string[] | TargetAndTransition | TargetResolver;
+/**
+ * @public
+ */
+interface AnimationControls {
     /**
-     * A target to animate to when this component is removed from the tree.
-     *
-     * This component **must** be the first animatable child of an `AnimatePresence` to enable this exit animation.
+     * Starts an animation on all linked components.
      *
-     * This limitation exists because React doesn't allow components to defer unmounting until after
-     * an animation is complete. Once this limitation is fixed, the `AnimatePresence` component will be unnecessary.
+     * @remarks
      *
      * ```jsx
-     * import { AnimatePresence, motion } from 'framer-motion'
-     *
-     * export const MyComponent = ({ isVisible }) => {
-     *   return (
-     *     <AnimatePresence>
-     *        {isVisible && (
-     *          <motion.div
-     *            initial={{ opacity: 0 }}
-     *            animate={{ opacity: 1 }}
-     *            exit={{ opacity: 0 }}
-     *          />
-     *        )}
-     *     </AnimatePresence>
-     *   )
-     * }
+     * controls.start("variantLabel")
+     * controls.start({
+     *   x: 0,
+     *   transition: { duration: 1 }
+     * })
      * ```
-     */
-    exit?: TargetAndTransition | VariantLabels;
-    /**
-     * Variants allow you to define animation states and organise them by name. They allow
-     * you to control animations throughout a component tree by switching a single `animate` prop.
      *
-     * Using `transition` options like `delayChildren` and `staggerChildren`, you can orchestrate
-     * when children animations play relative to their parent.
-
+     * @param definition - Properties or variant label to animate to
+     * @param transition - Optional `transtion` to apply to a variant
+     * @returns - A `Promise` that resolves when all animations have completed.
      *
-     * After passing variants to one or more `motion` component's `variants` prop, these variants
-     * can be used in place of values on the `animate`, `initial`, `whileFocus`, `whileTap` and `whileHover` props.
+     * @public
+     */
+    start(definition: ControlsAnimationDefinition, transitionOverride?: Transition): Promise<any>;
+    /**
+     * Instantly set to a set of properties or a variant.
      *
      * ```jsx
-     * const variants = {
-     *   active: {
-     *       backgroundColor: "#f00"
-     *   },
-     *   inactive: {
-     *     backgroundColor: "#fff",
-     *     transition: { duration: 2 }
-     *   }
-     * }
+     * // With properties
+     * controls.set({ opacity: 0 })
      *
-     * <motion.div variants={variants} animate="active" />
+     * // With variants
+     * controls.set("hidden")
      * ```
+     *
+     * @privateRemarks
+     * We could perform a similar trick to `.start` where this can be called before mount
+     * and we maintain a list of of pending actions that get applied on mount. But the
+     * expectation of `set` is that it happens synchronously and this would be difficult
+     * to do before any children have even attached themselves. It's also poor practise
+     * and we should discourage render-synchronous `.start` calls rather than lean into this.
+     *
+     * @public
      */
-    variants?: Variants;
+    set(definition: ControlsAnimationDefinition): void;
     /**
-     * Default transition. If no `transition` is defined in `animate`, it will use the transition defined here.
-     * ```jsx
-     * const spring = {
-     *   type: "spring",
-     *   damping: 10,
-     *   stiffness: 100
-     * }
+     * Stops animations on all linked components.
      *
-     * <motion.div transition={spring} animate={{ scale: 1.2 }} />
+     * ```jsx
+     * controls.stop()
      * ```
+     *
+     * @public
      */
-    transition?: Transition;
+    stop(): void;
+    mount(): () => void;
+}
+
+interface Point {
+    x: number;
+    y: number;
+}
+interface Axis {
+    min: number;
+    max: number;
+}
+interface Box {
+    x: Axis;
+    y: Axis;
+}
+interface BoundingBox {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+interface AxisDelta {
+    translate: number;
+    scale: number;
+    origin: number;
+    originPoint: number;
+}
+interface Delta {
+    x: AxisDelta;
+    y: AxisDelta;
 }
+declare type TransformPoint = (point: Point) => Point;
+
 /**
+ * Passed in to pan event handlers like `onPan` the `PanInfo` object contains
+ * information about the current state of the tap gesture such as its
+ * `point`, `delta`, `offset` and `velocity`.
+ *
+ * ```jsx
+ * <motion.div onPan={(event, info) => {
+ *   console.log(info.point.x, info.point.y)
+ * }} />
+ * ```
+ *
  * @public
  */
-interface MotionAdvancedProps {
+interface PanInfo {
     /**
-     * Custom data to use to resolve dynamic variants differently for each animating component.
+     * Contains `x` and `y` values for the current pan position relative
+     * to the device or page.
      *
      * ```jsx
-     * const variants = {
-     *   visible: (custom) => ({
-     *     opacity: 1,
-     *     transition: { delay: custom * 0.2 }
-     *   })
+     * function onPan(event, info) {
+     *   console.log(info.point.x, info.point.y)
      * }
      *
-     * <motion.div custom={0} animate="visible" variants={variants} />
-     * <motion.div custom={1} animate="visible" variants={variants} />
-     * <motion.div custom={2} animate="visible" variants={variants} />
+     * <motion.div onPan={onPan} />
      * ```
      *
      * @public
      */
-    custom?: any;
-    /**
-     * @public
-     * Set to `false` to prevent inheriting variant changes from its parent.
-     */
-    inherit?: boolean;
-}
-/**
- * Props for `motion` components.
- *
- * @public
- */
-interface MotionProps extends AnimationProps, VisualElementLifecycles, PanHandlers, TapHandlers, HoverHandlers, FocusHandlers, ViewportProps, DraggableProps, LayoutProps, MotionAdvancedProps {
+    point: Point;
     /**
-     *
-     * The React DOM `style` prop, enhanced with support for `MotionValue`s and separate `transform` values.
+     * Contains `x` and `y` values for the distance moved since
+     * the last event.
      *
      * ```jsx
-     * export const MyComponent = () => {
-     *   const x = useMotionValue(0)
-     *
-     *   return <motion.div style={{ x, opacity: 1, scale: 0.5 }} />
+     * function onPan(event, info) {
+     *   console.log(info.delta.x, info.delta.y)
      * }
+     *
+     * <motion.div onPan={onPan} />
      * ```
+     *
+     * @public
      */
-    style?: MotionStyle;
+    delta: Point;
     /**
-     * By default, Framer Motion generates a `transform` property with a sensible transform order. `transformTemplate`
-     * can be used to create a different order, or to append/preprend the automatically generated `transform` property.
+     * Contains `x` and `y` values for the distance moved from
+     * the first pan event.
      *
      * ```jsx
-     * <motion.div
-     *   style={{ x: 0, rotate: 180 }}
-     *   transformTemplate={
-     *     ({ x, rotate }) => `rotate(${rotate}deg) translateX(${x}px)`
-     *   }
-     * />
-     * ```
+     * function onPan(event, info) {
+     *   console.log(info.offset.x, info.offset.y)
+     * }
      *
-     * @param transform - The latest animated transform props.
-     * @param generatedTransform - The transform string as automatically generated by Framer Motion
+     * <motion.div onPan={onPan} />
+     * ```
      *
      * @public
      */
-    transformTemplate?(transform: TransformProperties, generatedTransform: string): string;
+    offset: Point;
     /**
-     * Internal.
-     *
-     * This allows values to be transformed before being animated or set as styles.
+     * Contains `x` and `y` values for the current velocity of the pointer, in px/ms.
      *
-     * For instance, this allows custom values in Framer Library like `size` to be converted into `width` and `height`.
-     * It also allows us a chance to take a value like `Color` and convert it to an animatable color string.
+     * ```jsx
+     * function onPan(event, info) {
+     *   console.log(info.velocity.x, info.velocity.y)
+     * }
      *
-     * A few structural typing changes need making before this can be a public property:
-     * - Allow `Target` values to be appended by user-defined types (delete `CustomStyles` - does `size` throw a type error?)
-     * - Extract `CustomValueType` as a separate user-defined type (delete `CustomValueType` and animate a `Color` - does this throw a type error?).
+     * <motion.div onPan={onPan} />
+     * ```
      *
-     * @param values -
+     * @public
      */
-    transformValues?<V extends ResolvedValues>(values: V): V;
+    velocity: Point;
 }
 
+declare type ReducedMotionConfig = "always" | "never" | "user";
 /**
  * @public
  */
-declare type ResolvedKeyframesTarget = [null, ...number[]] | number[] | [null, ...string[]] | string[];
+interface MotionConfigContext {
+    /**
+     * Internal, exported only for usage in Framer
+     */
+    transformPagePoint: TransformPoint;
+    /**
+     * Internal. Determines whether this is a static context ie the Framer canvas. If so,
+     * it'll disable all dynamic functionality.
+     */
+    isStatic: boolean;
+    /**
+     * Defines a new default transition for the entire tree.
+     *
+     * @public
+     */
+    transition?: Transition;
+    /**
+     * If true, will respect the device prefersReducedMotion setting by switching
+     * transform animations off.
+     *
+     * @public
+     */
+    reducedMotion?: ReducedMotionConfig;
+}
 /**
  * @public
  */
-declare type KeyframesTarget = ResolvedKeyframesTarget | [null, ...CustomValueType[]] | CustomValueType[];
+declare const MotionConfigContext: React$1.Context<MotionConfigContext>;
+
+declare type IsValidProp = (key: string) => boolean;
+declare function filterProps(props: MotionProps, isDom: boolean, forwardMotionProps: boolean): {};
+
+interface MotionConfigProps extends Partial<MotionConfigContext> {
+    children?: React$1.ReactNode;
+    isValidProp?: IsValidProp;
+}
 /**
+ * `MotionConfig` is used to set configuration options for all children `motion` components.
+ *
+ * ```jsx
+ * import { motion, MotionConfig } from "framer-motion"
+ *
+ * export function App() {
+ *   return (
+ *     <MotionConfig transition={{ type: "spring" }}>
+ *       <motion.div animate={{ x: 100 }} />
+ *     </MotionConfig>
+ *   )
+ * }
+ * ```
+ *
  * @public
  */
-declare type ResolvedSingleTarget = string | number;
+declare function MotionConfig({ children, isValidProp, ...config }: MotionConfigProps): JSX.Element;
+
+declare class NodeStack {
+    lead?: IProjectionNode;
+    prevLead?: IProjectionNode;
+    members: IProjectionNode[];
+    add(node: IProjectionNode): void;
+    remove(node: IProjectionNode): void;
+    relegate(node: IProjectionNode): boolean;
+    promote(node: IProjectionNode, preserveFollowOpacity?: boolean): void;
+    exitAnimationComplete(): void;
+    scheduleRender(): void;
+    /**
+     * Clear any leads that have been removed this render to prevent them from being
+     * used in future animations and to prevent memory leaks
+     */
+    removeLeadSnapshot(): void;
+}
+
 /**
  * @public
  */
-declare type SingleTarget = ResolvedSingleTarget | CustomValueType;
+interface AnimationPlaybackControls {
+    stop: () => void;
+    isAnimating: () => boolean;
+}
 /**
  * @public
  */
-declare type ResolvedValueTarget = ResolvedSingleTarget | ResolvedKeyframesTarget;
+interface AnimationPlaybackLifecycles<V> {
+    onUpdate?: (latest: V) => void;
+    onPlay?: () => void;
+    onComplete?: () => void;
+    onRepeat?: () => void;
+    onStop?: () => void;
+}
 /**
  * @public
  */
-declare type ValueTarget = SingleTarget | KeyframesTarget;
+declare type AnimationOptions$1<V> = (Tween | Spring) & AnimationPlaybackLifecycles<V> & {
+    delay?: number;
+    type?: "tween" | "spring";
+};
 /**
- * A function that accepts a progress value between `0` and `1` and returns a
- * new one.
+ * Animate a single value or a `MotionValue`.
  *
- * ```jsx
- * <motion.div
- *   animate={{ opacity: 0 }}
- *   transition={{
- *     duration: 1,
- *     ease: progress => progress * progress
- *   }}
- * />
- * ```
+ * The first argument is either a `MotionValue` to animate, or an initial animation value.
  *
- * @public
- */
-declare type EasingFunction = (v: number) => number;
-/**
- * The easing function to use. Set as one of:
+ * The second is either a value to animate to, or an array of keyframes to animate through.
  *
- * - The name of an in-built easing function.
- * - An array of four numbers to define a cubic bezier curve.
- * - An easing function, that accepts and returns a progress value between `0` and `1`.
+ * The third argument can be either tween or spring options, and optional lifecycle methods: `onUpdate`, `onPlay`, `onComplete`, `onRepeat` and `onStop`.
  *
- * @public
- */
-declare type Easing = [number, number, number, number] | "linear" | "easeIn" | "easeOut" | "easeInOut" | "circIn" | "circOut" | "circInOut" | "backIn" | "backOut" | "backInOut" | "anticipate" | EasingFunction;
-/**
- * Options for orchestrating the timing of animations.
+ * Returns `AnimationPlaybackControls`, currently just a `stop` method.
+ *
+ * ```javascript
+ * const x = useMotionValue(0)
+ *
+ * useEffect(() => {
+ *   const controls = animate(x, 100, {
+ *     type: "spring",
+ *     stiffness: 2000,
+ *     onComplete: v => {}
+ *   })
+ *
+ *   return controls.stop
+ * })
+ * ```
  *
  * @public
  */
-interface Orchestration {
-    /**
-     * Delay the animation by this duration (in seconds). Defaults to `0`.
-     *
-     * @remarks
-     * ```javascript
-     * const transition = {
-     *   delay: 0.2
-     * }
-     * ```
-     *
-     * @public
-     */
-    delay?: number;
-    /**
-     * Describes the relationship between the transition and its children. Set
-     * to `false` by default.
-     *
-     * @remarks
-     * When using variants, the transition can be scheduled in relation to its
-     * children with either `"beforeChildren"` to finish this transition before
-     * starting children transitions, `"afterChildren"` to finish children
-     * transitions before starting this transition.
-     *
-     * ```jsx
-     * const list = {
-     *   hidden: {
-     *     opacity: 0,
-     *     transition: { when: "afterChildren" }
-     *   }
-     * }
-     *
-     * const item = {
-     *   hidden: {
-     *     opacity: 0,
-     *     transition: { duration: 2 }
-     *   }
-     * }
-     *
-     * return (
-     *   <motion.ul variants={list} animate="hidden">
-     *     <motion.li variants={item} />
-     *     <motion.li variants={item} />
-     *   </motion.ul>
-     * )
-     * ```
-     *
-     * @public
-     */
-    when?: false | "beforeChildren" | "afterChildren" | string;
-    /**
-     * When using variants, children animations will start after this duration
-     * (in seconds). You can add the `transition` property to both the `Frame` and the `variant` directly. Adding it to the `variant` generally offers more flexibility, as it allows you to customize the delay per visual state.
-     *
-     * ```jsx
-     * const container = {
-     *   hidden: { opacity: 0 },
-     *   show: {
-     *     opacity: 1,
-     *     transition: {
-     *       delayChildren: 0.5
-     *     }
-     *   }
-     * }
-     *
-     * const item = {
-     *   hidden: { opacity: 0 },
-     *   show: { opacity: 1 }
-     * }
-     *
-     * return (
-     *   <motion.ul
-     *     variants={container}
-     *     initial="hidden"
-     *     animate="show"
-     *   >
-     *     <motion.li variants={item} />
-     *     <motion.li variants={item} />
-     *   </motion.ul>
-     * )
-     * ```
-     *
-     * @public
-     */
-    delayChildren?: number;
-    /**
-     * When using variants, animations of child components can be staggered by this
-     * duration (in seconds).
-     *
-     * For instance, if `staggerChildren` is `0.01`, the first child will be
-     * delayed by `0` seconds, the second by `0.01`, the third by `0.02` and so
-     * on.
-     *
-     * The calculated stagger delay will be added to `delayChildren`.
-     *
-     * ```jsx
-     * const container = {
-     *   hidden: { opacity: 0 },
-     *   show: {
-     *     opacity: 1,
-     *     transition: {
-     *       staggerChildren: 0.5
-     *     }
-     *   }
-     * }
-     *
-     * const item = {
-     *   hidden: { opacity: 0 },
-     *   show: { opacity: 1 }
-     * }
+declare function animate<V>(from: MotionValue<V> | V, to: V | V[], transition?: AnimationOptions$1<V>): AnimationPlaybackControls;
+
+interface WithDepth {
+    depth: number;
+}
+
+declare class FlatTree {
+    private children;
+    private isDirty;
+    add(child: WithDepth): void;
+    remove(child: WithDepth): void;
+    forEach(callback: (child: WithDepth) => void): void;
+}
+
+interface Measurements {
+    measuredBox: Box;
+    layoutBox: Box;
+    latestValues: ResolvedValues;
+    isShared?: boolean;
+}
+declare type LayoutEvents = "willUpdate" | "didUpdate" | "beforeMeasure" | "measure" | "projectionUpdate" | "animationStart" | "animationComplete";
+interface IProjectionNode<I = unknown> {
+    elementId: number | undefined;
+    parent?: IProjectionNode;
+    relativeParent?: IProjectionNode;
+    root?: IProjectionNode;
+    children: Set<IProjectionNode>;
+    path: IProjectionNode[];
+    nodes?: FlatTree;
+    depth: number;
+    instance: I;
+    mount: (node: I, isLayoutDirty?: boolean) => void;
+    unmount: () => void;
+    options: ProjectionNodeOptions;
+    setOptions(options: ProjectionNodeOptions): void;
+    layout?: Measurements;
+    snapshot?: Measurements;
+    target?: Box;
+    relativeTarget?: Box;
+    targetDelta?: Delta;
+    targetWithTransforms?: Box;
+    scroll?: Point;
+    isScrollRoot?: boolean;
+    treeScale?: Point;
+    projectionDelta?: Delta;
+    projectionDeltaWithTransform?: Delta;
+    latestValues: ResolvedValues;
+    isLayoutDirty: boolean;
+    shouldResetTransform: boolean;
+    prevTransformTemplateValue: string | undefined;
+    isUpdateBlocked(): boolean;
+    updateManuallyBlocked: boolean;
+    updateBlockedByResize: boolean;
+    blockUpdate(): void;
+    unblockUpdate(): void;
+    isUpdating: boolean;
+    needsReset: boolean;
+    startUpdate(): void;
+    willUpdate(notifyListeners?: boolean): void;
+    didUpdate(): void;
+    measure(removeTransform?: boolean): Measurements;
+    measurePageBox(): Box;
+    updateLayout(): void;
+    updateSnapshot(): void;
+    clearSnapshot(): void;
+    updateScroll(): void;
+    scheduleUpdateProjection(): void;
+    scheduleCheckAfterUnmount(): void;
+    checkUpdateFailed(): void;
+    potentialNodes: Map<number, IProjectionNode>;
+    sharedNodes: Map<string, NodeStack>;
+    registerPotentialNode(id: number, node: IProjectionNode): void;
+    registerSharedNode(id: string, node: IProjectionNode): void;
+    getStack(): NodeStack | undefined;
+    isVisible: boolean;
+    hide(): void;
+    show(): void;
+    scheduleRender(notifyAll?: boolean): void;
+    getClosestProjectingParent(): IProjectionNode | undefined;
+    setTargetDelta(delta: Delta): void;
+    resetTransform(): void;
+    resetRotation(): void;
+    applyTransform(box: Box, transformOnly?: boolean): Box;
+    resolveTargetDelta(): void;
+    calcProjection(): void;
+    getProjectionStyles(styles?: MotionStyle): MotionStyle | undefined;
+    clearMeasurements(): void;
+    resetTree(): void;
+    animationValues?: ResolvedValues;
+    currentAnimation?: AnimationPlaybackControls;
+    isTreeAnimating?: boolean;
+    isAnimationBlocked?: boolean;
+    isTreeAnimationBlocked: () => boolean;
+    setAnimationOrigin(delta: Delta): void;
+    startAnimation(transition: Transition): void;
+    finishAnimation(): void;
+    isLead(): boolean;
+    promote(options?: {
+        needsReset?: boolean;
+        transition?: Transition;
+        preserveFollowOpacity?: boolean;
+    }): void;
+    relegate(): boolean;
+    resumeFrom?: IProjectionNode;
+    resumingFrom?: IProjectionNode;
+    isPresent?: boolean;
+    addEventListener(name: LayoutEvents, handler: any): VoidFunction;
+    notifyListeners(name: LayoutEvents, ...args: any): void;
+    hasListeners(name: LayoutEvents): boolean;
+    preserveOpacity?: boolean;
+}
+interface ProjectionNodeOptions {
+    animate?: boolean;
+    layoutScroll?: boolean;
+    alwaysMeasureLayout?: boolean;
+    scheduleRender?: VoidFunction;
+    onExitComplete?: VoidFunction;
+    animationType?: "size" | "position" | "both" | "preserve-aspect";
+    layoutId?: string;
+    layout?: boolean | string;
+    visualElement?: VisualElement;
+    crossfade?: boolean;
+    transition?: Transition;
+    initialPromotionConfig?: InitialPromotionConfig;
+}
+
+interface SwitchLayoutGroup {
+    register?: (member: IProjectionNode) => void;
+    deregister?: (member: IProjectionNode) => void;
+}
+declare type InitialPromotionConfig = {
+    /**
+     * The initial transition to use when the elements in this group mount (and automatically promoted).
+     * Subsequent updates should provide a transition in the promote method.
+     */
+    transition?: Transition;
+    /**
+     * If the follow tree should preserve its opacity when the lead is promoted on mount
+     */
+    shouldPreserveFollowOpacity?: (member: IProjectionNode) => boolean;
+};
+declare type SwitchLayoutGroupContext = SwitchLayoutGroup & InitialPromotionConfig;
+/**
+ * Internal, exported only for usage in Framer
+ */
+declare const SwitchLayoutGroupContext: React$1.Context<SwitchLayoutGroupContext>;
+
+interface VisualState<Instance, RenderState> {
+    renderState: RenderState;
+    latestValues: ResolvedValues;
+    mount?: (instance: Instance) => void;
+}
+declare type UseVisualState<Instance, RenderState> = (props: MotionProps, isStatic: boolean) => VisualState<Instance, RenderState>;
+interface UseVisualStateConfig<Instance, RenderState> {
+    scrapeMotionValuesFromProps: ScrapeMotionValuesFromProps;
+    createRenderState: () => RenderState;
+    onMount?: (props: MotionProps, instance: Instance, visualState: VisualState<Instance, RenderState>) => void;
+}
+declare const makeUseVisualState: <I, RS>(config: UseVisualStateConfig<I, RS>) => UseVisualState<I, RS>;
+
+/**
+ * @public
+ */
+interface FeatureProps<T = unknown> extends MotionProps {
+    visualElement: VisualElement<T>;
+}
+declare type FeatureNames = {
+    animation: true;
+    exit: true;
+    drag: true;
+    tap: true;
+    focus: true;
+    hover: true;
+    pan: true;
+    inView: true;
+    measureLayout: true;
+};
+declare type FeatureComponent = React$1.ComponentType<React$1.PropsWithChildren<FeatureProps>>;
+/**
+ * @public
+ */
+interface FeatureDefinition {
+    isEnabled: (props: MotionProps) => boolean;
+    Component?: FeatureComponent;
+}
+interface FeatureComponents {
+    animation?: FeatureComponent;
+    exit?: FeatureComponent;
+    drag?: FeatureComponent;
+    tap?: FeatureComponent;
+    focus?: FeatureComponent;
+    hover?: FeatureComponent;
+    pan?: FeatureComponent;
+    inView?: FeatureComponent;
+    measureLayout?: FeatureComponent;
+}
+interface FeatureBundle extends FeatureComponents {
+    renderer: CreateVisualElement<any>;
+    projectionNodeConstructor?: any;
+}
+declare type LazyFeatureBundle$1 = () => Promise<FeatureBundle>;
+declare type FeatureDefinitions = {
+    [K in keyof FeatureNames]: FeatureDefinition;
+};
+declare type LoadedFeatures = FeatureDefinitions & {
+    projectionNodeConstructor?: any;
+};
+declare type RenderComponent<Instance, RenderState> = (Component: string | React$1.ComponentType<React$1.PropsWithChildren<unknown>>, props: MotionProps, projectionId: number | undefined, ref: React$1.Ref<Instance>, visualState: VisualState<Instance, RenderState>, isStatic: boolean, visualElement?: VisualElement) => any;
+
+declare enum AnimationType {
+    Animate = "animate",
+    Hover = "whileHover",
+    Tap = "whileTap",
+    Drag = "whileDrag",
+    Focus = "whileFocus",
+    InView = "whileInView",
+    Exit = "exit"
+}
+
+declare type AnimationDefinition = VariantLabels | TargetAndTransition | TargetResolver;
+declare type AnimationOptions = {
+    delay?: number;
+    transitionOverride?: Transition;
+    custom?: any;
+    type?: AnimationType;
+};
+declare function animateVisualElement(visualElement: VisualElement, definition: AnimationDefinition, options?: AnimationOptions): Promise<void>;
+
+interface AnimationState {
+    animateChanges: (options?: AnimationOptions, type?: AnimationType) => Promise<any>;
+    setActive: (type: AnimationType, isActive: boolean, options?: AnimationOptions) => Promise<any>;
+    setAnimateFunction: (fn: any) => void;
+    getState: () => {
+        [key: string]: AnimationTypeState;
+    };
+}
+interface AnimationTypeState {
+    isActive: boolean;
+    protectedKeys: {
+        [key: string]: true;
+    };
+    needsAnimating: {
+        [key: string]: boolean;
+    };
+    prevResolvedValues: {
+        [key: string]: any;
+    };
+    prevProp?: VariantLabels | TargetAndTransition;
+}
+
+/**
+ * A VisualElement is an imperative abstraction around UI elements such as
+ * HTMLElement, SVGElement, Three.Object3D etc.
+ */
+declare abstract class VisualElement<Instance = unknown, RenderState = unknown, Options extends {} = {}> {
+    /**
+     * VisualElements are arranged in trees mirroring that of the React tree.
+     * Each type of VisualElement has a unique name, to detect when we're crossing
+     * type boundaries within that tree.
+     */
+    abstract type: string;
+    /**
+     * An `Array.sort` compatible function that will compare two Instances and
+     * compare their respective positions within the tree.
+     */
+    abstract sortInstanceNodePosition(a: Instance, b: Instance): number;
+    /**
+     * Take a target and make it animatable. For instance if provided
+     * height: "auto" we need to measure height in pixels and animate that instead.
+     */
+    abstract makeTargetAnimatableFromInstance(target: TargetAndTransition, props: MotionProps, isLive: boolean): TargetAndTransition;
+    /**
+     * Measure the viewport-relative bounding box of the Instance.
+     */
+    abstract measureInstanceViewportBox(instance: Instance, props: MotionProps & MotionConfigProps): Box;
+    /**
+     * When a value has been removed from all animation props we need to
+     * pick a target to animate back to. For instance, for HTMLElements
+     * we can look in the style prop.
+     */
+    abstract getBaseTargetFromProps(props: MotionProps, key: string): string | number | undefined | MotionValue;
+    /**
+     * When we first animate to a value we need to animate it *from* a value.
+     * Often this have been specified via the initial prop but it might be
+     * that the value needs to be read from the Instance.
+     */
+    abstract readValueFromInstance(instance: Instance, key: string, options: Options): string | number | null | undefined;
+    /**
+     * When a value has been removed from the VisualElement we use this to remove
+     * it from the inherting class' unique render state.
+     */
+    abstract removeValueFromRenderState(key: string, renderState: RenderState): void;
+    /**
+     * Run before a React or VisualElement render, builds the latest motion
+     * values into an Instance-specific format. For example, HTMLVisualElement
+     * will use this step to build `style` and `var` values.
+     */
+    abstract build(renderState: RenderState, latestValues: ResolvedValues, options: Options, props: MotionProps): void;
+    /**
+     * Apply the built values to the Instance. For example, HTMLElements will have
+     * styles applied via `setProperty` and the style attribute, whereas SVGElements
+     * will have values applied to attributes.
+     */
+    abstract renderInstance(instance: Instance, renderState: RenderState, styleProp?: MotionStyle, projection?: IProjectionNode): void;
+    /**
+     * This method takes React props and returns found MotionValues. For example, HTML
+     * MotionValues will be found within the style prop, whereas for Three.js within attribute arrays.
+     *
+     * This isn't an abstract method as it needs calling in the constructor, but it is
+     * intended to be one.
+     */
+    scrapeMotionValuesFromProps(_props: MotionProps): {
+        [key: string]: MotionValue | string | number;
+    };
+    /**
+     * A reference to the current underlying Instance, e.g. a HTMLElement
+     * or Three.Mesh etc.
+     */
+    current: Instance | null;
+    /**
+     * A reference to the parent VisualElement (if exists).
+     */
+    parent: VisualElement | undefined;
+    /**
+     * A set containing references to this VisualElement's children.
+     */
+    children: Set<VisualElement<unknown, unknown, {}>>;
+    /**
+     * The depth of this VisualElement within the overall VisualElement tree.
+     */
+    depth: number;
+    /**
+     * The current render state of this VisualElement. Defined by inherting VisualElements.
+     */
+    renderState: RenderState;
+    /**
+     * An object containing the latest static values for each of this VisualElement's
+     * MotionValues.
+     */
+    latestValues: ResolvedValues;
+    /**
+     * Determine what role this visual element should take in the variant tree.
+     */
+    isVariantNode: boolean;
+    isControllingVariants: boolean;
+    /**
+     * If this component is part of the variant tree, it should track
+     * any children that are also part of the tree. This is essentially
+     * a shadow tree to simplify logic around how to stagger over children.
+     */
+    variantChildren?: Set<VisualElement>;
+    /**
+     * Decides whether this VisualElement should animate in reduced motion
+     * mode.
+     *
+     * TODO: This is currently set on every individual VisualElement but feels
+     * like it could be set globally.
+     */
+    shouldReduceMotion: boolean | null;
+    /**
+     * Normally, if a component is controlled by a parent's variants, it can
+     * rely on that ancestor to trigger animations further down the tree.
+     * However, if a component is created after its parent is mounted, the parent
+     * won't trigger that mount animation so the child needs to.
+     *
+     * TODO: This might be better replaced with a method isParentMounted
+     */
+    manuallyAnimateOnMount: boolean;
+    /**
+     * This can be set by AnimatePresence to force components that mount
+     * at the same time as it to mount as if they have initial={false} set.
+     */
+    blockInitialAnimation: boolean;
+    /**
+     * A reference to this VisualElement's projection node, used in layout animations.
+     */
+    projection?: IProjectionNode;
+    /**
+     * A map of all motion values attached to this visual element. Motion
+     * values are source of truth for any given animated value. A motion
+     * value might be provided externally by the component via props.
+     */
+    values: Map<string, MotionValue<any>>;
+    /**
+     * Tracks whether this VisualElement's React component is currently present
+     * within the defined React tree.
+     */
+    isPresent: boolean;
+    /**
+     * The AnimationState, this is hydrated by the animation Feature.
+     */
+    animationState?: AnimationState;
+    /**
+     * The options used to create this VisualElement. The Options type is defined
+     * by the inheriting VisualElement and is passed straight through to the render functions.
+     */
+    private readonly options;
+    /**
+     * A reference to the latest props provided to the VisualElement's host React component.
+     */
+    private props;
+    /**
+     * A map of every subscription that binds the provided or generated
+     * motion values onChange listeners to this visual element.
+     */
+    private valueSubscriptions;
+    /**
+     * A reference to the ReducedMotionConfig passed to the VisualElement's host React component.
+     */
+    private reducedMotionConfig;
+    /**
+     * On mount, this will be hydrated with a callback to disconnect
+     * this visual element from its parent on unmount.
+     */
+    private removeFromVariantTree;
+    /**
+     * A reference to the previously-provided motion values as returned
+     * from scrapeMotionValuesFromProps. We use the keys in here to determine
+     * if any motion values need to be removed after props are updated.
+     */
+    private prevMotionValues;
+    /**
+     * When values are removed from all animation props we need to search
+     * for a fallback value to animate to. These values are tracked in baseTarget.
+     */
+    private baseTarget;
+    /**
+     * Create an object of the values we initially animated from (if initial prop present).
+     */
+    private initialValues;
+    /**
+     * An object containing a SubscriptionManager for each active event.
+     */
+    private events;
+    /**
+     * An object containing an unsubscribe function for each prop event subscription.
+     * For example, every "Update" event can have multiple subscribers via
+     * VisualElement.on(), but only one of those can be defined via the onUpdate prop.
+     */
+    private propEventSubscriptions;
+    constructor({ parent, props, reducedMotionConfig, visualState, }: VisualElementOptions<Instance, RenderState>, options?: Options);
+    mount(instance: Instance): void;
+    unmount(): void;
+    private bindToMotionValue;
+    sortNodePosition(other: VisualElement<Instance>): number;
+    loadFeatures(renderedProps: MotionProps, isStrict?: boolean, preloadedFeatures?: FeatureBundle, projectionId?: number, ProjectionNodeConstructor?: any, initialLayoutGroupConfig?: SwitchLayoutGroupContext): JSX.Element[];
+    notifyUpdate: () => void;
+    triggerBuild(): void;
+    render: () => void;
+    scheduleRender: () => framesync.Process;
+    /**
+     * Measure the current viewport box with or without transforms.
+     * Only measures axis-aligned boxes, rotate and skew must be manually
+     * removed with a re-render to work.
+     */
+    measureViewportBox(): Box;
+    getStaticValue(key: string): string | number;
+    setStaticValue(key: string, value: string | number): void;
+    /**
+     * Make a target animatable by Popmotion. For instance, if we're
+     * trying to animate width from 100px to 100vw we need to measure 100vw
+     * in pixels to determine what we really need to animate to. This is also
+     * pluggable to support Framer's custom value types like Color,
+     * and CSS variables.
+     */
+    makeTargetAnimatable(target: TargetAndTransition, canMutate?: boolean): TargetAndTransition;
+    /**
+     * Update the provided props. Ensure any newly-added motion values are
+     * added to our map, old ones removed, and listeners updated.
+     */
+    setProps(props: MotionProps): void;
+    getProps(): MotionProps;
+    /**
+     * Returns the variant definition with a given name.
+     */
+    getVariant(name: string): Variant | undefined;
+    /**
+     * Returns the defined default transition on this component.
+     */
+    getDefaultTransition(): Transition | undefined;
+    getTransformPagePoint(): any;
+    getClosestVariantNode(): VisualElement | undefined;
+    getVariantContext(startAtParent?: boolean): undefined | VariantStateContext;
+    /**
+     * Add a child visual element to our set of children.
+     */
+    addVariantChild(child: VisualElement): (() => boolean) | undefined;
+    /**
+     * Add a motion value and bind it to this visual element.
+     */
+    addValue(key: string, value: MotionValue): void;
+    /**
+     * Remove a motion value and unbind any active subscriptions.
+     */
+    removeValue(key: string): void;
+    /**
+     * Check whether we have a motion value for this key
+     */
+    hasValue(key: string): boolean;
+    /**
+     * Get a motion value for this key. If called with a default
+     * value, we'll create one if none exists.
+     */
+    getValue(key: string, defaultValue?: string | number): MotionValue<any>;
+    /**
+     * If we're trying to animate to a previously unencountered value,
+     * we need to check for it in our state and as a last resort read it
+     * directly from the instance (which might have performance implications).
+     */
+    readValue(key: string): string | number | null | undefined;
+    /**
+     * Set the base target to later animate back to. This is currently
+     * only hydrated on creation and when we first read a value.
+     */
+    setBaseTarget(key: string, value: string | number): void;
+    /**
+     * Find the base target for a value thats been removed from all animation
+     * props.
+     */
+    getBaseTarget(key: string): any;
+    on<EventName extends keyof VisualElementEventCallbacks>(eventName: EventName, callback: VisualElementEventCallbacks[EventName]): VoidFunction;
+    notify<EventName extends keyof VisualElementEventCallbacks>(eventName: EventName, ...args: any): void;
+}
+
+interface DragControlOptions {
+    snapToCursor?: boolean;
+    cursorProgress?: Point;
+}
+
+/**
+ * Can manually trigger a drag gesture on one or more `drag`-enabled `motion` components.
+ *
+ * ```jsx
+ * const dragControls = useDragControls()
+ *
+ * function startDrag(event) {
+ *   dragControls.start(event, { snapToCursor: true })
+ * }
+ *
+ * return (
+ *   <>
+ *     <div onPointerDown={startDrag} />
+ *     <motion.div drag="x" dragControls={dragControls} />
+ *   </>
+ * )
+ * ```
+ *
+ * @public
+ */
+declare class DragControls {
+    private componentControls;
+    /**
+     * Start a drag gesture on every `motion` component that has this set of drag controls
+     * passed into it via the `dragControls` prop.
      *
-     * return (
-     *   <motion.ol
-     *     variants={container}
-     *     initial="hidden"
-     *     animate="show"
-     *   >
-     *     <motion.li variants={item} />
-     *     <motion.li variants={item} />
-     *   </motion.ol>
-     * )
+     * ```jsx
+     * dragControls.start(e, {
+     *   snapToCursor: true
+     * })
      * ```
      *
+     * @param event - PointerEvent
+     * @param options - Options
+     *
      * @public
      */
-    staggerChildren?: number;
+    start(event: React$1.MouseEvent | React$1.TouchEvent | React$1.PointerEvent | MouseEvent | TouchEvent | PointerEvent, options?: DragControlOptions): void;
+}
+/**
+ * Usually, dragging is initiated by pressing down on a `motion` component with a `drag` prop
+ * and moving it. For some use-cases, for instance clicking at an arbitrary point on a video scrubber, we
+ * might want to initiate that dragging from a different component than the draggable one.
+ *
+ * By creating a `dragControls` using the `useDragControls` hook, we can pass this into
+ * the draggable component's `dragControls` prop. It exposes a `start` method
+ * that can start dragging from pointer events on other components.
+ *
+ * ```jsx
+ * const dragControls = useDragControls()
+ *
+ * function startDrag(event) {
+ *   dragControls.start(event, { snapToCursor: true })
+ * }
+ *
+ * return (
+ *   <>
+ *     <div onPointerDown={startDrag} />
+ *     <motion.div drag="x" dragControls={dragControls} />
+ *   </>
+ * )
+ * ```
+ *
+ * @public
+ */
+declare function useDragControls(): DragControls;
+
+declare type DragElastic = boolean | number | Partial<BoundingBox>;
+/**
+ * @public
+ */
+interface DragHandlers {
     /**
-     * The direction in which to stagger children.
-     *
-     * A value of `1` staggers from the first to the last while `-1`
-     * staggers from the last to the first.
+     * Callback function that fires when dragging starts.
      *
      * ```jsx
-     * const container = {
-     *   hidden: { opacity: 0 },
-     *   show: {
-     *     opacity: 1,
-     *     transition: {
-     *       delayChildren: 0.5,
-     *       staggerDirection: -1
-     *     }
+     * <motion.div
+     *   drag
+     *   onDragStart={
+     *     (event, info) => console.log(info.point.x, info.point.y)
      *   }
-     * }
-     *
-     * const item = {
-     *   hidden: { opacity: 0 },
-     *   show: { opacity: 1 }
-     * }
-     *
-     * return (
-     *   <motion.ul
-     *     variants={container}
-     *     initial="hidden"
-     *     animate="show"
-     *   >
-     *     <motion.li variants={item} size={50} />
-     *     <motion.li variants={item} size={50} />
-     *   </motion.ul>
-     * )
+     * />
      * ```
      *
      * @public
      */
-    staggerDirection?: number;
-}
-interface Repeat {
+    onDragStart?(event: MouseEvent | TouchEvent | PointerEvent, info: PanInfo): void;
     /**
-     * The number of times to repeat the transition. Set to `Infinity` for perpetual repeating.
-     *
-     * Without setting `repeatType`, this will loop the animation.
+     * Callback function that fires when dragging ends.
      *
      * ```jsx
      * <motion.div
-     *   animate={{ rotate: 180 }}
-     *   transition={{ repeat: Infinity, duration: 2 }}
+     *   drag
+     *   onDragEnd={
+     *     (event, info) => console.log(info.point.x, info.point.y)
+     *   }
      * />
      * ```
      *
      * @public
      */
-    repeat?: number;
+    onDragEnd?(event: MouseEvent | TouchEvent | PointerEvent, info: PanInfo): void;
     /**
-     * How to repeat the animation. This can be either:
-     *
-     * "loop": Repeats the animation from the start
+     * Callback function that fires when the component is dragged.
      *
-     * "reverse": Alternates between forward and backwards playback
+     * ```jsx
+     * <motion.div
+     *   drag
+     *   onDrag={
+     *     (event, info) => console.log(info.point.x, info.point.y)
+     *   }
+     * />
+     * ```
      *
-     * "mirror": Switches `from` and `to` alternately
+     * @public
+     */
+    onDrag?(event: MouseEvent | TouchEvent | PointerEvent, info: PanInfo): void;
+    /**
+     * Callback function that fires a drag direction is determined.
      *
      * ```jsx
      * <motion.div
-     *   animate={{ rotate: 180 }}
-     *   transition={{
-     *     repeat: 1,
-     *     repeatType: "reverse",
-     *     duration: 2
-     *   }}
+     *   drag
+     *   dragDirectionLock
+     *   onDirectionLock={axis => console.log(axis)}
      * />
      * ```
      *
      * @public
      */
-    repeatType?: "loop" | "reverse" | "mirror";
+    onDirectionLock?(axis: "x" | "y"): void;
     /**
-     * When repeating an animation, `repeatDelay` will set the
-     * duration of the time to wait, in seconds, between each repetition.
+     * Callback function that fires when drag momentum/bounce transition finishes.
      *
      * ```jsx
      * <motion.div
-     *   animate={{ rotate: 180 }}
-     *   transition={{ repeat: Infinity, repeatDelay: 1 }}
+     *   drag
+     *   onDragTransitionEnd={() => console.log('Drag transition complete')}
      * />
      * ```
      *
      * @public
      */
-    repeatDelay?: number;
+    onDragTransitionEnd?(): void;
 }
 /**
- * An animation that animates between two or more values over a specific duration of time.
- * This is the default animation for non-physical values like `color` and `opacity`.
- *
  * @public
  */
-interface Tween extends Repeat {
+declare type InertiaOptions = Partial<Omit<Inertia, "velocity" | "type">>;
+/**
+ * @public
+ */
+interface DraggableProps extends DragHandlers {
     /**
-     * Set `type` to `"tween"` to use a duration-based tween animation.
-     * If any non-orchestration `transition` values are set without a `type` property,
-     * this is used as the default animation.
+     * Enable dragging for this element. Set to `false` by default.
+     * Set `true` to drag in both directions.
+     * Set `"x"` or `"y"` to only drag in a specific direction.
      *
      * ```jsx
-     * <motion.path
-     *   animate={{ pathLength: 1 }}
-     *   transition={{ duration: 2, type: "tween" }}
-     * />
+     * <motion.div drag="x" />
      * ```
-     *
-     * @public
      */
-    type?: "tween";
+    drag?: boolean | "x" | "y";
     /**
-     * The duration of the tween animation. Set to `0.3` by default, 0r `0.8` if animating a series of keyframes.
+     * Properties or variant label to animate to while the drag gesture is recognised.
      *
      * ```jsx
-     * const variants = {
-     *   visible: {
-     *     opacity: 1,
-     *     transition: { duration: 2 }
-     *   }
-     * }
+     * <motion.div whileDrag={{ scale: 1.2 }} />
      * ```
-     *
-     * @public
      */
-    duration?: number;
+    whileDrag?: VariantLabels | TargetAndTransition;
     /**
-     * The easing function to use. Set as one of the below.
-     *
-     * - The name of an existing easing function.
-     *
-     * - An array of four numbers to define a cubic bezier curve.
-     *
-     * - An easing function, that accepts and returns a value `0-1`.
-     *
-     * If the animating value is set as an array of multiple values for a keyframes
-     * animation, `ease` can be set as an array of easing functions to set different easings between
-     * each of those values.
-     *
+     * If `true`, this will lock dragging to the initially-detected direction. Defaults to `false`.
      *
      * ```jsx
-     * <motion.div
-     *   animate={{ opacity: 0 }}
-     *   transition={{ ease: [0.17, 0.67, 0.83, 0.67] }}
-     * />
+     * <motion.div drag dragDirectionLock />
      * ```
+     */
+    dragDirectionLock?: boolean;
+    /**
+     * Allows drag gesture propagation to child components. Set to `false` by
+     * default.
      *
-     * @public
+     * ```jsx
+     * <motion.div drag="x" dragPropagation />
+     * ```
      */
-    ease?: Easing | Easing[];
+    dragPropagation?: boolean;
     /**
-     * When animating keyframes, `times` can be used to determine where in the animation each keyframe is reached.
-     * Each value in `times` is a value between `0` and `1`, representing `duration`.
+     * Applies constraints on the permitted draggable area.
      *
-     * There must be the same number of `times` as there are keyframes.
-     * Defaults to an array of evenly-spread durations.
+     * It can accept an object of optional `top`, `left`, `right`, and `bottom` values, measured in pixels.
+     * This will define a distance the named edge of the draggable component.
+     *
+     * Alternatively, it can accept a `ref` to another component created with React's `useRef` hook.
+     * This `ref` should be passed both to the draggable component's `dragConstraints` prop, and the `ref`
+     * of the component you want to use as constraints.
      *
      * ```jsx
+     * // In pixels
      * <motion.div
-     *   animate={{ scale: [0, 1, 0.5, 1] }}
-     *   transition={{ times: [0, 0.1, 0.9, 1] }}
+     *   drag="x"
+     *   dragConstraints={{ left: 0, right: 300 }}
      * />
-     * ```
      *
-     * @public
+     * // As a ref to another component
+     * const MyComponent = () => {
+     *   const constraintsRef = useRef(null)
+     *
+     *   return (
+     *      <motion.div ref={constraintsRef}>
+     *          <motion.div drag dragConstraints={constraintsRef} />
+     *      </motion.div>
+     *   )
+     * }
+     * ```
      */
-    times?: number[];
+    dragConstraints?: false | Partial<BoundingBox> | RefObject<Element>;
     /**
-     * When animating keyframes, `easings` can be used to define easing functions between each keyframe. This array should be one item fewer than the number of keyframes, as these easings apply to the transitions between the keyframes.
+     * The degree of movement allowed outside constraints. 0 = no movement, 1 =
+     * full movement.
+     *
+     * Set to `0.5` by default. Can also be set as `false` to disable movement.
+     *
+     * By passing an object of `top`/`right`/`bottom`/`left`, individual values can be set
+     * per constraint. Any missing values will be set to `0`.
      *
      * ```jsx
      * <motion.div
-     *   animate={{ backgroundColor: ["#0f0", "#00f", "#f00"] }}
-     *   transition={{ easings: ["easeIn", "easeOut"] }}
+     *   drag
+     *   dragConstraints={{ left: 0, right: 300 }}
+     *   dragElastic={0.2}
      * />
      * ```
-     *
-     * @public
      */
-    easings?: Easing[];
+    dragElastic?: DragElastic;
     /**
-     * The value to animate from.
-     * By default, this is the current state of the animating value.
+     * Apply momentum from the pan gesture to the component when dragging
+     * finishes. Set to `true` by default.
      *
      * ```jsx
      * <motion.div
-     *   animate={{ rotate: 180 }}
-     *   transition={{ from: 90, duration: 2 }}
+     *   drag
+     *   dragConstraints={{ left: 0, right: 300 }}
+     *   dragMomentum={false}
      * />
      * ```
-     *
-     * @public
      */
-    from?: number | string;
-}
-/**
- * An animation that simulates spring physics for realistic motion.
- * This is the default animation for physical values like `x`, `y`, `scale` and `rotate`.
- *
- * @public
- */
-interface Spring extends Repeat {
+    dragMomentum?: boolean;
     /**
-     * Set `type` to `"spring"` to animate using spring physics for natural
-     * movement. Type is set to `"spring"` by default.
+     * Allows you to change dragging inertia parameters.
+     * When releasing a draggable Frame, an animation with type `inertia` starts. The animation is based on your dragging velocity. This property allows you to customize it.
+     * See {@link https://framer.com/api/animation/#inertia | Inertia} for all properties you can use.
      *
      * ```jsx
      * <motion.div
-     *   animate={{ rotate: 180 }}
-     *   transition={{ type: 'spring' }}
+     *   drag
+     *   dragTransition={{ bounceStiffness: 600, bounceDamping: 10 }}
      * />
      * ```
-     *
-     * @public
      */
-    type: "spring";
+    dragTransition?: InertiaOptions;
     /**
-     * Stiffness of the spring. Higher values will create more sudden movement.
-     * Set to `100` by default.
+     * Usually, dragging is initiated by pressing down on a component and moving it. For some
+     * use-cases, for instance clicking at an arbitrary point on a video scrubber, we
+     * might want to initiate dragging from a different component than the draggable one.
+     *
+     * By creating a `dragControls` using the `useDragControls` hook, we can pass this into
+     * the draggable component's `dragControls` prop. It exposes a `start` method
+     * that can start dragging from pointer events on other components.
      *
      * ```jsx
-     * <motion.section
-     *   animate={{ rotate: 180 }}
-     *   transition={{ type: 'spring', stiffness: 50 }}
-     * />
+     * const dragControls = useDragControls()
+     *
+     * function startDrag(event) {
+     *   dragControls.start(event, { snapToCursor: true })
+     * }
+     *
+     * return (
+     *   <>
+     *     <div onPointerDown={startDrag} />
+     *     <motion.div drag="x" dragControls={dragControls} />
+     *   </>
+     * )
      * ```
+     */
+    dragControls?: DragControls;
+    /**
+     * If true, element will snap back to its origin when dragging ends.
      *
-     * @public
+     * Enabling this is the equivalent of setting all `dragConstraints` axes to `0`
+     * with `dragElastic={1}`, but when used together `dragConstraints` can define
+     * a wider draggable area and `dragSnapToOrigin` will ensure the element
+     * animates back to its origin on release.
      */
-    stiffness?: number;
+    dragSnapToOrigin?: boolean;
     /**
-     * Strength of opposing force. If set to 0, spring will oscillate
-     * indefinitely. Set to `10` by default.
+     * By default, if `drag` is defined on a component then an event listener will be attached
+     * to automatically initiate dragging when a user presses down on it.
+     *
+     * By setting `dragListener` to `false`, this event listener will not be created.
      *
      * ```jsx
-     * <motion.a
-     *   animate={{ rotate: 180 }}
-     *   transition={{ type: 'spring', damping: 300 }}
-     * />
+     * const dragControls = useDragControls()
+     *
+     * function startDrag(event) {
+     *   dragControls.start(event, { snapToCursor: true })
+     * }
+     *
+     * return (
+     *   <>
+     *     <div onPointerDown={startDrag} />
+     *     <motion.div
+     *       drag="x"
+     *       dragControls={dragControls}
+     *       dragListener={false}
+     *     />
+     *   </>
+     * )
      * ```
+     */
+    dragListener?: boolean;
+    /**
+     * If `dragConstraints` is set to a React ref, this callback will call with the measured drag constraints.
      *
      * @public
      */
-    damping?: number;
+    onMeasureDragConstraints?: (constraints: BoundingBox) => BoundingBox | void;
     /**
-     * Mass of the moving object. Higher values will result in more lethargic
-     * movement. Set to `1` by default.
-     *
-     * ```jsx
-     * <motion.feTurbulence
-     *   animate={{ baseFrequency: 0.5 } as any}
-     *   transition={{ type: "spring", mass: 0.5 }}
-     * />
-     * ```
+     * Usually, dragging uses the layout project engine, and applies transforms to the underlying VisualElement.
+     * Passing MotionValues as _dragX and _dragY instead applies drag updates to these motion values.
+     * This allows you to manually control how updates from a drag gesture on an element is applied.
      *
      * @public
      */
-    mass?: number;
+    _dragX?: MotionValue<number>;
     /**
-     * The duration of the animation, defined in seconds. Spring animations can be a maximum of 10 seconds.
-     *
-     * If `bounce` is set, this defaults to `0.8`.
+     * Usually, dragging uses the layout project engine, and applies transforms to the underlying VisualElement.
+     * Passing MotionValues as _dragX and _dragY instead applies drag updates to these motion values.
+     * This allows you to manually control how updates from a drag gesture on an element is applied.
      *
-     * Note: `duration` and `bounce` will be overridden if `stiffness`, `damping` or `mass` are set.
+     * @public
+     */
+    _dragY?: MotionValue<number>;
+}
+
+/**
+ * @public
+ */
+interface LayoutProps {
+    /**
+     * If `true`, this component will automatically animate to its new position when
+     * its layout changes.
      *
      * ```jsx
-     * <motion.div
-     *   animate={{ x: 100 }}
-     *   transition={{ type: "spring", duration: 0.8 }}
-     * />
+     * <motion.div layout />
      * ```
      *
-     * @public
-     */
-    duration?: number;
-    /**
-     * `bounce` determines the "bounciness" of a spring animation.
+     * This will perform a layout animation using performant transforms. Part of this technique
+     * involved animating an element's scale. This can introduce visual distortions on children,
+     * `boxShadow` and `borderRadius`.
      *
-     * `0` is no bounce, and `1` is extremely bouncy.
+     * To correct distortion on immediate children, add `layout` to those too.
      *
-     * If `duration` is set, this defaults to `0.25`.
+     * `boxShadow` and `borderRadius` will automatically be corrected if they are already being
+     * animated on this component. Otherwise, set them directly via the `initial` prop.
      *
-     * Note: `bounce` and `duration` will be overridden if `stiffness`, `damping` or `mass` are set.
+     * If `layout` is set to `"position"`, the size of the component will change instantly and
+     * only its position will animate. If `layout` is set to `"size"`, the position of the
+     * component will change instantly but its size will animate.
      *
-     * ```jsx
-     * <motion.div
-     *   animate={{ x: 100 }}
-     *   transition={{ type: "spring", bounce: 0.25 }}
-     * />
-     * ```
+     * If `layout` is set to `"size"`, the position of the component will change instantly and
+     * only its size will animate.
+     *
+     * If `layout` is set to `"preserve-aspect"`, the component will animate size & position if
+     * the aspect ratio remains the same between renders, and just position if the ratio changes.
      *
      * @public
      */
-    bounce?: number;
+    layout?: boolean | "position" | "size" | "preserve-aspect";
     /**
-     * End animation if absolute speed (in units per second) drops below this
-     * value and delta is smaller than `restDelta`. Set to `0.01` by default.
+     * Enable shared layout transitions between different components with the same `layoutId`.
+     *
+     * When a component with a layoutId is removed from the React tree, and then
+     * added elsewhere, it will visually animate from the previous component's bounding box
+     * and its latest animated values.
      *
      * ```jsx
-     * <motion.div
-     *   animate={{ rotate: 180 }}
-     *   transition={{ type: 'spring', restSpeed: 0.5 }}
-     * />
+     *   {items.map(item => (
+     *      <motion.li layout>
+     *         {item.name}
+     *         {item.isSelected && <motion.div layoutId="underline" />}
+     *      </motion.li>
+     *   ))}
      * ```
      *
+     * If the previous component remains in the tree it will crossfade with the new component.
+     *
      * @public
      */
-    restSpeed?: number;
+    layoutId?: string;
     /**
-     * End animation if distance is below this value and speed is below
-     * `restSpeed`. When animation ends, spring gets “snapped” to. Set to
-     * `0.01` by default.
-     *
-     * ```jsx
-     * <motion.div
-     *   animate={{ rotate: 180 }}
-     *   transition={{ type: 'spring', restDelta: 0.5 }}
-     * />
-     * ```
+     * A callback that will fire when a layout animation on this component starts.
      *
      * @public
      */
-    restDelta?: number;
+    onLayoutAnimationStart?(): void;
     /**
-     * The value to animate from.
-     * By default, this is the initial state of the animating value.
+     * A callback that will fire when a layout animation on this component completes.
      *
-     * ```jsx
-     * <motion.div
-     *   animate={{ rotate: 180 }}
-     *   transition={{ type: 'spring', from: 90 }}
-     * />
-     * ```
+     * @public
+     */
+    onLayoutAnimationComplete?(): void;
+    /**
+     * @public
+     */
+    layoutDependency?: any;
+    /**
+     * Wether a projection node should measure its scroll when it or its descendants update their layout.
      *
      * @public
      */
-    from?: number | string;
+    layoutScroll?: boolean;
+}
+
+/** @public */
+interface EventInfo {
+    point: Point;
+}
+
+/**
+ * @public
+ */
+interface FocusHandlers {
     /**
-     * The initial velocity of the spring. By default this is the current velocity of the component.
+     * Properties or variant label to animate to while the focus gesture is recognised.
      *
      * ```jsx
-     * <motion.div
-     *   animate={{ rotate: 180 }}
-     *   transition={{ type: 'spring', velocity: 2 }}
-     * />
+     * <motion.input whileFocus={{ scale: 1.2 }} />
      * ```
-     *
-     * @public
      */
-    velocity?: number;
+    whileFocus?: VariantLabels | TargetAndTransition;
 }
 /**
- * An animation that decelerates a value based on its initial velocity,
- * usually used to implement inertial scrolling.
- *
- * Optionally, `min` and `max` boundaries can be defined, and inertia
- * will snap to these with a spring animation.
- *
- * This animation will automatically precalculate a target value,
- * which can be modified with the `modifyTarget` property.
+ * Passed in to tap event handlers like `onTap` the `TapInfo` object contains
+ * information about the tap gesture such as it‘s location.
  *
- * This allows you to add snap-to-grid or similar functionality.
+ * ```jsx
+ * function onTap(event, info) {
+ *   console.log(info.point.x, info.point.y)
+ * }
  *
- * Inertia is also the animation used for `dragTransition`, and can be configured via that prop.
+ * <motion.div onTap={onTap} />
+ * ```
  *
  * @public
  */
-interface Inertia {
+interface TapInfo {
     /**
-     * Set `type` to animate using the inertia animation. Set to `"tween"` by
-     * default. This can be used for natural deceleration, like momentum scrolling.
+     * Contains `x` and `y` values for the tap gesture relative to the
+     * device or page.
      *
      * ```jsx
-     * <motion.div
-     *   animate={{ rotate: 180 }}
-     *   transition={{ type: "inertia", velocity: 50 }}
-     * />
-     * ```
-     *
-     * @public
-     */
-    type: "inertia";
-    /**
-     * A function that receives the automatically-calculated target and returns a new one. Useful for snapping the target to a grid.
+     * function onTapStart(event, info) {
+     *   console.log(info.point.x, info.point.y)
+     * }
      *
-     * ```jsx
-     * <motion.div
-     *   drag
-     *   dragTransition={{
-     *     power: 0,
-     *     // Snap calculated target to nearest 50 pixels
-     *     modifyTarget: target => Math.round(target / 50) * 50
-     *   }}
-     * />
+     * <motion.div onTapStart={onTapStart} />
      * ```
      *
      * @public
      */
-    modifyTarget?(v: number): number;
+    point: Point;
+}
+/**
+ * @public
+ */
+interface TapHandlers {
     /**
-     * If `min` or `max` is set, this affects the stiffness of the bounce
-     * spring. Higher values will create more sudden movement. Set to `500` by
-     * default.
+     * Callback when the tap gesture successfully ends on this element.
      *
      * ```jsx
-     * <motion.div
-     *   drag
-     *   dragTransition={{
-     *     min: 0,
-     *     max: 100,
-     *     bounceStiffness: 100
-     *   }}
-     * />
-     * ```
-     *
-     * @public
-     */
-    bounceStiffness?: number;
-    /**
-     * If `min` or `max` is set, this affects the damping of the bounce spring.
-     * If set to `0`, spring will oscillate indefinitely. Set to `10` by
-     * default.
+     * function onTap(event, info) {
+     *   console.log(info.point.x, info.point.y)
+     * }
      *
-     * ```jsx
-     * <motion.div
-     *   drag
-     *   dragTransition={{
-     *     min: 0,
-     *     max: 100,
-     *     bounceDamping: 8
-     *   }}
-     * />
+     * <motion.div onTap={onTap} />
      * ```
      *
-     * @public
+     * @param event - The originating pointer event.
+     * @param info - An {@link TapInfo} object containing `x` and `y` values for the `point` relative to the device or page.
      */
-    bounceDamping?: number;
+    onTap?(event: MouseEvent | TouchEvent | PointerEvent, info: TapInfo): void;
     /**
-     * A higher power value equals a further target. Set to `0.8` by default.
+     * Callback when the tap gesture starts on this element.
      *
      * ```jsx
-     * <motion.div
-     *   drag
-     *   dragTransition={{ power: 0.2 }}
-     * />
+     * function onTapStart(event, info) {
+     *   console.log(info.point.x, info.point.y)
+     * }
+     *
+     * <motion.div onTapStart={onTapStart} />
      * ```
      *
-     * @public
+     * @param event - The originating pointer event.
+     * @param info - An {@link TapInfo} object containing `x` and `y` values for the `point` relative to the device or page.
      */
-    power?: number;
+    onTapStart?(event: MouseEvent | TouchEvent | PointerEvent, info: TapInfo): void;
     /**
-     * Adjusting the time constant will change the duration of the
-     * deceleration, thereby affecting its feel. Set to `700` by default.
+     * Callback when the tap gesture ends outside this element.
      *
      * ```jsx
-     * <motion.div
-     *   drag
-     *   dragTransition={{ timeConstant: 200 }}
-     * />
+     * function onTapCancel(event, info) {
+     *   console.log(info.point.x, info.point.y)
+     * }
+     *
+     * <motion.div onTapCancel={onTapCancel} />
      * ```
      *
-     * @public
+     * @param event - The originating pointer event.
+     * @param info - An {@link TapInfo} object containing `x` and `y` values for the `point` relative to the device or page.
      */
-    timeConstant?: number;
+    onTapCancel?(event: MouseEvent | TouchEvent | PointerEvent, info: TapInfo): void;
     /**
-     * End the animation if the distance to the animation target is below this value, and the absolute speed is below `restSpeed`.
-     * When the animation ends, the value gets snapped to the animation target. Set to `0.01` by default.
-     * Generally the default values provide smooth animation endings, only in rare cases should you need to customize these.
+     * Properties or variant label to animate to while the component is pressed.
      *
      * ```jsx
-     * <motion.div
-     *   drag
-     *   dragTransition={{ restDelta: 10 }}
-     * />
+     * <motion.div whileTap={{ scale: 0.8 }} />
      * ```
-     *
-     * @public
      */
-    restDelta?: number;
+    whileTap?: VariantLabels | TargetAndTransition;
+}
+/**
+ * @public
+ */
+interface PanHandlers {
     /**
-     * Minimum constraint. If set, the value will "bump" against this value (or immediately spring to it if the animation starts as less than this value).
+     * Callback function that fires when the pan gesture is recognised on this element.
+     *
+     * **Note:** For pan gestures to work correctly with touch input, the element needs
+     * touch scrolling to be disabled on either x/y or both axis with the
+     * [touch-action](https://developer.mozilla.org/en-US/docs/Web/CSS/touch-action) CSS rule.
      *
      * ```jsx
-     * <motion.div
-     *   drag
-     *   dragTransition={{ min: 0, max: 100 }}
-     * />
+     * function onPan(event, info) {
+     *   console.log(info.point.x, info.point.y)
+     * }
+     *
+     * <motion.div onPan={onPan} />
      * ```
      *
-     * @public
+     * @param event - The originating pointer event.
+     * @param info - A {@link PanInfo} object containing `x` and `y` values for:
+     *
+     *   - `point`: Relative to the device or page.
+     *   - `delta`: Distance moved since the last event.
+     *   - `offset`: Offset from the original pan event.
+     *   - `velocity`: Current velocity of the pointer.
      */
-    min?: number;
+    onPan?(event: MouseEvent | TouchEvent | PointerEvent, info: PanInfo): void;
     /**
-     * Maximum constraint. If set, the value will "bump" against this value (or immediately snap to it, if the initial animation value exceeds this value).
+     * Callback function that fires when the pan gesture begins on this element.
      *
      * ```jsx
-     * <motion.div
-     *   drag
-     *   dragTransition={{ min: 0, max: 100 }}
-     * />
+     * function onPanStart(event, info) {
+     *   console.log(info.point.x, info.point.y)
+     * }
+     *
+     * <motion.div onPanStart={onPanStart} />
      * ```
      *
-     * @public
+     * @param event - The originating pointer event.
+     * @param info - A {@link PanInfo} object containing `x`/`y` values for:
+     *
+     *   - `point`: Relative to the device or page.
+     *   - `delta`: Distance moved since the last event.
+     *   - `offset`: Offset from the original pan event.
+     *   - `velocity`: Current velocity of the pointer.
      */
-    max?: number;
+    onPanStart?(event: MouseEvent | TouchEvent | PointerEvent, info: PanInfo): void;
     /**
-     * The value to animate from. By default, this is the current state of the animating value.
+     * Callback function that fires when we begin detecting a pan gesture. This
+     * is analogous to `onMouseStart` or `onTouchStart`.
      *
      * ```jsx
-     * <Frame
-     *   drag
-     *   dragTransition={{ from: 50 }}
-     * />
+     * function onPanSessionStart(event, info) {
+     *   console.log(info.point.x, info.point.y)
+     * }
+     *
+     * <motion.div onPanSessionStart={onPanSessionStart} />
      * ```
      *
-     * @public
+     * @param event - The originating pointer event.
+     * @param info - An {@link EventInfo} object containing `x`/`y` values for:
+     *
+     *   - `point`: Relative to the device or page.
      */
-    from?: number | string;
+    onPanSessionStart?(event: MouseEvent | TouchEvent | PointerEvent, info: EventInfo): void;
     /**
-     * The initial velocity of the animation.
-     * By default this is the current velocity of the component.
+     * Callback function that fires when the pan gesture ends on this element.
      *
      * ```jsx
-     * <motion.div
-     *   animate={{ rotate: 180 }}
-     *   transition={{ type: 'inertia', velocity: 200 }}
-     * />
+     * function onPanEnd(event, info) {
+     *   console.log(info.point.x, info.point.y)
+     * }
+     *
+     * <motion.div onPanEnd={onPanEnd} />
      * ```
      *
-     * @public
+     * @param event - The originating pointer event.
+     * @param info - A {@link PanInfo} object containing `x`/`y` values for:
+     *
+     *   - `point`: Relative to the device or page.
+     *   - `delta`: Distance moved since the last event.
+     *   - `offset`: Offset from the original pan event.
+     *   - `velocity`: Current velocity of the pointer.
      */
-    velocity?: number;
+    onPanEnd?(event: MouseEvent | TouchEvent | PointerEvent, info: PanInfo): void;
 }
 /**
- * Keyframes tweens between multiple `values`.
- *
- * These tweens can be arranged using the `duration`, `easings`, and `times` properties.
+ * @public
  */
-interface Keyframes {
-    /**
-     * Set `type` to `"keyframes"` to animate using the keyframes animation.
-     * Set to `"tween"` by default. This can be used to animate between a series of values.
-     *
-     * @public
-     */
-    type: "keyframes";
-    /**
-     * An array of numbers between 0 and 1, where `1` represents the `total` duration.
-     *
-     * Each value represents at which point during the animation each item in the animation target should be hit, so the array should be the same length as `values`.
-     *
-     * Defaults to an array of evenly-spread durations.
-     *
-     * @public
-     */
-    times?: number[];
+interface HoverHandlers {
     /**
-     * An array of easing functions for each generated tween, or a single easing function applied to all tweens.
-     *
-     * This array should be one item less than `values`, as these easings apply to the transitions *between* the `values`.
+     * Properties or variant label to animate to while the hover gesture is recognised.
      *
      * ```jsx
-     * const transition = {
-     *   backgroundColor: {
-     *     type: 'keyframes',
-     *     easings: ['circIn', 'circOut']
-     *   }
-     * }
+     * <motion.div whileHover={{ scale: 1.2 }} />
      * ```
-     *
-     * @public
      */
-    ease?: Easing | Easing[];
+    whileHover?: VariantLabels | TargetAndTransition;
     /**
-     * The total duration of the animation. Set to `0.3` by default.
+     * Callback function that fires when pointer starts hovering over the component.
      *
      * ```jsx
-     * const transition = {
-     *   type: "keyframes",
-     *   duration: 2
-     * }
-     *
-     * <Frame
-     *   animate={{ opacity: 0 }}
-     *   transition={transition}
-     * />
+     * <motion.div onHoverStart={() => console.log('Hover starts')} />
      * ```
-     *
-     * @public
      */
-    duration?: number;
+    onHoverStart?(event: MouseEvent, info: EventInfo): void;
     /**
-     * @public
+     * Callback function that fires when pointer stops hovering over the component.
+     *
+     * ```jsx
+     * <motion.div onHoverEnd={() => console.log("Hover ends")} />
+     * ```
      */
-    repeatDelay?: number;
+    onHoverEnd?(event: MouseEvent, info: EventInfo): void;
+}
+
+declare type ViewportEventHandler = (entry: IntersectionObserverEntry | null) => void;
+interface ViewportOptions {
+    root?: RefObject<Element>;
+    once?: boolean;
+    margin?: string;
+    amount?: "some" | "all" | number;
+    fallback?: boolean;
 }
+interface ViewportProps {
+    whileInView?: VariantLabels | TargetAndTransition;
+    onViewportEnter?: ViewportEventHandler;
+    onViewportLeave?: ViewportEventHandler;
+    viewport?: ViewportOptions;
+}
+
 /**
+ * Either a string, or array of strings, that reference variants defined via the `variants` prop.
  * @public
  */
-interface Just {
-    /**
-     * @public
-     */
-    type: "just";
+declare type VariantLabels = string | string[];
+interface TransformProperties {
+    x?: string | number;
+    y?: string | number;
+    z?: string | number;
+    translateX?: string | number;
+    translateY?: string | number;
+    translateZ?: string | number;
+    rotate?: string | number;
+    rotateX?: string | number;
+    rotateY?: string | number;
+    rotateZ?: string | number;
+    scale?: string | number;
+    scaleX?: string | number;
+    scaleY?: string | number;
+    scaleZ?: string | number;
+    skew?: string | number;
+    skewX?: string | number;
+    skewY?: string | number;
+    originX?: string | number;
+    originY?: string | number;
+    originZ?: string | number;
+    perspective?: string | number;
+    transformPerspective?: string | number;
 }
 /**
  * @public
  */
-interface None {
+interface SVGPathProperties {
+    pathLength?: number;
+    pathOffset?: number;
+    pathSpacing?: number;
+}
+interface CustomStyles {
     /**
-     * Set `type` to `false` for an instant transition.
-     *
-     * @public
+     * Framer Library custom prop types. These are not actually supported in Motion - preferably
+     * we'd have a way of external consumers injecting supported styles into this library.
      */
-    type: false;
+    size?: string | number;
+    radius?: string | number;
+    shadow?: string;
+    image?: string;
 }
+declare type MakeMotion<T> = MakeCustomValueType<{
+    [K in keyof T]: T[K] | MotionValue<number> | MotionValue<string> | MotionValue<any>;
+}>;
+declare type MotionCSS = MakeMotion<Omit$1<CSSProperties, "rotate" | "scale" | "perspective">>;
 /**
  * @public
  */
-declare type PermissiveTransitionDefinition = {
-    [key: string]: any;
-};
-/**
- * @public
- */
-declare type TransitionDefinition = Tween | Spring | Keyframes | Inertia | Just | None | PermissiveTransitionDefinition;
-declare type TransitionMap = Orchestration & {
-    [key: string]: TransitionDefinition;
-};
-/**
- * Transition props
- *
- * @public
- */
-declare type Transition = (Orchestration & Repeat & TransitionDefinition) | (Orchestration & Repeat & TransitionMap);
-declare type Omit$1<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
-declare type CSSPropertiesWithoutTransitionOrSingleTransforms = Omit$1<CSSProperties, "transition" | "rotate" | "scale" | "perspective">;
-declare type TargetProperties = CSSPropertiesWithoutTransitionOrSingleTransforms & SVGAttributes<SVGElement> & TransformProperties & CustomStyles & SVGPathProperties;
-/**
- * @public
- */
-declare type MakeCustomValueType<T> = {
-    [K in keyof T]: T[K] | CustomValueType;
-};
-/**
- * @public
- */
-declare type Target = MakeCustomValueType<TargetProperties>;
-/**
- * @public
- */
-declare type MakeKeyframes<T> = {
-    [K in keyof T]: T[K] | T[K][] | [null, ...T[K][]];
-};
-/**
- * @public
- */
-declare type TargetWithKeyframes = MakeKeyframes<Target>;
-/**
- * An object that specifies values to animate to. Each value may be set either as
- * a single value, or an array of values.
- *
- * It may also option contain these properties:
- *
- * - `transition`: Specifies transitions for all or individual values.
- * - `transitionEnd`: Specifies values to set when the animation finishes.
- *
- * ```jsx
- * const target = {
- *   x: "0%",
- *   opacity: 0,
- *   transition: { duration: 1 },
- *   transitionEnd: { display: "none" }
- * }
- * ```
- *
- * @public
- */
-declare type TargetAndTransition = TargetWithKeyframes & {
-    transition?: Transition;
-    transitionEnd?: Target;
-};
-declare type TargetResolver = (custom: any, current: Target, velocity: Target) => TargetAndTransition | string;
-/**
- * @public
- */
-declare type Variant = TargetAndTransition | TargetResolver;
-/**
- * @public
- */
-declare type Variants = {
-    [key: string]: Variant;
-};
-/**
- * @public
- */
-interface CustomValueType {
-    mix: (from: any, to: any) => (p: number) => number | string;
-    toValue: () => number | string;
-}
-
-/**
- * Start animation on a MotionValue. This function is an interface between
- * Framer Motion and Popmotion
- */
-declare function startAnimation(key: string, value: MotionValue, target: ResolvedValueTarget, transition?: Transition): Promise<void>;
-
-interface VisualState<Instance, RenderState> {
-    renderState: RenderState;
-    latestValues: ResolvedValues;
-    mount?: (instance: Instance) => void;
-}
-declare type UseVisualState<Instance, RenderState> = (props: MotionProps, isStatic: boolean) => VisualState<Instance, RenderState>;
-interface UseVisualStateConfig<Instance, RenderState> {
-    scrapeMotionValuesFromProps: ScrapeMotionValuesFromProps;
-    createRenderState: () => RenderState;
-    onMount?: (props: MotionProps, instance: Instance, visualState: VisualState<Instance, RenderState>) => void;
-}
-declare const makeUseVisualState: <I, RS>(config: UseVisualStateConfig<I, RS>) => UseVisualState<I, RS>;
-
-interface AnimationState {
-    animateChanges: (options?: AnimationOptions$1, type?: AnimationType) => Promise<any>;
-    setActive: (type: AnimationType, isActive: boolean, options?: AnimationOptions$1) => Promise<any>;
-    setAnimateFunction: (fn: any) => void;
-    getState: () => {
-        [key: string]: AnimationTypeState;
-    };
-}
-interface AnimationTypeState {
-    isActive: boolean;
-    protectedKeys: {
-        [key: string]: true;
-    };
-    needsAnimating: {
-        [key: string]: boolean;
-    };
-    prevResolvedValues: {
-        [key: string]: any;
-    };
-    prevProp?: VariantLabels | TargetAndTransition;
-}
-
-declare class NodeStack {
-    lead?: IProjectionNode;
-    prevLead?: IProjectionNode;
-    members: IProjectionNode[];
-    add(node: IProjectionNode): void;
-    remove(node: IProjectionNode): void;
-    relegate(node: IProjectionNode): boolean;
-    promote(node: IProjectionNode, preserveFollowOpacity?: boolean): void;
-    exitAnimationComplete(): void;
-    scheduleRender(): void;
-    /**
-     * Clear any leads that have been removed this render to prevent them from being
-     * used in future animations and to prevent memory leaks
-     */
-    removeLeadSnapshot(): void;
-}
-
+declare type MotionTransform = MakeMotion<TransformProperties>;
 /**
  * @public
  */
-interface AnimationPlaybackControls {
-    stop: () => void;
-    isAnimating: () => boolean;
-}
+declare type MotionStyle = MotionCSS & MotionTransform & MakeMotion<SVGPathProperties> & MakeCustomValueType<CustomStyles>;
 /**
  * @public
  */
-interface AnimationPlaybackLifecycles<V> {
-    onUpdate?: (latest: V) => void;
-    onPlay?: () => void;
-    onComplete?: () => void;
-    onRepeat?: () => void;
-    onStop?: () => void;
+interface RelayoutInfo {
+    delta: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
 }
 /**
  * @public
  */
-declare type AnimationOptions<V> = (Tween | Spring) & AnimationPlaybackLifecycles<V> & {
-    delay?: number;
-    type?: "tween" | "spring";
-};
+declare type ResolveLayoutTransition = (info: RelayoutInfo) => Transition | boolean;
 /**
- * Animate a single value or a `MotionValue`.
- *
- * The first argument is either a `MotionValue` to animate, or an initial animation value.
- *
- * The second is either a value to animate to, or an array of keyframes to animate through.
- *
- * The third argument can be either tween or spring options, and optional lifecycle methods: `onUpdate`, `onPlay`, `onComplete`, `onRepeat` and `onStop`.
- *
- * Returns `AnimationPlaybackControls`, currently just a `stop` method.
- *
- * ```javascript
- * const x = useMotionValue(0)
- *
- * useEffect(() => {
- *   const controls = animate(x, 100, {
- *     type: "spring",
- *     stiffness: 2000,
- *     onComplete: v => {}
- *   })
- *
- *   return controls.stop
- * })
- * ```
- *
  * @public
  */
-declare function animate<V>(from: MotionValue<V> | V, to: V | V[], transition?: AnimationOptions<V>): AnimationPlaybackControls;
-
-interface WithDepth {
-    depth: number;
-}
-
-declare class FlatTree {
-    private children;
-    private isDirty;
-    add(child: WithDepth): void;
-    remove(child: WithDepth): void;
-    forEach(callback: (child: WithDepth) => void): void;
-}
-
-interface SwitchLayoutGroup {
-    register?: (member: IProjectionNode) => void;
-    deregister?: (member: IProjectionNode) => void;
-}
-declare type InitialPromotionConfig = {
+interface AnimationProps {
     /**
-     * The initial transition to use when the elements in this group mount (and automatically promoted).
-     * Subsequent updates should provide a transition in the promote method.
+     * Properties, variant label or array of variant labels to start in.
+     *
+     * Set to `false` to initialise with the values in `animate` (disabling the mount animation)
+     *
+     * ```jsx
+     * // As values
+     * <motion.div initial={{ opacity: 1 }} />
+     *
+     * // As variant
+     * <motion.div initial="visible" variants={variants} />
+     *
+     * // Multiple variants
+     * <motion.div initial={["visible", "active"]} variants={variants} />
+     *
+     * // As false (disable mount animation)
+     * <motion.div initial={false} animate={{ opacity: 0 }} />
+     * ```
      */
-    transition?: Transition;
+    initial?: boolean | Target | VariantLabels;
     /**
-     * If the follow tree should preserve its opacity when the lead is promoted on mount
+     * Values to animate to, variant label(s), or `AnimationControls`.
+     *
+     * ```jsx
+     * // As values
+     * <motion.div animate={{ opacity: 1 }} />
+     *
+     * // As variant
+     * <motion.div animate="visible" variants={variants} />
+     *
+     * // Multiple variants
+     * <motion.div animate={["visible", "active"]} variants={variants} />
+     *
+     * // AnimationControls
+     * <motion.div animate={animation} />
+     * ```
      */
-    shouldPreserveFollowOpacity?: (member: IProjectionNode) => boolean;
-};
-declare type SwitchLayoutGroupContext = SwitchLayoutGroup & InitialPromotionConfig;
-/**
- * Internal, exported only for usage in Framer
- */
-declare const SwitchLayoutGroupContext: React$1.Context<SwitchLayoutGroupContext>;
+    animate?: AnimationControls | TargetAndTransition | VariantLabels | boolean;
+    /**
+     * A target to animate to when this component is removed from the tree.
+     *
+     * This component **must** be the first animatable child of an `AnimatePresence` to enable this exit animation.
+     *
+     * This limitation exists because React doesn't allow components to defer unmounting until after
+     * an animation is complete. Once this limitation is fixed, the `AnimatePresence` component will be unnecessary.
+     *
+     * ```jsx
+     * import { AnimatePresence, motion } from 'framer-motion'
+     *
+     * export const MyComponent = ({ isVisible }) => {
+     *   return (
+     *     <AnimatePresence>
+     *        {isVisible && (
+     *          <motion.div
+     *            initial={{ opacity: 0 }}
+     *            animate={{ opacity: 1 }}
+     *            exit={{ opacity: 0 }}
+     *          />
+     *        )}
+     *     </AnimatePresence>
+     *   )
+     * }
+     * ```
+     */
+    exit?: TargetAndTransition | VariantLabels;
+    /**
+     * Variants allow you to define animation states and organise them by name. They allow
+     * you to control animations throughout a component tree by switching a single `animate` prop.
+     *
+     * Using `transition` options like `delayChildren` and `staggerChildren`, you can orchestrate
+     * when children animations play relative to their parent.
 
-interface Snapshot {
-    measured: Box;
-    layout: Box;
-    latestValues: ResolvedValues;
-    isShared?: boolean;
-}
-interface Layout {
-    measured: Box;
-    actual: Box;
-}
-declare type LayoutEvents = "willUpdate" | "didUpdate" | "beforeMeasure" | "measure" | "projectionUpdate" | "animationStart" | "animationComplete";
-interface IProjectionNode<I = unknown> {
-    id: number | undefined;
-    parent?: IProjectionNode;
-    relativeParent?: IProjectionNode;
-    root?: IProjectionNode;
-    children: Set<IProjectionNode>;
-    path: IProjectionNode[];
-    nodes?: FlatTree;
-    depth: number;
-    instance: I;
-    mount: (node: I, isLayoutDirty?: boolean) => void;
-    unmount: () => void;
-    options: ProjectionNodeOptions;
-    setOptions(options: ProjectionNodeOptions): void;
-    layout?: Layout;
-    snapshot?: Snapshot;
-    target?: Box;
-    relativeTarget?: Box;
-    targetDelta?: Delta;
-    targetWithTransforms?: Box;
-    scroll?: Point;
-    isScrollRoot?: boolean;
-    treeScale?: Point;
-    projectionDelta?: Delta;
-    projectionDeltaWithTransform?: Delta;
-    latestValues: ResolvedValues;
-    isLayoutDirty: boolean;
-    shouldResetTransform: boolean;
-    prevTransformTemplateValue: string | undefined;
-    isUpdateBlocked(): boolean;
-    updateManuallyBlocked: boolean;
-    updateBlockedByResize: boolean;
-    blockUpdate(): void;
-    unblockUpdate(): void;
-    isUpdating: boolean;
-    needsReset: boolean;
-    startUpdate(): void;
-    willUpdate(notifyListeners?: boolean): void;
-    didUpdate(): void;
-    measure(): Box;
-    updateLayout(): void;
-    updateSnapshot(): void;
-    clearSnapshot(): void;
-    updateScroll(): void;
-    scheduleUpdateProjection(): void;
-    scheduleCheckAfterUnmount(): void;
-    checkUpdateFailed(): void;
-    potentialNodes: Map<number, IProjectionNode>;
-    sharedNodes: Map<string, NodeStack>;
-    registerPotentialNode(id: number, node: IProjectionNode): void;
-    registerSharedNode(id: string, node: IProjectionNode): void;
-    getStack(): NodeStack | undefined;
-    isVisible: boolean;
-    hide(): void;
-    show(): void;
-    scheduleRender(notifyAll?: boolean): void;
-    getClosestProjectingParent(): IProjectionNode | undefined;
-    setTargetDelta(delta: Delta): void;
-    resetTransform(): void;
-    resetRotation(): void;
-    applyTransform(box: Box, transformOnly?: boolean): Box;
-    resolveTargetDelta(): void;
-    calcProjection(): void;
-    getProjectionStyles(styles?: MotionStyle): MotionStyle | undefined;
-    clearMeasurements(): void;
-    resetTree(): void;
-    animationValues?: ResolvedValues;
-    currentAnimation?: AnimationPlaybackControls;
-    isTreeAnimating?: boolean;
-    isAnimationBlocked?: boolean;
-    isTreeAnimationBlocked: () => boolean;
-    setAnimationOrigin(delta: Delta): void;
-    startAnimation(transition: Transition): void;
-    finishAnimation(): void;
-    isLead(): boolean;
-    promote(options?: {
-        needsReset?: boolean;
-        transition?: Transition;
-        preserveFollowOpacity?: boolean;
-    }): void;
-    relegate(): boolean;
-    resumeFrom?: IProjectionNode;
-    resumingFrom?: IProjectionNode;
-    isPresent?: boolean;
-    addEventListener(name: LayoutEvents, handler: any): VoidFunction;
-    notifyListeners(name: LayoutEvents, ...args: any): void;
-    hasListeners(name: LayoutEvents): boolean;
-    preserveOpacity?: boolean;
-}
-interface ProjectionNodeOptions {
-    animate?: boolean;
-    layoutScroll?: boolean;
-    alwaysMeasureLayout?: boolean;
-    scheduleRender?: VoidFunction;
-    onExitComplete?: VoidFunction;
-    animationType?: "size" | "position" | "both" | "preserve-aspect";
-    layoutId?: string;
-    layout?: boolean | string;
-    visualElement?: VisualElement;
-    crossfade?: boolean;
+     *
+     * After passing variants to one or more `motion` component's `variants` prop, these variants
+     * can be used in place of values on the `animate`, `initial`, `whileFocus`, `whileTap` and `whileHover` props.
+     *
+     * ```jsx
+     * const variants = {
+     *   active: {
+     *       backgroundColor: "#f00"
+     *   },
+     *   inactive: {
+     *     backgroundColor: "#fff",
+     *     transition: { duration: 2 }
+     *   }
+     * }
+     *
+     * <motion.div variants={variants} animate="active" />
+     * ```
+     */
+    variants?: Variants;
+    /**
+     * Default transition. If no `transition` is defined in `animate`, it will use the transition defined here.
+     * ```jsx
+     * const spring = {
+     *   type: "spring",
+     *   damping: 10,
+     *   stiffness: 100
+     * }
+     *
+     * <motion.div transition={spring} animate={{ scale: 1.2 }} />
+     * ```
+     */
     transition?: Transition;
-    initialPromotionConfig?: InitialPromotionConfig;
 }
-
-declare type ReducedMotionConfig = "always" | "never" | "user";
 /**
  * @public
  */
-interface MotionConfigContext {
-    /**
-     * Internal, exported only for usage in Framer
-     */
-    transformPagePoint: TransformPoint;
-    /**
-     * Internal. Determines whether this is a static context ie the Framer canvas. If so,
-     * it'll disable all dynamic functionality.
-     */
-    isStatic: boolean;
+interface MotionAdvancedProps {
     /**
-     * Defines a new default transition for the entire tree.
+     * Custom data to use to resolve dynamic variants differently for each animating component.
+     *
+     * ```jsx
+     * const variants = {
+     *   visible: (custom) => ({
+     *     opacity: 1,
+     *     transition: { delay: custom * 0.2 }
+     *   })
+     * }
+     *
+     * <motion.div custom={0} animate="visible" variants={variants} />
+     * <motion.div custom={1} animate="visible" variants={variants} />
+     * <motion.div custom={2} animate="visible" variants={variants} />
+     * ```
      *
      * @public
      */
-    transition?: Transition;
+    custom?: any;
     /**
-     * If true, will respect the device prefersReducedMotion setting by switching
-     * transform animations off.
-     *
      * @public
+     * Set to `false` to prevent inheriting variant changes from its parent.
      */
-    reducedMotion?: ReducedMotionConfig;
-}
-/**
- * @public
- */
-declare const MotionConfigContext: React$1.Context<MotionConfigContext>;
-
-declare type IsValidProp = (key: string) => boolean;
-declare function filterProps(props: MotionProps, isDom: boolean, forwardMotionProps: boolean): {};
-
-interface MotionConfigProps extends Partial<MotionConfigContext> {
-    children?: React$1.ReactNode;
-    isValidProp?: IsValidProp;
+    inherit?: boolean;
 }
 /**
- * `MotionConfig` is used to set configuration options for all children `motion` components.
- *
- * ```jsx
- * import { motion, MotionConfig } from "framer-motion"
- *
- * export function App() {
- *   return (
- *     <MotionConfig transition={{ type: "spring" }}>
- *       <motion.div animate={{ x: 100 }} />
- *     </MotionConfig>
- *   )
- * }
- * ```
+ * Props for `motion` components.
  *
  * @public
  */
-declare function MotionConfig({ children, isValidProp, ...config }: MotionConfigProps): JSX.Element;
-
-/**
- * @public
- */
-interface FeatureProps extends MotionProps {
-    visualElement: VisualElement;
-}
-declare type FeatureNames = {
-    animation: true;
-    exit: true;
-    drag: true;
-    tap: true;
-    focus: true;
-    hover: true;
-    pan: true;
-    inView: true;
-    measureLayout: true;
-};
-declare type FeatureComponent = React$1.ComponentType<React$1.PropsWithChildren<FeatureProps>>;
-/**
- * @public
- */
-interface FeatureDefinition {
-    isEnabled: (props: MotionProps) => boolean;
-    Component?: FeatureComponent;
-}
-interface FeatureComponents {
-    animation?: FeatureComponent;
-    exit?: FeatureComponent;
-    drag?: FeatureComponent;
-    tap?: FeatureComponent;
-    focus?: FeatureComponent;
-    hover?: FeatureComponent;
-    pan?: FeatureComponent;
-    inView?: FeatureComponent;
-    measureLayout?: FeatureComponent;
-}
-interface FeatureBundle extends FeatureComponents {
-    renderer: CreateVisualElement<any>;
-    projectionNodeConstructor?: any;
-}
-declare type LazyFeatureBundle$1 = () => Promise<FeatureBundle>;
-declare type FeatureDefinitions = {
-    [K in keyof FeatureNames]: FeatureDefinition;
-};
-declare type LoadedFeatures = FeatureDefinitions & {
-    projectionNodeConstructor?: any;
-};
-declare type RenderComponent<Instance, RenderState> = (Component: string | React$1.ComponentType<React$1.PropsWithChildren<unknown>>, props: MotionProps, projectionId: number | undefined, ref: React$1.Ref<Instance>, visualState: VisualState<Instance, RenderState>, isStatic: boolean, visualElement?: VisualElement) => any;
-
-interface VisualElement<Instance = any, RenderState = any> extends LifecycleManager {
-    treeType: string;
-    depth: number;
-    parent?: VisualElement;
-    children: Set<VisualElement>;
-    variantChildren?: Set<VisualElement>;
-    current: Instance | null;
-    manuallyAnimateOnMount: boolean;
-    blockInitialAnimation?: boolean;
-    presenceId: string | undefined;
-    isMounted(): boolean;
-    mount(instance: Instance): void;
-    unmount(): void;
-    isStatic?: boolean;
-    getInstance(): Instance | null;
-    sortNodePosition(element: VisualElement): number;
-    measureViewportBox(withTransform?: boolean): Box;
-    addVariantChild(child: VisualElement): undefined | (() => void);
-    getClosestVariantNode(): VisualElement | undefined;
-    shouldReduceMotion?: boolean | null;
-    animateMotionValue?: typeof startAnimation;
-    loadFeatures(props: MotionProps, isStrict?: boolean, preloadedFeatures?: FeatureBundle, projectionId?: number, ProjectionNodeConstructor?: any, initialPromotionConfig?: SwitchLayoutGroupContext): JSX.Element[];
-    projection?: IProjectionNode;
+interface MotionProps extends AnimationProps, EventProps, PanHandlers, TapHandlers, HoverHandlers, FocusHandlers, ViewportProps, DraggableProps, LayoutProps, MotionAdvancedProps {
+    /**
+     *
+     * The React DOM `style` prop, enhanced with support for `MotionValue`s and separate `transform` values.
+     *
+     * ```jsx
+     * export const MyComponent = () => {
+     *   const x = useMotionValue(0)
+     *
+     *   return <motion.div style={{ x, opacity: 1, scale: 0.5 }} />
+     * }
+     * ```
+     */
+    style?: MotionStyle;
     /**
-     * Visibility
+     * By default, Framer Motion generates a `transform` property with a sensible transform order. `transformTemplate`
+     * can be used to create a different order, or to append/preprend the automatically generated `transform` property.
+     *
+     * ```jsx
+     * <motion.div
+     *   style={{ x: 0, rotate: 180 }}
+     *   transformTemplate={
+     *     ({ x, rotate }) => `rotate(${rotate}deg) translateX(${x}px)`
+     *   }
+     * />
+     * ```
+     *
+     * @param transform - The latest animated transform props.
+     * @param generatedTransform - The transform string as automatically generated by Framer Motion
+     *
+     * @public
      */
-    isVisible?: boolean;
-    setVisibility(visibility: boolean): void;
-    hasValue(key: string): boolean;
-    addValue(key: string, value: MotionValue<any>): void;
-    removeValue(key: string): void;
-    getValue(key: string): undefined | MotionValue;
-    getValue(key: string, defaultValue: string | number): MotionValue;
-    getValue(key: string, defaultValue?: string | number): undefined | MotionValue;
-    forEachValue(callback: (value: MotionValue, key: string) => void): void;
-    readValue(key: string): string | number | undefined | null;
-    setBaseTarget(key: string, value: string | number | null): void;
-    getBaseTarget(key: string): number | string | undefined | null;
-    getStaticValue(key: string): number | string | undefined;
-    setStaticValue(key: string, value: number | string): void;
-    getLatestValues(): ResolvedValues;
-    scheduleRender(): void;
-    makeTargetAnimatable(target: TargetAndTransition, isLive?: boolean): TargetAndTransition;
-    setProps(props: MotionProps): void;
-    getProps(): MotionProps;
-    getVariant(name: string): Variant | undefined;
-    getDefaultTransition(): Transition | undefined;
-    getVariantContext(startAtParent?: boolean): undefined | {
-        initial?: string | string[];
-        animate?: string | string[];
-        exit?: string | string[];
-        whileHover?: string | string[];
-        whileDrag?: string | string[];
-        whileFocus?: string | string[];
-        whileTap?: string | string[];
-    };
-    getTransformPagePoint: () => TransformPoint | undefined;
-    build(): RenderState;
-    syncRender(): void;
-    isPresenceRoot?: boolean;
-    isPresent?: boolean;
-    prevDragCursor?: Point;
-    getLayoutId(): string | undefined;
-    animationState?: AnimationState;
-}
-interface VisualElementConfig<Instance, RenderState, Options> {
-    treeType?: string;
-    getBaseTarget?(props: MotionProps, key: string): string | number | undefined | MotionValue;
-    build(visualElement: VisualElement<Instance>, renderState: RenderState, latestValues: ResolvedValues, options: Options, props: MotionProps): void;
-    sortNodePosition?: (a: Instance, b: Instance) => number;
-    makeTargetAnimatable(element: VisualElement<Instance>, target: TargetAndTransition, props: MotionProps, isLive: boolean): TargetAndTransition;
-    measureViewportBox(instance: Instance, props: MotionProps & MotionConfigProps): Box;
-    readValueFromInstance(instance: Instance, key: string, options: Options): string | number | null | undefined;
-    resetTransform(element: VisualElement<Instance>, instance: Instance, props: MotionProps): void;
-    restoreTransform(instance: Instance, renderState: RenderState): void;
-    render(instance: Instance, renderState: RenderState, styleProp?: MotionStyle, projection?: IProjectionNode): void;
-    removeValueFromRenderState(key: string, renderState: RenderState): void;
-    scrapeMotionValuesFromProps: ScrapeMotionValuesFromProps;
+    transformTemplate?(transform: TransformProperties, generatedTransform: string): string;
+    /**
+     * Internal.
+     *
+     * This allows values to be transformed before being animated or set as styles.
+     *
+     * For instance, this allows custom values in Framer Library like `size` to be converted into `width` and `height`.
+     * It also allows us a chance to take a value like `Color` and convert it to an animatable color string.
+     *
+     * A few structural typing changes need making before this can be a public property:
+     * - Allow `Target` values to be appended by user-defined types (delete `CustomStyles` - does `size` throw a type error?)
+     * - Extract `CustomValueType` as a separate user-defined type (delete `CustomValueType` and animate a `Color` - does this throw a type error?).
+     *
+     * @param values -
+     */
+    transformValues?<V extends ResolvedValues>(values: V): V;
 }
+
+declare type VariantStateContext = {
+    initial?: string | string[];
+    animate?: string | string[];
+    exit?: string | string[];
+    whileHover?: string | string[];
+    whileDrag?: string | string[];
+    whileFocus?: string | string[];
+    whileTap?: string | string[];
+};
 declare type ScrapeMotionValuesFromProps = (props: MotionProps) => {
     [key: string]: MotionValue | string | number;
 };
@@ -2701,13 +2800,86 @@ declare type VisualElementOptions<Instance, RenderState = any> = {
     blockInitialAnimation?: boolean;
     reducedMotionConfig?: ReducedMotionConfig;
 };
-declare type CreateVisualElement<Instance> = (Component: string | React$1.ComponentType<React$1.PropsWithChildren<unknown>>, options: VisualElementOptions<Instance>) => VisualElement<Instance>;
 /**
  * A generic set of string/number values
  */
 interface ResolvedValues {
     [key: string]: string | number;
 }
+interface VisualElementEventCallbacks {
+    BeforeLayoutMeasure: () => void;
+    LayoutMeasure: (layout: Box, prevLayout?: Box) => void;
+    LayoutUpdate: (layout: Axis, prevLayout: Axis) => void;
+    Update: (latest: ResolvedValues) => void;
+    Render: () => void;
+    AnimationStart: (definition: AnimationDefinition) => void;
+    AnimationComplete: (definition: AnimationDefinition) => void;
+    LayoutAnimationStart: () => void;
+    LayoutAnimationComplete: () => void;
+    SetAxisTarget: () => void;
+    Unmount: () => void;
+}
+interface LayoutLifecycles {
+    onBeforeLayoutMeasure?(box: Box): void;
+    onLayoutMeasure?(box: Box, prevBox: Box): void;
+}
+interface AnimationLifecycles {
+    /**
+     * Callback with latest motion values, fired max once per frame.
+     *
+     * ```jsx
+     * function onUpdate(latest) {
+     *   console.log(latest.x, latest.opacity)
+     * }
+     *
+     * <motion.div animate={{ x: 100, opacity: 0 }} onUpdate={onUpdate} />
+     * ```
+     */
+    onUpdate?(latest: ResolvedValues): void;
+    /**
+     * Callback when animation defined in `animate` begins.
+     *
+     * The provided callback will be called with the triggering animation definition.
+     * If this is a variant, it'll be the variant name, and if a target object
+     * then it'll be the target object.
+     *
+     * This way, it's possible to figure out which animation has started.
+     *
+     * ```jsx
+     * function onStart() {
+     *   console.log("Animation started")
+     * }
+     *
+     * <motion.div animate={{ x: 100 }} onAnimationStart={onStart} />
+     * ```
+     */
+    onAnimationStart?(definition: AnimationDefinition): void;
+    /**
+     * Callback when animation defined in `animate` is complete.
+     *
+     * The provided callback will be called with the triggering animation definition.
+     * If this is a variant, it'll be the variant name, and if a target object
+     * then it'll be the target object.
+     *
+     * This way, it's possible to figure out which animation has completed.
+     *
+     * ```jsx
+     * function onComplete() {
+     *   console.log("Animation completed")
+     * }
+     *
+     * <motion.div
+     *   animate={{ x: 100 }}
+     *   onAnimationComplete={definition => {
+     *     console.log('Completed animating', definition)
+     *   }}
+     * />
+     * ```
+     */
+    onAnimationComplete?(definition: AnimationDefinition): void;
+}
+declare type EventProps = LayoutLifecycles & AnimationLifecycles;
+declare type CreateVisualElement<Instance> = (Component: string | React.ComponentType<React.PropsWithChildren<unknown>>, options: VisualElementOptions<Instance>) => VisualElement<Instance>;
 
 declare type UnionStringArray$1<T extends Readonly<string[]>> = T[number];
 declare const svgElements: readonly ["animate", "circle", "defs", "desc", "ellipse", "g", "image", "line", "filter", "marker", "mask", "metadata", "path", "pattern", "polygon", "polyline", "rect", "stop", "svg", "switch", "symbol", "text", "tspan", "use", "view", "clipPath", "feBlend", "feColorMatrix", "feComponentTransfer", "feComposite", "feConvolveMatrix", "feDiffuseLighting", "feDisplacementMap", "feDistantLight", "feDropShadow", "feFlood", "feFuncA", "feFuncB", "feFuncG", "feFuncR", "feGaussianBlur", "feImage", "feMerge", "feMergeNode", "feMorphology", "feOffset", "fePointLight", "feSpecularLighting", "feSpotLight", "feTile", "feTurbulence", "foreignObject", "linearGradient", "radialGradient", "textPath"];
@@ -3163,6 +3335,10 @@ declare const Reorder: {
         color?: string | undefined;
         translate?: "no" | "yes" | undefined;
         hidden?: boolean | undefined;
+        draggable?: (boolean | "false" | "true") | undefined;
+        children?: React$1.ReactNode;
+        slot?: string | undefined;
+        title?: string | undefined;
         onPlay?: React$1.ReactEventHandler<any> | undefined;
         className?: string | undefined;
         id?: string | undefined;
@@ -3178,7 +3354,7 @@ declare const Reorder: {
         "aria-colindex"?: number | undefined;
         "aria-colspan"?: number | undefined;
         "aria-controls"?: string | undefined;
-        "aria-current"?: boolean | "page" | "false" | "true" | "step" | "location" | "date" | "time" | undefined;
+        "aria-current"?: boolean | "time" | "page" | "false" | "true" | "step" | "location" | "date" | undefined;
         "aria-describedby"?: string | undefined;
         "aria-details"?: string | undefined;
         "aria-disabled"?: (boolean | "false" | "true") | undefined;
@@ -3187,7 +3363,7 @@ declare const Reorder: {
         "aria-expanded"?: (boolean | "false" | "true") | undefined;
         "aria-flowto"?: string | undefined;
         "aria-grabbed"?: (boolean | "false" | "true") | undefined;
-        "aria-haspopup"?: boolean | "grid" | "listbox" | "menu" | "false" | "true" | "dialog" | "tree" | undefined;
+        "aria-haspopup"?: boolean | "grid" | "dialog" | "menu" | "listbox" | "false" | "true" | "tree" | undefined;
         "aria-hidden"?: (boolean | "false" | "true") | undefined;
         "aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined;
         "aria-keyshortcuts"?: string | undefined;
@@ -3217,7 +3393,6 @@ declare const Reorder: {
         "aria-valuemin"?: number | undefined;
         "aria-valuenow"?: number | undefined;
         "aria-valuetext"?: string | undefined;
-        children?: React$1.ReactNode;
         dangerouslySetInnerHTML?: {
             __html: string;
         } | undefined;
@@ -3376,9 +3551,6 @@ declare const Reorder: {
         onAnimationIterationCapture?: React$1.AnimationEventHandler<any> | undefined;
         onTransitionEnd?: React$1.TransitionEventHandler<any> | undefined;
         onTransitionEndCapture?: React$1.TransitionEventHandler<any> | undefined;
-        draggable?: (boolean | "false" | "true") | undefined;
-        slot?: string | undefined;
-        title?: string | undefined;
         defaultChecked?: boolean | undefined;
         defaultValue?: string | number | readonly string[] | undefined;
         suppressContentEditableWarning?: boolean | undefined;
@@ -3408,7 +3580,7 @@ declare const Reorder: {
         itemRef?: string | undefined;
         results?: number | undefined;
         security?: string | undefined;
-        unselectable?: "off" | "on" | undefined;
+        unselectable?: "on" | "off" | undefined;
         inputMode?: "none" | "text" | "search" | "tel" | "url" | "email" | "numeric" | "decimal" | undefined;
         is?: string | undefined;
     } & MotionProps & {
@@ -3418,13 +3590,13 @@ declare const Reorder: {
 
 declare const animations: FeatureComponents;
 
-interface MotionContextProps {
-    visualElement?: VisualElement;
+interface MotionContextProps<Instance = unknown> {
+    visualElement?: VisualElement<Instance>;
     initial?: false | string | string[];
     animate?: string | string[];
 }
-declare const MotionContext: React$1.Context<MotionContextProps>;
-declare function useVisualElementContext(): VisualElement<any, any> | undefined;
+declare const MotionContext: React$1.Context<MotionContextProps<unknown>>;
+declare function useVisualElementContext(): VisualElement<unknown, unknown, {}> | undefined;
 
 declare function checkTargetForNewValues(visualElement: VisualElement, target: TargetWithKeyframes, origin: ResolvedValues): void;
 
@@ -3988,8 +4160,6 @@ declare function isMotionComponent(component: React.ComponentType | string): boo
  */
 declare function unwrapMotionComponent(component: React.ComponentType | string): React.ComponentType | string | undefined;
 
-declare const visualElement: <Instance, MutableState, Options>({ treeType, build, getBaseTarget, makeTargetAnimatable, measureViewportBox, render: renderInstance, readValueFromInstance, removeValueFromRenderState, sortNodePosition, scrapeMotionValuesFromProps, }: VisualElementConfig<Instance, MutableState, Options>) => ({ parent, props, presenceId, blockInitialAnimation, visualState, reducedMotionConfig, }: VisualElementOptions<Instance, any>, options?: Options) => VisualElement<Instance, any>;
-
 declare type ScaleCorrector = (latest: string | number, node: IProjectionNode) => string | number;
 interface ScaleCorrectorDefinition {
     correct: ScaleCorrector;
@@ -4077,4 +4247,4 @@ interface ScaleMotionValues {
  */
 declare function useInvertedScale(scale?: Partial<ScaleMotionValues>): ScaleMotionValues;
 
-export { AnimatePresence, AnimatePresenceProps, AnimateSharedLayout, AnimationControls, AnimationLifecycles, AnimationOptions, AnimationPlaybackControls, AnimationProps, AnimationType, Axis, AxisDelta, BoundingBox, Box, CreateVisualElement, CustomDomComponent, CustomValueType, Cycle, CycleState, DelayedFunction, Delta, DeprecatedLayoutGroupContext, DragControls, DragElastic, DragHandlers, DraggableProps, EasingFunction, EventInfo, FeatureBundle, FeatureComponent, FeatureComponents, FeatureDefinition, FeatureDefinitions, FeatureNames, FeatureProps, FlatTree, FocusHandlers, ForwardRefComponent, HTMLMotionProps, HoverHandlers, IProjectionNode, Inertia, Keyframes, KeyframesTarget, LayoutGroup, LayoutGroupContext, LayoutProps, LazyFeatureBundle$1 as LazyFeatureBundle, LazyMotion, LazyProps, LoadedFeatures, MotionAdvancedProps, MotionConfig, MotionConfigContext, MotionConfigProps, MotionContext, MotionProps, MotionStyle, MotionTransform, MotionValue, None, Orchestration, PanHandlers, PanInfo, PassiveEffect, Point, PresenceContext, RelayoutInfo, RenderComponent, Reorder, Repeat, ResolveLayoutTransition, ResolvedKeyframesTarget, ResolvedSingleTarget, ResolvedValueTarget, ResolvedValues, SVGAttributesAsMotionValues, SVGMotionProps, ScrapeMotionValuesFromProps, ScrollMotionValues, SingleTarget, Spring, Subscriber, SwitchLayoutGroupContext, TapHandlers, TapInfo, Target, TargetAndTransition, TransformPoint, Transition, Tween, ValueTarget, Variant, VariantLabels, Variants, VisualElement, VisualElementLifecycles, VisualState, addPointerEvent, addScaleCorrector, animate, animateVisualElement, animationControls, animations, buildTransform, calcLength, checkTargetForNewValues, createBox, createDomMotionComponent, createMotionComponent, delay, domAnimation, domMax, filterProps, isBrowser, isDragActive, isMotionComponent, isMotionValue, isValidMotionProp, m, makeUseVisualState, motion, motionValue, resolveMotionValue, transform, unwrapMotionComponent, useAnimation, useAnimationControls, useAnimationFrame, useCycle, useAnimatedState as useDeprecatedAnimatedState, useInvertedScale as useDeprecatedInvertedScale, useDomEvent, useDragControls, useElementScroll, useForceUpdate, useInView, useInstantLayoutTransition, useInstantTransition, useIsPresent, useIsomorphicLayoutEffect, useMotionTemplate, useMotionValue, usePresence, useReducedMotion, useReducedMotionConfig, useResetProjection, useScroll, useSpring, useTime, useTransform, useUnmountEffect, useVelocity, useViewportScroll, useVisualElementContext, useWillChange, visualElement, wrapHandler };
+export { AnimatePresence, AnimatePresenceProps, AnimateSharedLayout, AnimationControls, AnimationLifecycles, AnimationOptions$1 as AnimationOptions, AnimationPlaybackControls, AnimationProps, AnimationType, Axis, AxisDelta, BoundingBox, Box, CreateVisualElement, CustomDomComponent, CustomValueType, Cycle, CycleState, DelayedFunction, Delta, DeprecatedLayoutGroupContext, DragControls, DragElastic, DragHandlers, DraggableProps, EasingFunction, EventInfo, FeatureBundle, FeatureComponent, FeatureComponents, FeatureDefinition, FeatureDefinitions, FeatureNames, FeatureProps, FlatTree, FocusHandlers, ForwardRefComponent, HTMLMotionProps, HoverHandlers, IProjectionNode, Inertia, Keyframes, KeyframesTarget, LayoutGroup, LayoutGroupContext, LayoutProps, LazyFeatureBundle$1 as LazyFeatureBundle, LazyMotion, LazyProps, LoadedFeatures, MotionAdvancedProps, MotionConfig, MotionConfigContext, MotionConfigProps, MotionContext, MotionProps, MotionStyle, MotionTransform, MotionValue, None, Orchestration, PanHandlers, PanInfo, PassiveEffect, Point, PresenceContext, RelayoutInfo, RenderComponent, Reorder, Repeat, ResolveLayoutTransition, ResolvedKeyframesTarget, ResolvedSingleTarget, ResolvedValueTarget, ResolvedValues, SVGAttributesAsMotionValues, SVGMotionProps, ScrapeMotionValuesFromProps, ScrollMotionValues, SingleTarget, Spring, Subscriber, SwitchLayoutGroupContext, TapHandlers, TapInfo, Target, TargetAndTransition, TransformPoint, Transition, Tween, ValueTarget, Variant, VariantLabels, Variants, VisualElement, VisualState, addPointerEvent, addScaleCorrector, animate, animateVisualElement, animationControls, animations, buildTransform, calcLength, checkTargetForNewValues, createBox, createDomMotionComponent, createMotionComponent, delay, domAnimation, domMax, filterProps, isBrowser, isDragActive, isMotionComponent, isMotionValue, isValidMotionProp, m, makeUseVisualState, motion, motionValue, resolveMotionValue, transform, unwrapMotionComponent, useAnimation, useAnimationControls, useAnimationFrame, useCycle, useAnimatedState as useDeprecatedAnimatedState, useInvertedScale as useDeprecatedInvertedScale, useDomEvent, useDragControls, useElementScroll, useForceUpdate, useInView, useInstantLayoutTransition, useInstantTransition, useIsPresent, useIsomorphicLayoutEffect, useMotionTemplate, useMotionValue, usePresence, useReducedMotion, useReducedMotionConfig, useResetProjection, useScroll, useSpring, useTime, useTransform, useUnmountEffect, useVelocity, useViewportScroll, useVisualElementContext, useWillChange, wrapHandler };