framer-motion 6.3.10 → 6.3.13

package/types/motion/index.d.ts

@@ -1,25 +0,0 @@
-import * as React from "react";
-import { MotionProps } from "./types";
-import { RenderComponent, FeatureBundle } from "./features/types";
-import { CreateVisualElement } from "../render/types";
-import { UseVisualState } from "./utils/use-visual-state";
-export interface MotionComponentConfig<Instance, RenderState> {
-    preloadedFeatures?: FeatureBundle;
-    createVisualElement?: CreateVisualElement<Instance>;
-    projectionNodeConstructor?: any;
-    useRender: RenderComponent<Instance, RenderState>;
-    useVisualState: UseVisualState<Instance, RenderState>;
-    Component: string | React.ComponentType;
-}
-/**
- * Create a `motion` component.
- *
- * This function accepts a Component argument, which can be either a string (ie "div"
- * for `motion.div`), or an actual React component.
- *
- * Alongside this is a config option which provides a way of rendering the provided
- * component "offline", or outside the React render cycle.
- *
- * @internal
- */
-export declare function createMotionComponent<Props extends {}, Instance, RenderState>({ preloadedFeatures, createVisualElement, projectionNodeConstructor, useRender, useVisualState, Component, }: MotionComponentConfig<Instance, RenderState>): React.ForwardRefExoticComponent<React.PropsWithoutRef<Props & MotionProps> & React.RefAttributes<Instance>>;

package/types/motion/types.d.ts

@@ -1,279 +0,0 @@
-import { CSSProperties } from "react";
-import { MotionValue } from "../value";
-import { AnimationControls } from "../animation/types";
-import { Variants, Target, Transition, TargetAndTransition, Omit, MakeCustomValueType } from "../types";
-import { DraggableProps } from "../gestures/drag/types";
-import { LayoutProps } from "./features/layout/types";
-import { ResolvedValues } from "../render/types";
-import { VisualElementLifecycles } from "../render/utils/lifecycles";
-import { PanHandlers, TapHandlers, HoverHandlers, FocusHandlers } from "../gestures/types";
-import { ViewportProps } from "./features/viewport/types";
-export declare type MotionStyleProp = string | number | MotionValue;
-/**
- * Either a string, or array of strings, that reference variants defined via the `variants` prop.
- * @public
- */
-export declare type VariantLabels = string | string[];
-export 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
- */
-export interface SVGPathProperties {
-    pathLength?: number;
-    pathOffset?: number;
-    pathSpacing?: number;
-}
-export 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;
-}
-export declare type MakeMotion<T> = MakeCustomValueType<{
-    [K in keyof T]: T[K] | MotionValue<number> | MotionValue<string> | MotionValue<any>;
-}>;
-export declare type MotionCSS = MakeMotion<Omit<CSSProperties, "rotate" | "scale" | "perspective">>;
-/**
- * @public
- */
-export declare type MotionTransform = MakeMotion<TransformProperties>;
-/**
- * @public
- */
-export declare type MotionStyle = MotionCSS & MotionTransform & MakeMotion<SVGPathProperties> & MakeCustomValueType<CustomStyles>;
-export declare type OnUpdate = (v: Target) => void;
-/**
- * @public
- */
-export interface RelayoutInfo {
-    delta: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-}
-/**
- * @public
- */
-export declare type ResolveLayoutTransition = (info: RelayoutInfo) => Transition | boolean;
-/**
- * @public
- */
-export 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;
-    /**
-     * 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.
-
-     *
-     * 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;
-}
-/**
- * @public
- */
-export interface MotionAdvancedProps {
-    /**
-     * 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
-     */
-    custom?: any;
-    /**
-     * @public
-     * Set to `false` to prevent inheriting variant changes from its parent.
-     */
-    inherit?: boolean;
-}
-/**
- * Props for `motion` components.
- *
- * @public
- */
-export interface MotionProps extends AnimationProps, VisualElementLifecycles, 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;
-    /**
-     * 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
-     */
-    transformTemplate?(transform: TransformProperties, generatedTransform: string): string;
-    /**
-     * 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 -
-     *
-     * @internal
-     */
-    transformValues?<V extends ResolvedValues>(values: V): V;
-}
-export declare type TransformTemplate = (transform: TransformProperties, generatedTransform: string) => string;

package/types/motion/utils/VisualElementHandler.d.ts

@@ -1,18 +0,0 @@
-import React from "react";
-import { MotionConfigProps } from "../..";
-import { VisualElement } from "../../render/types";
-import { MotionProps } from "../types";
-interface Props {
-    visualElement?: VisualElement;
-    props: MotionProps & MotionConfigProps;
-}
-export declare class VisualElementHandler extends React.Component<React.PropsWithChildren<Props>> {
-    /**
-     * Update visual element props as soon as we know this update is going to be commited.
-     */
-    getSnapshotBeforeUpdate(): null;
-    componentDidUpdate(): void;
-    updateProps(): void;
-    render(): React.ReactNode;
-}
-export {};

package/types/motion/utils/is-forced-motion-value.d.ts

@@ -1,2 +0,0 @@
-import { MotionProps } from "../..";
-export declare function isForcedMotionValue(key: string, { layout, layoutId }: MotionProps): boolean;

package/types/motion/utils/make-renderless-component.d.ts

@@ -1,2 +0,0 @@
-import { FeatureProps } from "../features/types";
-export declare const makeRenderlessComponent: <P = FeatureProps>(hook: Function) => (props: P) => null;

package/types/motion/utils/should-inherit-variant.d.ts

@@ -1,2 +0,0 @@
-import { MotionProps } from "../types";
-export declare function checkShouldInheritVariant({ animate, variants, inherit, }: MotionProps): boolean;

package/types/motion/utils/use-motion-ref.d.ts

@@ -1,8 +0,0 @@
-import * as React from "react";
-import { VisualElement } from "../../render/types";
-import { VisualState } from "./use-visual-state";
-/**
- * Creates a ref function that, when called, hydrates the provided
- * external ref and VisualElement.
- */
-export declare function useMotionRef<Instance, RenderState>(visualState: VisualState<Instance, RenderState>, visualElement?: VisualElement<Instance> | null, externalRef?: React.Ref<Instance>): React.Ref<Instance>;

package/types/motion/utils/use-visual-element.d.ts

@@ -1,6 +0,0 @@
-import * as React from "react";
-import { MotionProps } from "../../motion/types";
-import { CreateVisualElement, VisualElement } from "../../render/types";
-import { VisualState } from "./use-visual-state";
-import { MotionConfigProps } from "../../components/MotionConfig";
-export declare function useVisualElement<Instance, RenderState>(Component: string | React.ComponentType, visualState: VisualState<Instance, RenderState>, props: MotionProps & MotionConfigProps, createVisualElement?: CreateVisualElement<Instance>): VisualElement<Instance> | undefined;

package/types/motion/utils/use-visual-state.d.ts

@@ -1,14 +0,0 @@
-import { ResolvedValues, ScrapeMotionValuesFromProps } from "../../render/types";
-import { MotionProps } from "../types";
-export interface VisualState<Instance, RenderState> {
-    renderState: RenderState;
-    latestValues: ResolvedValues;
-    mount?: (instance: Instance) => void;
-}
-export declare type UseVisualState<Instance, RenderState> = (props: MotionProps, isStatic: boolean) => VisualState<Instance, RenderState>;
-export interface UseVisualStateConfig<Instance, RenderState> {
-    scrapeMotionValuesFromProps: ScrapeMotionValuesFromProps;
-    createRenderState: () => RenderState;
-    onMount?: (props: MotionProps, instance: Instance, visualState: VisualState<Instance, RenderState>) => void;
-}
-export declare const makeUseVisualState: <I, RS>(config: UseVisualStateConfig<I, RS>) => UseVisualState<I, RS>;

package/types/motion/utils/valid-prop.d.ts

@@ -1,9 +0,0 @@
-/**
- * Check whether a prop name is a valid `MotionProp` key.
- *
- * @param key - Name of the property to check
- * @returns `true` is key is a valid `MotionProp`.
- *
- * @public
- */
-export declare function isValidMotionProp(key: string): boolean;

package/types/projection/animation/mix-values.d.ts

@@ -1,2 +0,0 @@
-import { ResolvedValues } from "../../render/types";
-export declare function mixValues(target: ResolvedValues, follow: ResolvedValues, lead: ResolvedValues, progress: number, shouldCrossfadeOpacity: boolean, isOnlyMember: boolean): void;

package/types/projection/geometry/conversion.d.ts

@@ -1,14 +0,0 @@
-import { BoundingBox, Box, TransformPoint } from "./types";
-/**
- * Bounding boxes tend to be defined as top, left, right, bottom. For various operations
- * it's easier to consider each axis individually. This function returns a bounding box
- * as a map of single-axis min/max values.
- */
-export declare function convertBoundingBoxToBox({ top, left, right, bottom, }: BoundingBox): Box;
-export declare function convertBoxToBoundingBox({ x, y }: Box): BoundingBox;
-/**
- * Applies a TransformPoint function to a bounding box. TransformPoint is usually a function
- * provided by Framer to allow measured points to be corrected for device scaling. This is used
- * when measuring DOM elements and DOM event points.
- */
-export declare function transformBoxPoints(point: BoundingBox, transformPoint?: TransformPoint): BoundingBox;

package/types/projection/geometry/copy.d.ts

@@ -1,13 +0,0 @@
-import { Axis, Box } from "./types";
-/**
- * Reset an axis to the provided origin box.
- *
- * This is a mutative operation.
- */
-export declare function copyAxisInto(axis: Axis, originAxis: Axis): void;
-/**
- * Reset a box to the provided origin box.
- *
- * This is a mutative operation.
- */
-export declare function copyBoxInto(box: Box, originBox: Box): void;

package/types/projection/geometry/delta-apply.d.ts

@@ -1,37 +0,0 @@
-import { ResolvedValues } from "../../render/types";
-import { IProjectionNode } from "../node/types";
-import { Axis, Box, Delta, Point } from "./types";
-/**
- * Scales a point based on a factor and an originPoint
- */
-export declare function scalePoint(point: number, scale: number, originPoint: number): number;
-/**
- * Applies a translate/scale delta to a point
- */
-export declare function applyPointDelta(point: number, translate: number, scale: number, originPoint: number, boxScale?: number): number;
-/**
- * Applies a translate/scale delta to an axis
- */
-export declare function applyAxisDelta(axis: Axis, translate: number | undefined, scale: number | undefined, originPoint: number, boxScale?: number): void;
-/**
- * Applies a translate/scale delta to a box
- */
-export declare function applyBoxDelta(box: Box, { x, y }: Delta): void;
-/**
- * Apply a tree of deltas to a box. We do this to calculate the effect of all the transforms
- * in a tree upon our box before then calculating how to project it into our desired viewport-relative box
- *
- * This is the final nested loop within updateLayoutDelta for future refactoring
- */
-export declare function applyTreeDeltas(box: Box, treeScale: Point, treePath: IProjectionNode[], isSharedTransition?: boolean): void;
-export declare function translateAxis(axis: Axis, distance: number): void;
-/**
- * Apply a transform to an axis from the latest resolved motion values.
- * This function basically acts as a bridge between a flat motion value map
- * and applyAxisDelta
- */
-export declare function transformAxis(axis: Axis, transforms: ResolvedValues, [key, scaleKey, originKey]: string[]): void;
-/**
- * Apply a transform to a box from the latest resolved motion values.
- */
-export declare function transformBox(box: Box, transform: ResolvedValues): void;

package/types/projection/geometry/delta-calc.d.ts

@@ -1,10 +0,0 @@
-import { ResolvedValues } from "../../render/types";
-import { Axis, AxisDelta, Box, Delta } from "./types";
-export declare function calcLength(axis: Axis): number;
-export declare function isNear(value: number, target?: number, maxDistance?: number): boolean;
-export declare function calcAxisDelta(delta: AxisDelta, source: Axis, target: Axis, origin?: number): void;
-export declare function calcBoxDelta(delta: Delta, source: Box, target: Box, origin?: ResolvedValues): void;
-export declare function calcRelativeAxis(target: Axis, relative: Axis, parent: Axis): void;
-export declare function calcRelativeBox(target: Box, relative: Box, parent: Box): void;
-export declare function calcRelativeAxisPosition(target: Axis, layout: Axis, parent: Axis): void;
-export declare function calcRelativePosition(target: Box, layout: Box, parent: Box): void;

package/types/projection/geometry/delta-remove.d.ts

@@ -1,20 +0,0 @@
-import { ResolvedValues } from "../../render/types";
-import { Axis, Box } from "./types";
-/**
- * Remove a delta from a point. This is essentially the steps of applyPointDelta in reverse
- */
-export declare function removePointDelta(point: number, translate: number, scale: number, originPoint: number, boxScale?: number): number;
-/**
- * Remove a delta from an axis. This is essentially the steps of applyAxisDelta in reverse
- */
-export declare function removeAxisDelta(axis: Axis, translate?: number | string, scale?: number, origin?: number, boxScale?: number, originAxis?: Axis, sourceAxis?: Axis): void;
-/**
- * Remove a transforms from an axis. This is essentially the steps of applyAxisTransforms in reverse
- * and acts as a bridge between motion values and removeAxisDelta
- */
-export declare function removeAxisTransforms(axis: Axis, transforms: ResolvedValues, [key, scaleKey, originKey]: string[], origin?: Axis, sourceAxis?: Axis): void;
-/**
- * Remove a transforms from an box. This is essentially the steps of applyAxisBox in reverse
- * and acts as a bridge between motion values and removeAxisDelta
- */
-export declare function removeBoxTransforms(box: Box, transforms: ResolvedValues, originBox?: Box, sourceBox?: Box): void;

package/types/projection/geometry/models.d.ts

@@ -1,5 +0,0 @@
-import { Axis, AxisDelta, Box, Delta } from "./types";
-export declare const createAxisDelta: () => AxisDelta;
-export declare const createDelta: () => Delta;
-export declare const createAxis: () => Axis;
-export declare const createBox: () => Box;

package/types/projection/geometry/types.d.ts

@@ -1,29 +0,0 @@
-export interface Point {
-    x: number;
-    y: number;
-}
-export interface Axis {
-    min: number;
-    max: number;
-}
-export interface Box {
-    x: Axis;
-    y: Axis;
-}
-export interface BoundingBox {
-    top: number;
-    right: number;
-    bottom: number;
-    left: number;
-}
-export interface AxisDelta {
-    translate: number;
-    scale: number;
-    origin: number;
-    originPoint: number;
-}
-export interface Delta {
-    x: AxisDelta;
-    y: AxisDelta;
-}
-export declare type TransformPoint = (point: Point) => Point;

package/types/projection/geometry/utils.d.ts

@@ -1,3 +0,0 @@
-import { Box, Delta } from "./types";
-export declare function isDeltaZero(delta: Delta): boolean;
-export declare function boxEquals(a: Box, b: Box): boolean;

package/types/projection/index.d.ts

@@ -1,14 +0,0 @@
-export { HTMLProjectionNode } from "./node/HTMLProjectionNode";
-export { nodeGroup } from "./node/group";
-export { calcBoxDelta } from "./geometry/delta-calc";
-/**
- * For debugging purposes
- */
-import sync from "framesync";
-import { animate, mix } from "popmotion";
-export { sync, animate, mix };
-export { buildTransform } from "../render/html/utils/build-transform";
-export { addScaleCorrector } from "./styles/scale-correction";
-export { correctBorderRadius } from "./styles/scale-border-radius";
-export { correctBoxShadow } from "./styles/scale-box-shadow";
-export { htmlVisualElement } from "../render/html/visual-element";

package/types/projection/node/DocumentProjectionNode.d.ts

@@ -1,108 +0,0 @@
-export declare const DocumentProjectionNode: {
-    new (id: number | undefined, latestValues?: import("../..").ResolvedValues, parent?: import("./types").IProjectionNode<unknown> | undefined): {
-        id: number | undefined;
-        instance: Window;
-        root: import("./types").IProjectionNode<unknown>;
-        parent?: import("./types").IProjectionNode<unknown> | undefined;
-        path: import("./types").IProjectionNode<unknown>[];
-        children: Set<import("./types").IProjectionNode<unknown>>;
-        options: import("./types").ProjectionNodeOptions;
-        snapshot: import("./types").Snapshot | undefined;
-        layout: import("./types").Layout | undefined;
-        targetLayout?: import("../..").Box | undefined;
-        layoutCorrected: import("../..").Box;
-        targetDelta?: import("../..").Delta | undefined;
-        target?: import("../..").Box | undefined;
-        relativeTarget?: import("../..").Box | undefined;
-        relativeTargetOrigin?: import("../..").Box | undefined;
-        relativeParent?: import("./types").IProjectionNode<unknown> | undefined;
-        isTreeAnimating: boolean;
-        isAnimationBlocked: boolean;
-        attemptToResolveRelativeTarget?: boolean | undefined;
-        targetWithTransforms?: import("../..").Box | undefined;
-        projectionDelta?: import("../..").Delta | undefined;
-        projectionDeltaWithTransform?: import("../..").Delta | undefined;
-        scroll?: import("../..").Point | undefined;
-        isLayoutDirty: boolean;
-        updateManuallyBlocked: boolean;
-        updateBlockedByResize: boolean;
-        isUpdating: boolean;
-        isSVG: boolean;
-        needsReset: boolean;
-        shouldResetTransform: boolean;
-        treeScale: import("../..").Point;
-        resumeFrom?: import("./types").IProjectionNode<unknown> | undefined;
-        resumingFrom?: import("./types").IProjectionNode<unknown> | undefined;
-        latestValues: import("../..").ResolvedValues;
-        eventHandlers: Map<import("./types").LayoutEvents, import("../../utils/subscription-manager").SubscriptionManager<any>>;
-        nodes?: import("../..").FlatTree | undefined;
-        depth: number;
-        projectionTransform: string;
-        prevTransformTemplateValue: string | undefined;
-        preserveOpacity?: boolean | undefined;
-        addEventListener(name: import("./types").LayoutEvents, handler: any): () => void;
-        notifyListeners(name: import("./types").LayoutEvents, ...args: any): void;
-        hasListeners(name: import("./types").LayoutEvents): boolean;
-        potentialNodes: Map<number, import("./types").IProjectionNode<unknown>>;
-        registerPotentialNode(id: number, node: import("./types").IProjectionNode<unknown>): void;
-        mount(instance: Window, isLayoutDirty?: boolean): void;
-        unmount(): void;
-        blockUpdate(): void;
-        unblockUpdate(): void;
-        isUpdateBlocked(): boolean;
-        isTreeAnimationBlocked(): boolean;
-        startUpdate(): void;
-        willUpdate(shouldNotifyListeners?: boolean): void;
-        didUpdate(): void;
-        clearAllSnapshots(): void;
-        scheduleUpdateProjection(): void;
-        scheduleCheckAfterUnmount(): void;
-        checkUpdateFailed: () => void;
-        updateProjection: () => void;
-        updateSnapshot(): void;
-        updateLayout(): void;
-        updateScroll(): void;
-        resetTransform(): void;
-        measure(): import("../..").Box;
-        removeElementScroll(box: import("../..").Box): import("../..").Box;
-        applyTransform(box: import("../..").Box, transformOnly?: boolean): import("../..").Box;
-        removeTransform(box: import("../..").Box): import("../..").Box;
-        setTargetDelta(delta: import("../..").Delta): void;
-        setOptions(options: import("./types").ProjectionNodeOptions): void;
-        clearMeasurements(): void;
-        resolveTargetDelta(): void;
-        getClosestProjectingParent(): import("./types").IProjectionNode<unknown> | undefined;
-        hasProjected: boolean;
-        calcProjection(): void;
-        isVisible: boolean;
-        hide(): void;
-        show(): void;
-        scheduleRender(notifyAll?: boolean): void;
-        animationValues?: import("../..").ResolvedValues | undefined;
-        pendingAnimation?: import("framesync").Process | undefined;
-        currentAnimation?: import("../..").AnimationPlaybackControls | undefined;
-        mixTargetDelta: (progress: number) => void;
-        animationProgress: number;
-        setAnimationOrigin(delta: import("../..").Delta, hasOnlyRelativeTargetChanged?: boolean): void;
-        startAnimation(options: import("../..").AnimationOptions<number>): void;
-        completeAnimation(): void;
-        finishAnimation(): void;
-        applyTransformsToTarget(): void;
-        sharedNodes: Map<string, import("../shared/stack").NodeStack>;
-        registerSharedNode(layoutId: string, node: import("./types").IProjectionNode<unknown>): void;
-        isLead(): boolean;
-        getLead(): import("./types").IProjectionNode<unknown> | any;
-        getPrevLead(): import("./types").IProjectionNode<unknown> | undefined;
-        getStack(): import("../shared/stack").NodeStack | undefined;
-        promote({ needsReset, transition, preserveFollowOpacity, }?: {
-            needsReset?: boolean | undefined;
-            transition?: import("../..").Transition | undefined;
-            preserveFollowOpacity?: boolean | undefined;
-        }): void;
-        relegate(): boolean;
-        resetRotation(): void;
-        getProjectionStyles(styleProp?: import("../..").MotionStyle): import("../..").ResolvedValues;
-        clearSnapshot(): void;
-        resetTree(): void;
-    };
-};