@cossistant/react 0.0.14 → 0.0.17

package/index5.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index5.d.ts","names":["Box","Easing","EasingFunction","BezierDefinition","Point","BoundingBox","Axis","SVGAttributes","AnyResolvedKeyframe","Update$1","DriverControls","Driver","WithRender","HTMLElement","SVGElement","ProgressTimeline","VoidFunction","ValueAnimationOptionsWithRenderContext","V","KeyframeResolver","MotionValue","ValueAnimationOptions","TimelineWithFallback","AnimationPlaybackControls","AnimationPlayState","Promise","AnimationPlaybackControlsWithThen","AnimationState","KeyframeGenerator","DOMValueAnimationOptions","ValueKeyframesDefinition","ValueAnimationTransition","GeneratorFactoryFunction","GeneratorFactory","Transition","AnimationGeneratorName","AnimationGeneratorType","AnimationPlaybackLifecycles","ValueTransition","RepeatType","AnimationPlaybackOptions","VelocityOptions","DurationSpringOptions","SpringOptions","Spring","DecayOptions","InertiaOptions","AnimationOrchestrationOptions","DynamicOption","KeyframeOptions","Omit","Tween","SVGForcedAttrTransitions","SVGForcedAttrProperties","SVGPathTransitions","SVGPathProperties","SVGTransitions","VariableTransitions","StyleTransitions","CSSStyleDeclarationWithTransform","ValueKeyframe","T","UnresolvedValueKeyframe","ResolvedValueKeyframe","StyleKeyframesDefinition","SVGKeyframesDefinition","VariableKeyframesDefinition","SVGForcedAttrKeyframesDefinition","SVGPathKeyframesDefinition","DOMKeyframesDefinition","Target","CSSPropertyKeys","CSSStyleDeclaration","K","TransitionWithValueOverrides","ValueAnimationWithDynamicDelay","AnimationOptions","TransformProperties","Subscriber","PassiveEffect","StartAnimation","MotionValueEventCallbacks","ResolvedValues$1","Owner","MotionValueOptions","collectMotionValues","EventName","NonNullable","motionValue","UnresolvedKeyframes","Array","ResolvedKeyframes","flushKeyframeResolvers","OnKeyframesResolved","WithPromise","OptionsWithoutKeyframes","AsyncMotionValueAnimation","autoplay","delay","type","repeat","repeatDelay","repeatType","keyframes","name","element","AcceptedAnimations","GroupedAnimations","GroupAnimation","GroupAnimationWithThen","JSAnimation","animateValue","NativeAnimationOptions","NativeAnimation","Animation","timeline","observe","NativeAnimationOptionsExtended","NativeAnimationExtended","NativeAnimationWrapper","animationMapKey","getAnimationMap","Element","Map","CSSVariableName","CSSVariableToken","isCSSVariableName","isCSSVariableToken","parseCSSVariable","getVariableValue","getValueTransition","makeAnimationInstant","Partial","inertia","velocity","power","timeConstant","bounceDamping","bounceStiffness","modifyTarget","min","max","restDelta","restSpeed","defaultEasing","duration","keyframeValues","times","ease","spring","maxGeneratorDuration","calcGeneratorDuration","createGeneratorEasing","isGenerator","DOMKeyframesResolver","defaultOffset","fillOffset","convertOffsetToTimes","applyPxDefaults","fillWildcards","cubicBezierAsString","isWaapiSupportedEasing","mapEasingToNativeEasing","supportedWaapiEasing","startWaapiAnimation","supportsPartialKeyframes","supportsBrowserAnimation","acceleratedValues","Set","applyGeneratorOptions","generateLinearEasing","MotionValueState","addAttrValue","attrEffect","ElementOrSelector","Record","propEffect","addStyleValue","styleEffect","svgEffect","frame","Batcher","cancelFrame","Process","frameData","FrameData","frameSteps","Steps","Schedule","Step","StepId","CancelProcess","createRenderBatcher","Function","microtask","cancelMicrotask","time","isDragging","isDragActive","setDragLock","PanInfo","PanHandler","Event","DragHandler","MouseEvent","TouchEvent","PointerEvent","DragElastic","ResolvedConstraints","ResolvedElastic","NodeListOf","WithQuerySelectorAll","AnimationScope","SelectorCache","resolveElements","EventOptions","OnHoverStartEvent","OnHoverEndEvent","hover","PressGestureInfo","OnPressEndEvent","OnPressStartEvent","PointerEventOptions","press","isNodeOrChild","isPrimaryPointer","EventInfo","ResolvedValues","AnimationDefinition","VariantLabels","TargetAndTransition","TargetResolver","Variant","Variants","LegacyAnimationControls","MotionNodeAnimationOptions","MotionNodeEventOptions","MotionNodePanHandlers","MotionNodeHoverHandlers","TapInfo","MotionNodeTapHandlers","TapHandlers","MotionNodeFocusHandlers","ViewportEventHandler","IntersectionObserverEntry","ViewportOptions","MotionNodeViewportOptions","MotionNodeDraggableOptions","MotionNodeDragHandlers","MotionNodeLayoutOptions","DraggableProps","TransformTemplate","MotionNodeAdvancedOptions","MotionNodeOptions","defaultTransformValue","parseValueFromTransform","readTransformValue","getComputedStyle","setStyle","positionalKeys","transformPropOrder","transformProps","ResizeInfo","ResizeHandler","I","WindowResizeHandler","resize","Update","observeTimeline","stepsOrder","StepNames","Summary","FrameloopStatNames","Stats","StatsBuffer","FrameStats","StatsRecording","StatsSummary","reportStats","recordStats","activeAnimations","InactiveStatsBuffer","ActiveStatsBuffer","statsBuffer","Mixer","MixerFactory","InterpolateOptions","interpolate","isClamp","mixer","isHTMLElement","isSVGElement","isSVGSVGElement","SVGSVGElement","mix","Transformer","ValueType","NumberMap","RGBA","HSLA","Color","mixLinearColor","mixColor","MixableArray","MixableObject","getMixer","mixArray","mixObject","mixComplex","mixImmediate","mixNumber","invisibleValues","mixVisibility","StaggerOrigin","StaggerOptions","getOriginIndex","stagger","startDelay","from","supportsFlags","supportsLinearEasing","_0","ScrollTimeline","sideEffect","ScrollOptions","supportsScrollTimeline","TransformOptions","transform","MapInputRange","mapValue","O","springValue","attachSpring","TransformInputRange","SingleTransformer","MultiTransformer","ValueTransformer","transformValue","color","parseHex","hex","red","green","blue","alpha","hsla","hue","saturation","lightness","hslaToRgba","rgbUnit","parseFloat","rgba","test","ComplexValues","ValueIndexes","ComplexValueInfo","analyseComplexValue","parseComplexValue","createTransformer","getAnimatableNone$1","complex","dimensionValueTypes","findDimensionValueType","ValueTypeMap","defaultValueTypes","getDefaultValueType","numberValueTypes","transformValueTypes","number","scale","degrees","percent","px","vh","vw","progressPercentage","testValueType","getAnimatableNone","findValueType","getValueAsType","isMotionValue","ViewTransitionAnimationDefinition","ViewTransitionTarget","ViewTransitionOptions","ViewTransitionTargetDefinition","ViewTransitionBuilder","animateView","getViewAnimationLayerInfo","getViewAnimations","sync","cancelSync"],"sources":["../../../node_modules/.bun/motion-dom@12.23.23/node_modules/motion-dom/dist/index.d.ts"],"sourcesContent":["import { Box, Easing, EasingFunction, BezierDefinition, Point, BoundingBox, Axis } from 'motion-utils';\n\ninterface SVGAttributes {\n    accentHeight?: AnyResolvedKeyframe | undefined;\n    accumulate?: \"none\" | \"sum\" | undefined;\n    additive?: \"replace\" | \"sum\" | undefined;\n    alignmentBaseline?: \"auto\" | \"baseline\" | \"before-edge\" | \"text-before-edge\" | \"middle\" | \"central\" | \"after-edge\" | \"text-after-edge\" | \"ideographic\" | \"alphabetic\" | \"hanging\" | \"mathematical\" | \"inherit\" | undefined;\n    allowReorder?: \"no\" | \"yes\" | undefined;\n    alphabetic?: AnyResolvedKeyframe | undefined;\n    amplitude?: AnyResolvedKeyframe | undefined;\n    arabicForm?: \"initial\" | \"medial\" | \"terminal\" | \"isolated\" | undefined;\n    ascent?: AnyResolvedKeyframe | undefined;\n    attributeName?: string | undefined;\n    attributeType?: string | undefined;\n    autoReverse?: boolean | undefined;\n    azimuth?: AnyResolvedKeyframe | undefined;\n    baseFrequency?: AnyResolvedKeyframe | undefined;\n    baselineShift?: AnyResolvedKeyframe | undefined;\n    baseProfile?: AnyResolvedKeyframe | undefined;\n    bbox?: AnyResolvedKeyframe | undefined;\n    begin?: AnyResolvedKeyframe | undefined;\n    bias?: AnyResolvedKeyframe | undefined;\n    by?: AnyResolvedKeyframe | undefined;\n    calcMode?: AnyResolvedKeyframe | undefined;\n    capHeight?: AnyResolvedKeyframe | undefined;\n    clip?: AnyResolvedKeyframe | undefined;\n    clipPath?: string | undefined;\n    clipPathUnits?: AnyResolvedKeyframe | undefined;\n    clipRule?: AnyResolvedKeyframe | undefined;\n    colorInterpolation?: AnyResolvedKeyframe | undefined;\n    colorInterpolationFilters?: \"auto\" | \"sRGB\" | \"linearRGB\" | \"inherit\" | undefined;\n    colorProfile?: AnyResolvedKeyframe | undefined;\n    colorRendering?: AnyResolvedKeyframe | undefined;\n    contentScriptType?: AnyResolvedKeyframe | undefined;\n    contentStyleType?: AnyResolvedKeyframe | undefined;\n    cursor?: AnyResolvedKeyframe | undefined;\n    cx?: AnyResolvedKeyframe | undefined;\n    cy?: AnyResolvedKeyframe | undefined;\n    d?: string | undefined;\n    decelerate?: AnyResolvedKeyframe | undefined;\n    descent?: AnyResolvedKeyframe | undefined;\n    diffuseConstant?: AnyResolvedKeyframe | undefined;\n    direction?: AnyResolvedKeyframe | undefined;\n    display?: AnyResolvedKeyframe | undefined;\n    divisor?: AnyResolvedKeyframe | undefined;\n    dominantBaseline?: AnyResolvedKeyframe | undefined;\n    dur?: AnyResolvedKeyframe | undefined;\n    dx?: AnyResolvedKeyframe | undefined;\n    dy?: AnyResolvedKeyframe | undefined;\n    edgeMode?: AnyResolvedKeyframe | undefined;\n    elevation?: AnyResolvedKeyframe | undefined;\n    enableBackground?: AnyResolvedKeyframe | undefined;\n    end?: AnyResolvedKeyframe | undefined;\n    exponent?: AnyResolvedKeyframe | undefined;\n    externalResourcesRequired?: boolean | undefined;\n    fill?: string | undefined;\n    fillOpacity?: AnyResolvedKeyframe | undefined;\n    fillRule?: \"nonzero\" | \"evenodd\" | \"inherit\" | undefined;\n    filter?: string | undefined;\n    filterRes?: AnyResolvedKeyframe | undefined;\n    filterUnits?: AnyResolvedKeyframe | undefined;\n    floodColor?: AnyResolvedKeyframe | undefined;\n    floodOpacity?: AnyResolvedKeyframe | undefined;\n    focusable?: boolean | \"auto\" | undefined;\n    fontFamily?: string | undefined;\n    fontSize?: AnyResolvedKeyframe | undefined;\n    fontSizeAdjust?: AnyResolvedKeyframe | undefined;\n    fontStretch?: AnyResolvedKeyframe | undefined;\n    fontStyle?: AnyResolvedKeyframe | undefined;\n    fontVariant?: AnyResolvedKeyframe | undefined;\n    fontWeight?: AnyResolvedKeyframe | undefined;\n    format?: AnyResolvedKeyframe | undefined;\n    fr?: AnyResolvedKeyframe | undefined;\n    from?: AnyResolvedKeyframe | undefined;\n    fx?: AnyResolvedKeyframe | undefined;\n    fy?: AnyResolvedKeyframe | undefined;\n    g1?: AnyResolvedKeyframe | undefined;\n    g2?: AnyResolvedKeyframe | undefined;\n    glyphName?: AnyResolvedKeyframe | undefined;\n    glyphOrientationHorizontal?: AnyResolvedKeyframe | undefined;\n    glyphOrientationVertical?: AnyResolvedKeyframe | undefined;\n    glyphRef?: AnyResolvedKeyframe | undefined;\n    gradientTransform?: string | undefined;\n    gradientUnits?: string | undefined;\n    hanging?: AnyResolvedKeyframe | undefined;\n    horizAdvX?: AnyResolvedKeyframe | undefined;\n    horizOriginX?: AnyResolvedKeyframe | undefined;\n    href?: string | undefined;\n    ideographic?: AnyResolvedKeyframe | undefined;\n    imageRendering?: AnyResolvedKeyframe | undefined;\n    in2?: AnyResolvedKeyframe | undefined;\n    in?: string | undefined;\n    intercept?: AnyResolvedKeyframe | undefined;\n    k1?: AnyResolvedKeyframe | undefined;\n    k2?: AnyResolvedKeyframe | undefined;\n    k3?: AnyResolvedKeyframe | undefined;\n    k4?: AnyResolvedKeyframe | undefined;\n    k?: AnyResolvedKeyframe | undefined;\n    kernelMatrix?: AnyResolvedKeyframe | undefined;\n    kernelUnitLength?: AnyResolvedKeyframe | undefined;\n    kerning?: AnyResolvedKeyframe | undefined;\n    keyPoints?: AnyResolvedKeyframe | undefined;\n    keySplines?: AnyResolvedKeyframe | undefined;\n    keyTimes?: AnyResolvedKeyframe | undefined;\n    lengthAdjust?: AnyResolvedKeyframe | undefined;\n    letterSpacing?: AnyResolvedKeyframe | undefined;\n    lightingColor?: AnyResolvedKeyframe | undefined;\n    limitingConeAngle?: AnyResolvedKeyframe | undefined;\n    local?: AnyResolvedKeyframe | undefined;\n    markerEnd?: string | undefined;\n    markerHeight?: AnyResolvedKeyframe | undefined;\n    markerMid?: string | undefined;\n    markerStart?: string | undefined;\n    markerUnits?: AnyResolvedKeyframe | undefined;\n    markerWidth?: AnyResolvedKeyframe | undefined;\n    mask?: string | undefined;\n    maskContentUnits?: AnyResolvedKeyframe | undefined;\n    maskUnits?: AnyResolvedKeyframe | undefined;\n    mathematical?: AnyResolvedKeyframe | undefined;\n    mode?: AnyResolvedKeyframe | undefined;\n    numOctaves?: AnyResolvedKeyframe | undefined;\n    offset?: AnyResolvedKeyframe | undefined;\n    opacity?: AnyResolvedKeyframe | undefined;\n    operator?: AnyResolvedKeyframe | undefined;\n    order?: AnyResolvedKeyframe | undefined;\n    orient?: AnyResolvedKeyframe | undefined;\n    orientation?: AnyResolvedKeyframe | undefined;\n    origin?: AnyResolvedKeyframe | undefined;\n    overflow?: AnyResolvedKeyframe | undefined;\n    overlinePosition?: AnyResolvedKeyframe | undefined;\n    overlineThickness?: AnyResolvedKeyframe | undefined;\n    paintOrder?: AnyResolvedKeyframe | undefined;\n    panose1?: AnyResolvedKeyframe | undefined;\n    path?: string | undefined;\n    pathLength?: AnyResolvedKeyframe | undefined;\n    patternContentUnits?: string | undefined;\n    patternTransform?: AnyResolvedKeyframe | undefined;\n    patternUnits?: string | undefined;\n    pointerEvents?: AnyResolvedKeyframe | undefined;\n    points?: string | undefined;\n    pointsAtX?: AnyResolvedKeyframe | undefined;\n    pointsAtY?: AnyResolvedKeyframe | undefined;\n    pointsAtZ?: AnyResolvedKeyframe | undefined;\n    preserveAlpha?: boolean | undefined;\n    preserveAspectRatio?: string | undefined;\n    primitiveUnits?: AnyResolvedKeyframe | undefined;\n    r?: AnyResolvedKeyframe | undefined;\n    radius?: AnyResolvedKeyframe | undefined;\n    refX?: AnyResolvedKeyframe | undefined;\n    refY?: AnyResolvedKeyframe | undefined;\n    renderingIntent?: AnyResolvedKeyframe | undefined;\n    repeatCount?: AnyResolvedKeyframe | undefined;\n    repeatDur?: AnyResolvedKeyframe | undefined;\n    requiredExtensions?: AnyResolvedKeyframe | undefined;\n    requiredFeatures?: AnyResolvedKeyframe | undefined;\n    restart?: AnyResolvedKeyframe | undefined;\n    result?: string | undefined;\n    rotate?: AnyResolvedKeyframe | undefined;\n    rx?: AnyResolvedKeyframe | undefined;\n    ry?: AnyResolvedKeyframe | undefined;\n    scale?: AnyResolvedKeyframe | undefined;\n    seed?: AnyResolvedKeyframe | undefined;\n    shapeRendering?: AnyResolvedKeyframe | undefined;\n    slope?: AnyResolvedKeyframe | undefined;\n    spacing?: AnyResolvedKeyframe | undefined;\n    specularConstant?: AnyResolvedKeyframe | undefined;\n    specularExponent?: AnyResolvedKeyframe | undefined;\n    speed?: AnyResolvedKeyframe | undefined;\n    spreadMethod?: string | undefined;\n    startOffset?: AnyResolvedKeyframe | undefined;\n    stdDeviation?: AnyResolvedKeyframe | undefined;\n    stemh?: AnyResolvedKeyframe | undefined;\n    stemv?: AnyResolvedKeyframe | undefined;\n    stitchTiles?: AnyResolvedKeyframe | undefined;\n    stopColor?: string | undefined;\n    stopOpacity?: AnyResolvedKeyframe | undefined;\n    strikethroughPosition?: AnyResolvedKeyframe | undefined;\n    strikethroughThickness?: AnyResolvedKeyframe | undefined;\n    string?: AnyResolvedKeyframe | undefined;\n    stroke?: string | undefined;\n    strokeDasharray?: AnyResolvedKeyframe | undefined;\n    strokeDashoffset?: AnyResolvedKeyframe | undefined;\n    strokeLinecap?: \"butt\" | \"round\" | \"square\" | \"inherit\" | undefined;\n    strokeLinejoin?: \"miter\" | \"round\" | \"bevel\" | \"inherit\" | undefined;\n    strokeMiterlimit?: AnyResolvedKeyframe | undefined;\n    strokeOpacity?: AnyResolvedKeyframe | undefined;\n    strokeWidth?: AnyResolvedKeyframe | undefined;\n    surfaceScale?: AnyResolvedKeyframe | undefined;\n    systemLanguage?: AnyResolvedKeyframe | undefined;\n    tableValues?: AnyResolvedKeyframe | undefined;\n    targetX?: AnyResolvedKeyframe | undefined;\n    targetY?: AnyResolvedKeyframe | undefined;\n    textAnchor?: string | undefined;\n    textDecoration?: AnyResolvedKeyframe | undefined;\n    textLength?: AnyResolvedKeyframe | undefined;\n    textRendering?: AnyResolvedKeyframe | undefined;\n    to?: AnyResolvedKeyframe | undefined;\n    transform?: string | undefined;\n    u1?: AnyResolvedKeyframe | undefined;\n    u2?: AnyResolvedKeyframe | undefined;\n    underlinePosition?: AnyResolvedKeyframe | undefined;\n    underlineThickness?: AnyResolvedKeyframe | undefined;\n    unicode?: AnyResolvedKeyframe | undefined;\n    unicodeBidi?: AnyResolvedKeyframe | undefined;\n    unicodeRange?: AnyResolvedKeyframe | undefined;\n    unitsPerEm?: AnyResolvedKeyframe | undefined;\n    vAlphabetic?: AnyResolvedKeyframe | undefined;\n    values?: string | undefined;\n    vectorEffect?: AnyResolvedKeyframe | undefined;\n    version?: string | undefined;\n    vertAdvY?: AnyResolvedKeyframe | undefined;\n    vertOriginX?: AnyResolvedKeyframe | undefined;\n    vertOriginY?: AnyResolvedKeyframe | undefined;\n    vHanging?: AnyResolvedKeyframe | undefined;\n    vIdeographic?: AnyResolvedKeyframe | undefined;\n    viewBox?: string | undefined;\n    viewTarget?: AnyResolvedKeyframe | undefined;\n    visibility?: AnyResolvedKeyframe | undefined;\n    vMathematical?: AnyResolvedKeyframe | undefined;\n    widths?: AnyResolvedKeyframe | undefined;\n    wordSpacing?: AnyResolvedKeyframe | undefined;\n    writingMode?: AnyResolvedKeyframe | undefined;\n    x1?: AnyResolvedKeyframe | undefined;\n    x2?: AnyResolvedKeyframe | undefined;\n    x?: AnyResolvedKeyframe | undefined;\n    xChannelSelector?: string | undefined;\n    xHeight?: AnyResolvedKeyframe | undefined;\n    xlinkActuate?: string | undefined;\n    xlinkArcrole?: string | undefined;\n    xlinkHref?: string | undefined;\n    xlinkRole?: string | undefined;\n    xlinkShow?: string | undefined;\n    xlinkTitle?: string | undefined;\n    xlinkType?: string | undefined;\n    xmlBase?: string | undefined;\n    xmlLang?: string | undefined;\n    xmlns?: string | undefined;\n    xmlnsXlink?: string | undefined;\n    xmlSpace?: string | undefined;\n    y1?: AnyResolvedKeyframe | undefined;\n    y2?: AnyResolvedKeyframe | undefined;\n    y?: AnyResolvedKeyframe | undefined;\n    yChannelSelector?: string | undefined;\n    z?: AnyResolvedKeyframe | undefined;\n    zoomAndPan?: string | undefined;\n}\n\n/**\n * An update function. It accepts a timestamp used to advance the animation.\n */\ntype Update$1 = (timestamp: number) => void;\n/**\n * Drivers accept a update function and call it at an interval. This interval\n * could be a synchronous loop, a setInterval, or tied to the device's framerate.\n */\ninterface DriverControls {\n    start: (keepAlive?: boolean) => void;\n    stop: () => void;\n    now: () => number;\n}\ntype Driver = (update: Update$1) => DriverControls;\n\n/**\n * Temporary subset of VisualElement until VisualElement is\n * moved to motion-dom\n */\ninterface WithRender {\n    render: () => void;\n    readValue: (name: string, keyframe: any) => any;\n    getValue: (name: string, defaultValue?: any) => any;\n    current?: HTMLElement | SVGElement;\n    measureViewportBox: () => Box;\n}\n\ntype AnyResolvedKeyframe = string | number;\ninterface ProgressTimeline {\n    currentTime: null | {\n        value: number;\n    };\n    cancel?: VoidFunction;\n}\ninterface ValueAnimationOptionsWithRenderContext<V extends AnyResolvedKeyframe = number> extends ValueAnimationOptions<V> {\n    KeyframeResolver?: typeof KeyframeResolver;\n    motionValue?: MotionValue<V>;\n    element?: WithRender;\n}\ninterface TimelineWithFallback {\n    timeline?: ProgressTimeline;\n    observe: (animation: AnimationPlaybackControls) => VoidFunction;\n}\n/**\n * Methods to control an animation.\n */\ninterface AnimationPlaybackControls {\n    /**\n     * The current time of the animation, in seconds.\n     */\n    time: number;\n    /**\n     * The playback speed of the animation.\n     * 1 = normal speed, 2 = double speed, 0.5 = half speed.\n     */\n    speed: number;\n    /**\n     * The start time of the animation, in milliseconds.\n     */\n    startTime: number | null;\n    /**\n     * The state of the animation.\n     *\n     * This is currently for internal use only.\n     */\n    state: AnimationPlayState;\n    duration: number;\n    /**\n     * The duration of the animation, including any delay.\n     */\n    iterationDuration: number;\n    /**\n     * Stops the animation at its current state, and prevents it from\n     * resuming when the animation is played again.\n     */\n    stop: () => void;\n    /**\n     * Plays the animation.\n     */\n    play: () => void;\n    /**\n     * Pauses the animation.\n     */\n    pause: () => void;\n    /**\n     * Completes the animation and applies the final state.\n     */\n    complete: () => void;\n    /**\n     * Cancels the animation and applies the initial state.\n     */\n    cancel: () => void;\n    /**\n     * Attaches a timeline to the animation, for instance the `ScrollTimeline`.\n     *\n     * This is currently for internal use only.\n     */\n    attachTimeline: (timeline: TimelineWithFallback) => VoidFunction;\n    finished: Promise<any>;\n}\ntype AnimationPlaybackControlsWithThen = AnimationPlaybackControls & {\n    then: (onResolve: VoidFunction, onReject?: VoidFunction) => Promise<void>;\n};\ninterface AnimationState<V> {\n    value: V;\n    done: boolean;\n}\ninterface KeyframeGenerator<V> {\n    calculatedDuration: null | number;\n    next: (t: number) => AnimationState<V>;\n    toString: () => string;\n}\ninterface DOMValueAnimationOptions<V extends AnyResolvedKeyframe = number> extends ValueAnimationTransition<V> {\n    element: HTMLElement | SVGElement;\n    keyframes: ValueKeyframesDefinition;\n    name: string;\n    pseudoElement?: string;\n    allowFlatten?: boolean;\n}\ninterface ValueAnimationOptions<V extends AnyResolvedKeyframe = number> extends ValueAnimationTransition {\n    keyframes: V[];\n    element?: any;\n    name?: string;\n    motionValue?: MotionValue<V>;\n    from?: any;\n    isHandoff?: boolean;\n    allowFlatten?: boolean;\n    finalKeyframe?: V;\n}\ntype GeneratorFactoryFunction = (options: ValueAnimationOptions<any>) => KeyframeGenerator<any>;\ninterface GeneratorFactory extends GeneratorFactoryFunction {\n    applyToOptions?: (options: Transition) => Transition;\n}\ntype AnimationGeneratorName = \"decay\" | \"spring\" | \"keyframes\" | \"tween\" | \"inertia\";\ntype AnimationGeneratorType = GeneratorFactory | AnimationGeneratorName | false;\ninterface AnimationPlaybackLifecycles<V> {\n    onUpdate?: (latest: V) => void;\n    onPlay?: () => void;\n    onComplete?: () => void;\n    onRepeat?: () => void;\n    onStop?: () => void;\n}\ninterface ValueAnimationTransition<V = any> extends ValueTransition, AnimationPlaybackLifecycles<V> {\n    isSync?: boolean;\n}\ntype RepeatType = \"loop\" | \"reverse\" | \"mirror\";\ninterface AnimationPlaybackOptions {\n    /**\n     * The number of times to repeat the transition. Set to `Infinity` for perpetual repeating.\n     *\n     * Without setting `repeatType`, this will loop the animation.\n     *\n     * @public\n     */\n    repeat?: number;\n    /**\n     * How to repeat the animation. This can be either:\n     *\n     * \"loop\": Repeats the animation from the start\n     *\n     * \"reverse\": Alternates between forward and backwards playback\n     *\n     * \"mirror\": Switches `from` and `to` alternately\n     *\n     * @public\n     */\n    repeatType?: RepeatType;\n    /**\n     * When repeating an animation, `repeatDelay` will set the\n     * duration of the time to wait, in seconds, between each repetition.\n     *\n     * @public\n     */\n    repeatDelay?: number;\n}\ninterface VelocityOptions {\n    velocity?: number;\n    /**\n     * End animation if absolute speed (in units per second) drops below this\n     * value and delta is smaller than `restDelta`. Set to `0.01` by default.\n     *\n     * @public\n     */\n    restSpeed?: number;\n    /**\n     * End animation if distance is below this value and speed is below\n     * `restSpeed`. When animation ends, spring gets \"snapped\" to. Set to\n     * `0.01` by default.\n     *\n     * @public\n     */\n    restDelta?: number;\n}\ninterface DurationSpringOptions {\n    /**\n     * The total duration of the animation. Set to `0.3` by default.\n     *\n     * @public\n     */\n    duration?: number;\n    /**\n     * If visualDuration is set, this will override duration.\n     *\n     * The visual duration is a time, set in seconds, that the animation will take to visually appear to reach its target.\n     *\n     * In other words, the bulk of the transition will occur before this time, and the \"bouncy bit\" will mostly happen after.\n     *\n     * This makes it easier to edit a spring, as well as visually coordinate it with other time-based animations.\n     *\n     * @public\n     */\n    visualDuration?: number;\n    /**\n     * `bounce` determines the \"bounciness\" of a spring animation.\n     *\n     * `0` is no bounce, and `1` is extremely bouncy.\n     *\n     * If `duration` is set, this defaults to `0.25`.\n     *\n     * Note: `bounce` and `duration` will be overridden if `stiffness`, `damping` or `mass` are set.\n     *\n     * @public\n     */\n    bounce?: number;\n}\ninterface SpringOptions extends DurationSpringOptions, VelocityOptions {\n    /**\n     * Stiffness of the spring. Higher values will create more sudden movement.\n     * Set to `100` by default.\n     *\n     * @public\n     */\n    stiffness?: number;\n    /**\n     * Strength of opposing force. If set to 0, spring will oscillate\n     * indefinitely. Set to `10` by default.\n     *\n     * @public\n     */\n    damping?: number;\n    /**\n     * Mass of the moving object. Higher values will result in more lethargic\n     * movement. Set to `1` by default.\n     *\n     * @public\n     */\n    mass?: number;\n}\n/**\n * @deprecated Use SpringOptions instead\n */\ninterface Spring extends SpringOptions {\n}\ninterface DecayOptions extends VelocityOptions {\n    keyframes?: number[];\n    /**\n     * A higher power value equals a further target. Set to `0.8` by default.\n     *\n     * @public\n     */\n    power?: number;\n    /**\n     * Adjusting the time constant will change the duration of the\n     * deceleration, thereby affecting its feel. Set to `700` by default.\n     *\n     * @public\n     */\n    timeConstant?: number;\n    /**\n     * A function that receives the automatically-calculated target and returns a new one. Useful for snapping the target to a grid.\n     *\n     * @public\n     */\n    modifyTarget?: (v: number) => number;\n}\ninterface InertiaOptions extends DecayOptions {\n    /**\n     * If `min` or `max` is set, this affects the stiffness of the bounce\n     * spring. Higher values will create more sudden movement. Set to `500` by\n     * default.\n     *\n     * @public\n     */\n    bounceStiffness?: number;\n    /**\n     * If `min` or `max` is set, this affects the damping of the bounce spring.\n     * If set to `0`, spring will oscillate indefinitely. Set to `10` by\n     * default.\n     *\n     * @public\n     */\n    bounceDamping?: number;\n    /**\n     * 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).\n     *\n     * @public\n     */\n    min?: number;\n    /**\n     * Maximum constraint. If set, the value will \"bump\" against this value (or immediately snap to it, if the initial animation value exceeds this value).\n     *\n     * @public\n     */\n    max?: number;\n}\ninterface AnimationOrchestrationOptions {\n    /**\n     * Delay the animation by this duration (in seconds). Defaults to `0`.\n     *\n     * @public\n     */\n    delay?: number;\n    /**\n     * Describes the relationship between the transition and its children. Set\n     * to `false` by default.\n     *\n     * @remarks\n     * When using variants, the transition can be scheduled in relation to its\n     * children with either `\"beforeChildren\"` to finish this transition before\n     * starting children transitions, `\"afterChildren\"` to finish children\n     * transitions before starting this transition.\n     *\n     * @public\n     */\n    when?: false | \"beforeChildren\" | \"afterChildren\" | string;\n    /**\n     * When using variants, children animations will start after this duration\n     * (in seconds). You can add the `transition` property to both the `motion.div` and the\n     * `variant` directly. Adding it to the `variant` generally offers more flexibility,\n     * as it allows you to customize the delay per visual state.\n     *\n     * @public\n     */\n    delayChildren?: number | DynamicOption<number>;\n    /**\n     * When using variants, animations of child components can be staggered by this\n     * duration (in seconds).\n     *\n     * For instance, if `staggerChildren` is `0.01`, the first child will be\n     * delayed by `0` seconds, the second by `0.01`, the third by `0.02` and so\n     * on.\n     *\n     * The calculated stagger delay will be added to `delayChildren`.\n     *\n     * @deprecated - Use `delayChildren: stagger(interval)` instead.\n     */\n    staggerChildren?: number;\n    /**\n     * The direction in which to stagger children.\n     *\n     * A value of `1` staggers from the first to the last while `-1`\n     * staggers from the last to the first.\n     *\n     * @deprecated - Use `delayChildren: stagger(interval, { from: \"last\" })` instead.\n     */\n    staggerDirection?: number;\n}\ninterface KeyframeOptions {\n    /**\n     * The total duration of the animation. Set to `0.3` by default.\n     *\n     * @public\n     */\n    duration?: number;\n    ease?: Easing | Easing[];\n    times?: number[];\n}\ninterface ValueTransition extends AnimationOrchestrationOptions, AnimationPlaybackOptions, Omit<SpringOptions, \"keyframes\">, Omit<InertiaOptions, \"keyframes\">, KeyframeOptions {\n    /**\n     * Delay the animation by this duration (in seconds). Defaults to `0`.\n     *\n     * @public\n     */\n    delay?: number;\n    /**\n     * The duration of time already elapsed in the animation. Set to `0` by\n     * default.\n     */\n    elapsed?: number;\n    driver?: Driver;\n    /**\n     * Type of animation to use.\n     *\n     * - \"tween\": Duration-based animation with ease curve\n     * - \"spring\": Physics or duration-based spring animation\n     * - false: Use an instant animation\n     */\n    type?: AnimationGeneratorType;\n    /**\n     * The duration of the tween animation. Set to `0.3` by default, 0r `0.8` if animating a series of keyframes.\n     *\n     * @public\n     */\n    duration?: number;\n    autoplay?: boolean;\n    startTime?: number;\n    from?: any;\n}\n/**\n * @deprecated Use KeyframeOptions instead\n */\ninterface Tween extends KeyframeOptions {\n}\ntype SVGForcedAttrTransitions = {\n    [K in keyof SVGForcedAttrProperties]: ValueTransition;\n};\ntype SVGPathTransitions = {\n    [K in keyof SVGPathProperties]: ValueTransition;\n};\ntype SVGTransitions = {\n    [K in keyof Omit<SVGAttributes, \"from\">]: ValueTransition;\n};\ninterface VariableTransitions {\n    [key: `--${string}`]: ValueTransition;\n}\ntype StyleTransitions = {\n    [K in keyof CSSStyleDeclarationWithTransform]?: ValueTransition;\n};\ntype ValueKeyframe<T extends AnyResolvedKeyframe = AnyResolvedKeyframe> = T;\ntype UnresolvedValueKeyframe<T extends AnyResolvedKeyframe = AnyResolvedKeyframe> = ValueKeyframe<T> | null;\ntype ResolvedValueKeyframe = ValueKeyframe | ValueKeyframe[];\ntype ValueKeyframesDefinition = ValueKeyframe | ValueKeyframe[] | UnresolvedValueKeyframe[];\ntype StyleKeyframesDefinition = {\n    [K in keyof CSSStyleDeclarationWithTransform]?: ValueKeyframesDefinition;\n};\ntype SVGKeyframesDefinition = {\n    [K in keyof Omit<SVGAttributes, \"from\">]?: ValueKeyframesDefinition;\n};\ninterface VariableKeyframesDefinition {\n    [key: `--${string}`]: ValueKeyframesDefinition;\n}\ntype SVGForcedAttrKeyframesDefinition = {\n    [K in keyof SVGForcedAttrProperties]?: ValueKeyframesDefinition;\n};\ntype SVGPathKeyframesDefinition = {\n    [K in keyof SVGPathProperties]?: ValueKeyframesDefinition;\n};\ntype DOMKeyframesDefinition = StyleKeyframesDefinition & SVGKeyframesDefinition & SVGPathKeyframesDefinition & SVGForcedAttrKeyframesDefinition & VariableKeyframesDefinition;\ninterface Target extends DOMKeyframesDefinition {\n}\ntype CSSPropertyKeys = {\n    [K in keyof CSSStyleDeclaration as K extends string ? CSSStyleDeclaration[K] extends AnyResolvedKeyframe ? K : never : never]: CSSStyleDeclaration[K];\n};\ninterface CSSStyleDeclarationWithTransform extends Omit<CSSPropertyKeys, \"direction\" | \"transition\" | \"x\" | \"y\" | \"z\"> {\n    x: number | string;\n    y: number | string;\n    z: number | string;\n    originX: number;\n    originY: number;\n    originZ: number;\n    translateX: number | string;\n    translateY: number | string;\n    translateZ: number | string;\n    rotateX: number | string;\n    rotateY: number | string;\n    rotateZ: number | string;\n    scaleX: number;\n    scaleY: number;\n    scaleZ: number;\n    skewX: number | string;\n    skewY: number | string;\n    transformPerspective: number;\n}\ntype TransitionWithValueOverrides<V> = ValueAnimationTransition<V> & StyleTransitions & SVGPathTransitions & SVGForcedAttrTransitions & SVGTransitions & VariableTransitions & {\n    default?: ValueTransition;\n    layout?: ValueTransition;\n};\ntype Transition<V = any> = ValueAnimationTransition<V> | TransitionWithValueOverrides<V>;\ntype DynamicOption<T> = (i: number, total: number) => T;\ntype ValueAnimationWithDynamicDelay = Omit<ValueAnimationTransition<any>, \"delay\"> & {\n    delay?: number | DynamicOption<number>;\n};\ntype AnimationOptions = ValueAnimationWithDynamicDelay | (ValueAnimationWithDynamicDelay & StyleTransitions & SVGPathTransitions & SVGForcedAttrTransitions & SVGTransitions & VariableTransitions & {\n    default?: ValueTransition;\n    layout?: ValueTransition;\n});\ninterface TransformProperties {\n    x?: AnyResolvedKeyframe;\n    y?: AnyResolvedKeyframe;\n    z?: AnyResolvedKeyframe;\n    translateX?: AnyResolvedKeyframe;\n    translateY?: AnyResolvedKeyframe;\n    translateZ?: AnyResolvedKeyframe;\n    rotate?: AnyResolvedKeyframe;\n    rotateX?: AnyResolvedKeyframe;\n    rotateY?: AnyResolvedKeyframe;\n    rotateZ?: AnyResolvedKeyframe;\n    scale?: AnyResolvedKeyframe;\n    scaleX?: AnyResolvedKeyframe;\n    scaleY?: AnyResolvedKeyframe;\n    scaleZ?: AnyResolvedKeyframe;\n    skew?: AnyResolvedKeyframe;\n    skewX?: AnyResolvedKeyframe;\n    skewY?: AnyResolvedKeyframe;\n    originX?: AnyResolvedKeyframe;\n    originY?: AnyResolvedKeyframe;\n    originZ?: AnyResolvedKeyframe;\n    perspective?: AnyResolvedKeyframe;\n    transformPerspective?: AnyResolvedKeyframe;\n}\ninterface SVGForcedAttrProperties {\n    attrX?: number;\n    attrY?: number;\n    attrScale?: number;\n}\ninterface SVGPathProperties {\n    pathLength?: number;\n    pathOffset?: number;\n    pathSpacing?: number;\n}\n\n/**\n * @public\n */\ntype Subscriber<T> = (v: T) => void;\n/**\n * @public\n */\ntype PassiveEffect<T> = (v: T, safeSetter: (v: T) => void) => void;\ntype StartAnimation = (complete: () => void) => AnimationPlaybackControlsWithThen | undefined;\ninterface MotionValueEventCallbacks<V> {\n    animationStart: () => void;\n    animationComplete: () => void;\n    animationCancel: () => void;\n    change: (latestValue: V) => void;\n    destroy: () => void;\n}\ninterface ResolvedValues$1 {\n    [key: string]: AnyResolvedKeyframe;\n}\ninterface Owner {\n    current: HTMLElement | unknown;\n    getProps: () => {\n        onUpdate?: (latest: ResolvedValues$1) => void;\n        transformTemplate?: (transform: TransformProperties, generatedTransform: string) => string;\n    };\n}\ninterface MotionValueOptions {\n    owner?: Owner;\n}\ndeclare const collectMotionValues: {\n    current: MotionValue[] | undefined;\n};\n/**\n * `MotionValue` is used to track the state and velocity of motion values.\n *\n * @public\n */\ndeclare class MotionValue<V = any> {\n    /**\n     * If a MotionValue has an owner, it was created internally within Motion\n     * and therefore has no external listeners. It is therefore safe to animate via WAAPI.\n     */\n    owner?: Owner;\n    /**\n     * The current state of the `MotionValue`.\n     */\n    private current;\n    /**\n     * The previous state of the `MotionValue`.\n     */\n    private prev;\n    /**\n     * The previous state of the `MotionValue` at the end of the previous frame.\n     */\n    private prevFrameValue;\n    /**\n     * The last time the `MotionValue` was updated.\n     */\n    updatedAt: number;\n    /**\n     * The time `prevFrameValue` was updated.\n     */\n    prevUpdatedAt: number | undefined;\n    private stopPassiveEffect?;\n    /**\n     * Whether the passive effect is active.\n     */\n    isEffectActive?: boolean;\n    /**\n     * A reference to the currently-controlling animation.\n     */\n    animation?: AnimationPlaybackControlsWithThen;\n    /**\n     * A list of MotionValues whose values are computed from this one.\n     * This is a rough start to a proper signal-like dirtying system.\n     */\n    private dependents;\n    /**\n     * Tracks whether this value should be removed\n     */\n    liveStyle?: boolean;\n    /**\n     * @param init - The initiating value\n     * @param config - Optional configuration options\n     *\n     * -  `transformer`: A function to transform incoming values with.\n     */\n    constructor(init: V, options?: MotionValueOptions);\n    setCurrent(current: V): void;\n    setPrevFrameValue(prevFrameValue?: V | undefined): void;\n    /**\n     * Adds a function that will be notified when the `MotionValue` is updated.\n     *\n     * It returns a function that, when called, will cancel the subscription.\n     *\n     * When calling `onChange` inside a React component, it should be wrapped with the\n     * `useEffect` hook. As it returns an unsubscribe function, this should be returned\n     * from the `useEffect` function to ensure you don't add duplicate subscribers..\n     *\n     * ```jsx\n     * export const MyComponent = () => {\n     *   const x = useMotionValue(0)\n     *   const y = useMotionValue(0)\n     *   const opacity = useMotionValue(1)\n     *\n     *   useEffect(() => {\n     *     function updateOpacity() {\n     *       const maxXY = Math.max(x.get(), y.get())\n     *       const newOpacity = transform(maxXY, [0, 100], [1, 0])\n     *       opacity.set(newOpacity)\n     *     }\n     *\n     *     const unsubscribeX = x.on(\"change\", updateOpacity)\n     *     const unsubscribeY = y.on(\"change\", updateOpacity)\n     *\n     *     return () => {\n     *       unsubscribeX()\n     *       unsubscribeY()\n     *     }\n     *   }, [])\n     *\n     *   return <motion.div style={{ x }} />\n     * }\n     * ```\n     *\n     * @param subscriber - A function that receives the latest value.\n     * @returns A function that, when called, will cancel this subscription.\n     *\n     * @deprecated\n     */\n    onChange(subscription: Subscriber<V>): () => void;\n    /**\n     * An object containing a SubscriptionManager for each active event.\n     */\n    private events;\n    on<EventName extends keyof MotionValueEventCallbacks<V>>(eventName: EventName, callback: MotionValueEventCallbacks<V>[EventName]): VoidFunction;\n    clearListeners(): void;\n    /**\n     * Attaches a passive effect to the `MotionValue`.\n     */\n    attach(passiveEffect: PassiveEffect<V>, stopPassiveEffect: VoidFunction): void;\n    /**\n     * Sets the state of the `MotionValue`.\n     *\n     * @remarks\n     *\n     * ```jsx\n     * const x = useMotionValue(0)\n     * x.set(10)\n     * ```\n     *\n     * @param latest - Latest value to set.\n     * @param render - Whether to notify render subscribers. Defaults to `true`\n     *\n     * @public\n     */\n    set(v: V): void;\n    setWithVelocity(prev: V, current: V, delta: number): void;\n    /**\n     * Set the state of the `MotionValue`, stopping any active animations,\n     * effects, and resets velocity to `0`.\n     */\n    jump(v: V, endAnimation?: boolean): void;\n    dirty(): void;\n    addDependent(dependent: MotionValue): void;\n    removeDependent(dependent: MotionValue): void;\n    updateAndNotify: (v: V) => void;\n    /**\n     * Returns the latest state of `MotionValue`\n     *\n     * @returns - The latest state of `MotionValue`\n     *\n     * @public\n     */\n    get(): NonNullable<V>;\n    /**\n     * @public\n     */\n    getPrevious(): V | undefined;\n    /**\n     * Returns the latest velocity of `MotionValue`\n     *\n     * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.\n     *\n     * @public\n     */\n    getVelocity(): number;\n    hasAnimated: boolean;\n    /**\n     * Registers a new animation to control this `MotionValue`. Only one\n     * animation can drive a `MotionValue` at one time.\n     *\n     * ```jsx\n     * value.start()\n     * ```\n     *\n     * @param animation - A function that starts the provided animation\n     */\n    start(startAnimation: StartAnimation): Promise<void>;\n    /**\n     * Stop the currently active animation.\n     *\n     * @public\n     */\n    stop(): void;\n    /**\n     * Returns `true` if this value is currently animating.\n     *\n     * @public\n     */\n    isAnimating(): boolean;\n    private clearAnimation;\n    /**\n     * Destroy and clean up subscribers to this `MotionValue`.\n     *\n     * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically\n     * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually\n     * created a `MotionValue` via the `motionValue` function.\n     *\n     * @public\n     */\n    destroy(): void;\n}\ndeclare function motionValue<V>(init: V, options?: MotionValueOptions): MotionValue<V>;\n\ntype UnresolvedKeyframes<T extends AnyResolvedKeyframe> = Array<T | null>;\ntype ResolvedKeyframes<T extends AnyResolvedKeyframe> = Array<T>;\ndeclare function flushKeyframeResolvers(): void;\ntype OnKeyframesResolved<T extends AnyResolvedKeyframe> = (resolvedKeyframes: ResolvedKeyframes<T>, finalKeyframe: T, forced: boolean) => void;\ndeclare class KeyframeResolver<T extends AnyResolvedKeyframe = any> {\n    name?: string;\n    element?: WithRender;\n    finalKeyframe?: T;\n    suspendedScrollY?: number;\n    protected unresolvedKeyframes: UnresolvedKeyframes<AnyResolvedKeyframe>;\n    private motionValue?;\n    private onComplete;\n    state: \"pending\" | \"scheduled\" | \"complete\";\n    /**\n     * Track whether this resolver is async. If it is, it'll be added to the\n     * resolver queue and flushed in the next frame. Resolvers that aren't going\n     * to trigger read/write thrashing don't need to be async.\n     */\n    private isAsync;\n    /**\n     * Track whether this resolver needs to perform a measurement\n     * to resolve its keyframes.\n     */\n    needsMeasurement: boolean;\n    constructor(unresolvedKeyframes: UnresolvedKeyframes<AnyResolvedKeyframe>, onComplete: OnKeyframesResolved<T>, name?: string, motionValue?: MotionValue<T>, element?: WithRender, isAsync?: boolean);\n    scheduleResolve(): void;\n    readKeyframes(): void;\n    setFinalKeyframe(): void;\n    measureInitialState(): void;\n    renderEndStyles(): void;\n    measureEndState(): void;\n    complete(isForcedComplete?: boolean): void;\n    cancel(): void;\n    resume(): void;\n}\n\ndeclare class WithPromise {\n    protected _finished: Promise<void>;\n    resolve: VoidFunction;\n    constructor();\n    get finished(): Promise<void>;\n    protected updateFinished(): void;\n    protected notifyFinished(): void;\n    /**\n     * Allows the animation to be awaited.\n     *\n     * @deprecated Use `finished` instead.\n     */\n    then(onResolve: VoidFunction, onReject?: VoidFunction): Promise<void>;\n}\n\ntype OptionsWithoutKeyframes<T extends AnyResolvedKeyframe> = Omit<ValueAnimationOptions<T>, \"keyframes\">;\ndeclare class AsyncMotionValueAnimation<T extends AnyResolvedKeyframe> extends WithPromise implements AnimationPlaybackControls {\n    private createdAt;\n    private resolvedAt;\n    private _animation;\n    private pendingTimeline;\n    private keyframeResolver;\n    private stopTimeline;\n    constructor({ autoplay, delay, type, repeat, repeatDelay, repeatType, keyframes, name, motionValue, element, ...options }: ValueAnimationOptions<T>);\n    onKeyframesResolved(keyframes: ResolvedKeyframes<T>, finalKeyframe: T, options: OptionsWithoutKeyframes<T>, sync: boolean): void;\n    get finished(): Promise<any>;\n    then(onResolve: VoidFunction, _onReject?: VoidFunction): Promise<void>;\n    get animation(): AnimationPlaybackControls;\n    get duration(): number;\n    get iterationDuration(): number;\n    get time(): number;\n    set time(newTime: number);\n    get speed(): number;\n    get state(): AnimationPlayState;\n    set speed(newSpeed: number);\n    get startTime(): number | null;\n    attachTimeline(timeline: TimelineWithFallback): () => void;\n    play(): void;\n    pause(): void;\n    complete(): void;\n    cancel(): void;\n    /**\n     * Bound to support return animation.stop pattern\n     */\n    stop: () => void;\n}\n\ntype AcceptedAnimations = AnimationPlaybackControls;\ntype GroupedAnimations = AcceptedAnimations[];\ndeclare class GroupAnimation implements AnimationPlaybackControls {\n    animations: GroupedAnimations;\n    constructor(animations: Array<AcceptedAnimations | undefined>);\n    get finished(): Promise<any[]>;\n    /**\n     * TODO: Filter out cancelled or stopped animations before returning\n     */\n    private getAll;\n    private setAll;\n    attachTimeline(timeline: TimelineWithFallback): () => void;\n    get time(): number;\n    set time(time: number);\n    get speed(): number;\n    set speed(speed: number);\n    get state(): any;\n    get startTime(): any;\n    get duration(): number;\n    get iterationDuration(): number;\n    private runAll;\n    play(): void;\n    pause(): void;\n    stop: () => void;\n    cancel(): void;\n    complete(): void;\n}\n\ndeclare class GroupAnimationWithThen extends GroupAnimation implements AnimationPlaybackControlsWithThen {\n    then(onResolve: VoidFunction, _onReject?: VoidFunction): Promise<void>;\n}\n\ndeclare class JSAnimation<T extends number | string> extends WithPromise implements AnimationPlaybackControlsWithThen {\n    state: AnimationPlayState;\n    startTime: number | null;\n    /**\n     * The driver that's controlling the animation loop. Normally this is a requestAnimationFrame loop\n     * but in tests we can pass in a synchronous loop.\n     */\n    private driver?;\n    private isStopped;\n    private generator;\n    private calculatedDuration;\n    private resolvedDuration;\n    private totalDuration;\n    private options;\n    /**\n     * The current time of the animation.\n     */\n    private currentTime;\n    /**\n     * The time at which the animation was paused.\n     */\n    private holdTime;\n    /**\n     * Playback speed as a factor. 0 would be stopped, -1 reverse and 2 double speed.\n     */\n    private playbackSpeed;\n    private mixKeyframes;\n    private mirroredGenerator;\n    constructor(options: ValueAnimationOptions<T>);\n    initAnimation(): void;\n    updateTime(timestamp: number): void;\n    tick(timestamp: number, sample?: boolean): AnimationState<T>;\n    /**\n     * Allows the returned animation to be awaited or promise-chained. Currently\n     * resolves when the animation finishes at all but in a future update could/should\n     * reject if its cancels.\n     */\n    then(resolve: VoidFunction, reject?: VoidFunction): Promise<void>;\n    get duration(): number;\n    get iterationDuration(): number;\n    get time(): number;\n    set time(newTime: number);\n    get speed(): number;\n    set speed(newSpeed: number);\n    play(): void;\n    pause(): void;\n    /**\n     * This method is bound to the instance to fix a pattern where\n     * animation.stop is returned as a reference from a useEffect.\n     */\n    stop: () => void;\n    complete(): void;\n    finish(): void;\n    cancel(): void;\n    private teardown;\n    private stopDriver;\n    sample(sampleTime: number): AnimationState<T>;\n    attachTimeline(timeline: TimelineWithFallback): VoidFunction;\n}\ndeclare function animateValue<T extends number | string>(options: ValueAnimationOptions<T>): JSAnimation<T>;\n\ninterface NativeAnimationOptions<V extends AnyResolvedKeyframe = number> extends DOMValueAnimationOptions<V> {\n    pseudoElement?: string;\n    startTime?: number;\n}\n/**\n * NativeAnimation implements AnimationPlaybackControls for the browser's Web Animations API.\n */\ndeclare class NativeAnimation<T extends AnyResolvedKeyframe> extends WithPromise implements AnimationPlaybackControlsWithThen {\n    /**\n     * The interfaced Web Animation API animation\n     */\n    protected animation: Animation;\n    protected finishedTime: number | null;\n    protected options: NativeAnimationOptions;\n    private allowFlatten;\n    private isStopped;\n    private isPseudoElement;\n    constructor(options?: NativeAnimationOptions);\n    updateMotionValue?(value?: T): void;\n    play(): void;\n    pause(): void;\n    complete(): void;\n    cancel(): void;\n    stop(): void;\n    /**\n     * WAAPI doesn't natively have any interruption capabilities.\n     *\n     * In this method, we commit styles back to the DOM before cancelling\n     * the animation.\n     *\n     * This is designed to be overridden by NativeAnimationExtended, which\n     * will create a renderless JS animation and sample it twice to calculate\n     * its current value, \"previous\" value, and therefore allow\n     * Motion to also correctly calculate velocity for any subsequent animation\n     * while deferring the commit until the next animation frame.\n     */\n    protected commitStyles(): void;\n    get duration(): number;\n    get iterationDuration(): number;\n    get time(): number;\n    set time(newTime: number);\n    /**\n     * The playback speed of the animation.\n     * 1 = normal speed, 2 = double speed, 0.5 = half speed.\n     */\n    get speed(): number;\n    set speed(newSpeed: number);\n    get state(): AnimationPlayState;\n    get startTime(): number;\n    set startTime(newStartTime: number);\n    /**\n     * Attaches a timeline to the animation, for instance the `ScrollTimeline`.\n     */\n    attachTimeline({ timeline, observe }: TimelineWithFallback): VoidFunction;\n}\n\ntype NativeAnimationOptionsExtended<T extends AnyResolvedKeyframe> = NativeAnimationOptions & ValueAnimationOptions<T> & NativeAnimationOptions;\ndeclare class NativeAnimationExtended<T extends AnyResolvedKeyframe> extends NativeAnimation<T> {\n    options: NativeAnimationOptionsExtended<T>;\n    constructor(options: NativeAnimationOptionsExtended<T>);\n    /**\n     * WAAPI doesn't natively have any interruption capabilities.\n     *\n     * Rather than read commited styles back out of the DOM, we can\n     * create a renderless JS animation and sample it twice to calculate\n     * its current value, \"previous\" value, and therefore allow\n     * Motion to calculate velocity for any subsequent animation.\n     */\n    updateMotionValue(value?: T): void;\n}\n\ndeclare class NativeAnimationWrapper<T extends AnyResolvedKeyframe> extends NativeAnimation<T> {\n    constructor(animation: Animation);\n}\n\ndeclare const animationMapKey: (name: string, pseudoElement?: string) => string;\ndeclare function getAnimationMap(element: Element): Map<any, any>;\n\ntype CSSVariableName = `--${string}`;\ntype CSSVariableToken = `var(${CSSVariableName})`;\ndeclare const isCSSVariableName: (key?: AnyResolvedKeyframe | null) => key is `--${string}`;\ndeclare const isCSSVariableToken: (value?: string) => value is `var(--${string})`;\n\ndeclare function parseCSSVariable(current: string): string[] | undefined[];\ndeclare function getVariableValue(current: CSSVariableToken, element: Element, depth?: number): AnyResolvedKeyframe | undefined;\n\ndeclare function getValueTransition(transition: any, key: string): any;\n\ndeclare function makeAnimationInstant(options: Partial<{\n    duration: ValueAnimationOptions[\"duration\"];\n    type: ValueAnimationOptions[\"type\"];\n}>): void;\n\ndeclare function inertia({ keyframes, velocity, power, timeConstant, bounceDamping, bounceStiffness, modifyTarget, min, max, restDelta, restSpeed, }: ValueAnimationOptions<number>): KeyframeGenerator<number>;\n\ndeclare function defaultEasing(values: any[], easing?: EasingFunction): EasingFunction[];\ndeclare function keyframes<T extends AnyResolvedKeyframe>({ duration, keyframes: keyframeValues, times, ease, }: ValueAnimationOptions<T>): KeyframeGenerator<T>;\n\ndeclare function spring(optionsOrVisualDuration?: ValueAnimationOptions<number> | number, bounce?: number): KeyframeGenerator<number>;\ndeclare namespace spring {\n    var applyToOptions: (options: Transition) => Transition;\n}\n\n/**\n * Implement a practical max duration for keyframe generation\n * to prevent infinite loops\n */\ndeclare const maxGeneratorDuration = 20000;\ndeclare function calcGeneratorDuration(generator: KeyframeGenerator<unknown>): number;\n\n/**\n * Create a progress => progress easing function from a generator.\n */\ndeclare function createGeneratorEasing(options: Transition, scale: number | undefined, createGenerator: GeneratorFactory): {\n    type: string;\n    ease: (progress: number) => number;\n    duration: number;\n};\n\ndeclare function isGenerator(type?: AnimationGeneratorType): type is GeneratorFactory;\n\ndeclare class DOMKeyframesResolver<T extends AnyResolvedKeyframe> extends KeyframeResolver<T> {\n    name: string;\n    element?: WithRender;\n    private removedTransforms?;\n    private measuredOrigin?;\n    constructor(unresolvedKeyframes: UnresolvedKeyframes<AnyResolvedKeyframe>, onComplete: OnKeyframesResolved<T>, name?: string, motionValue?: MotionValue<T>, element?: WithRender);\n    readKeyframes(): void;\n    resolveNoneKeyframes(): void;\n    measureInitialState(): void;\n    measureEndState(): void;\n}\n\ndeclare function defaultOffset(arr: any[]): number[];\n\ndeclare function fillOffset(offset: number[], remaining: number): void;\n\ndeclare function convertOffsetToTimes(offset: number[], duration: number): number[];\n\ndeclare function applyPxDefaults(keyframes: ValueKeyframe[] | UnresolvedValueKeyframe[], name: string): void;\n\ndeclare function fillWildcards(keyframes: ValueKeyframe[] | UnresolvedValueKeyframe[]): void;\n\ndeclare const cubicBezierAsString: ([a, b, c, d]: BezierDefinition) => string;\n\ndeclare function isWaapiSupportedEasing(easing?: Easing | Easing[]): boolean;\n\ndeclare function mapEasingToNativeEasing(easing: Easing | Easing[] | undefined, duration: number): undefined | string | string[];\n\ndeclare const supportedWaapiEasing: {\n    linear: string;\n    ease: string;\n    easeIn: string;\n    easeOut: string;\n    easeInOut: string;\n    circIn: string;\n    circOut: string;\n    backIn: string;\n    backOut: string;\n};\n\ndeclare function startWaapiAnimation(element: Element, valueName: string, keyframes: ValueKeyframesDefinition, { delay, duration, repeat, repeatType, ease, times, }?: ValueTransition, pseudoElement?: string | undefined): Animation;\n\ndeclare const supportsPartialKeyframes: () => boolean;\n\ndeclare function supportsBrowserAnimation<T extends AnyResolvedKeyframe>(options: ValueAnimationOptionsWithRenderContext<T>): any;\n\n/**\n * A list of values that can be hardware-accelerated.\n */\ndeclare const acceleratedValues: Set<string>;\n\ndeclare function applyGeneratorOptions({ type, ...options }: ValueTransition): ValueTransition;\n\ndeclare const generateLinearEasing: (easing: EasingFunction, duration: number, resolution?: number) => string;\n\ndeclare class MotionValueState {\n    latest: {\n        [name: string]: AnyResolvedKeyframe;\n    };\n    private values;\n    set(name: string, value: MotionValue, render?: VoidFunction, computed?: MotionValue, useDefaultValueType?: boolean): () => void;\n    get(name: string): MotionValue | undefined;\n    destroy(): void;\n}\n\ndeclare const addAttrValue: (element: HTMLElement | SVGElement, state: MotionValueState, key: string, value: MotionValue) => () => void;\ndeclare const attrEffect: (subject: ElementOrSelector, values: Record<string, MotionValue<any>>) => () => void;\n\ndeclare const propEffect: (subject: {\n    [key: string]: any;\n}, values: Record<string, MotionValue<any>>) => VoidFunction;\n\ndeclare const addStyleValue: (element: HTMLElement | SVGElement, state: MotionValueState, key: string, value: MotionValue) => () => void;\ndeclare const styleEffect: (subject: ElementOrSelector, values: Record<string, MotionValue<any>>) => () => void;\n\ndeclare const svgEffect: (subject: ElementOrSelector, values: Record<string, MotionValue<any>>) => () => void;\n\ndeclare const frame: Batcher;\ndeclare const cancelFrame: (process: Process) => void;\ndeclare const frameData: FrameData;\ndeclare const frameSteps: Steps;\n\ntype Process = (data: FrameData) => void;\ntype Schedule = (process: Process, keepAlive?: boolean, immediate?: boolean) => Process;\ninterface Step {\n    schedule: Schedule;\n    cancel: (process: Process) => void;\n    process: (data: FrameData) => void;\n}\ntype StepId = \"setup\" | \"read\" | \"resolveKeyframes\" | \"preUpdate\" | \"update\" | \"preRender\" | \"render\" | \"postRender\";\ntype CancelProcess = (process: Process) => void;\ntype Batcher = {\n    [key in StepId]: Schedule;\n};\ntype Steps = {\n    [key in StepId]: Step;\n};\ninterface FrameData {\n    delta: number;\n    timestamp: number;\n    isProcessing: boolean;\n}\n\ndeclare function createRenderBatcher(scheduleNextBatch: (callback: Function) => void, allowKeepAlive: boolean): {\n    schedule: Batcher;\n    cancel: (process: Process) => void;\n    state: FrameData;\n    steps: Steps;\n};\n\ndeclare const microtask: Batcher;\ndeclare const cancelMicrotask: (process: Process) => void;\n\n/**\n * An eventloop-synchronous alternative to performance.now().\n *\n * Ensures that time measurements remain consistent within a synchronous context.\n * Usually calling performance.now() twice within the same synchronous context\n * will return different values which isn't useful for animations when we're usually\n * trying to sync animations to the same frame.\n */\ndeclare const time: {\n    now: () => number;\n    set: (newTime: number) => void;\n};\n\ndeclare const isDragging: {\n    x: boolean;\n    y: boolean;\n};\ndeclare function isDragActive(): boolean;\n\ndeclare function setDragLock(axis: boolean | \"x\" | \"y\" | \"lockDirection\"): (() => void) | null;\n\n/**\n * Passed in to pan event handlers like `onPan` the `PanInfo` object contains\n * information about the current state of the tap gesture such as its\n * `point`, `delta`, `offset` and `velocity`.\n *\n * ```jsx\n * <motion.div onPan={(event, info) => {\n *   console.log(info.point.x, info.point.y)\n * }} />\n * ```\n *\n * @public\n */\ninterface PanInfo {\n    /**\n     * Contains `x` and `y` values for the current pan position relative\n     * to the device or page.\n     *\n     * ```jsx\n     * function onPan(event, info) {\n     *   console.log(info.point.x, info.point.y)\n     * }\n     *\n     * <motion.div onPan={onPan} />\n     * ```\n     *\n     * @public\n     */\n    point: Point;\n    /**\n     * Contains `x` and `y` values for the distance moved since\n     * the last event.\n     *\n     * ```jsx\n     * function onPan(event, info) {\n     *   console.log(info.delta.x, info.delta.y)\n     * }\n     *\n     * <motion.div onPan={onPan} />\n     * ```\n     *\n     * @public\n     */\n    delta: Point;\n    /**\n     * Contains `x` and `y` values for the distance moved from\n     * the first pan event.\n     *\n     * ```jsx\n     * function onPan(event, info) {\n     *   console.log(info.offset.x, info.offset.y)\n     * }\n     *\n     * <motion.div onPan={onPan} />\n     * ```\n     *\n     * @public\n     */\n    offset: Point;\n    /**\n     * Contains `x` and `y` values for the current velocity of the pointer, in px/ms.\n     *\n     * ```jsx\n     * function onPan(event, info) {\n     *   console.log(info.velocity.x, info.velocity.y)\n     * }\n     *\n     * <motion.div onPan={onPan} />\n     * ```\n     *\n     * @public\n     */\n    velocity: Point;\n}\ntype PanHandler = (event: Event, info: PanInfo) => void;\n\ntype DragHandler = (event: MouseEvent | TouchEvent | PointerEvent, info: PanInfo) => void;\ntype DragElastic = boolean | number | Partial<BoundingBox>;\ninterface ResolvedConstraints {\n    x: Partial<Axis>;\n    y: Partial<Axis>;\n}\ninterface ResolvedElastic {\n    x: Axis;\n    y: Axis;\n}\n\ntype ElementOrSelector = Element | Element[] | NodeListOf<Element> | string;\ninterface WithQuerySelectorAll {\n    querySelectorAll: Element[\"querySelectorAll\"];\n}\ninterface AnimationScope<T = any> {\n    readonly current: T;\n    animations: any[];\n}\ninterface SelectorCache {\n    [key: string]: NodeListOf<Element>;\n}\ndeclare function resolveElements(elementOrSelector: ElementOrSelector, scope?: AnimationScope, selectorCache?: SelectorCache): Element[];\n\n/**\n * Options for event listeners.\n *\n * @public\n */\ninterface EventOptions {\n    /**\n     * Use passive event listeners. Doing so allows the browser to optimize\n     * scrolling performance by not allowing the use of `preventDefault()`.\n     *\n     * @default true\n     */\n    passive?: boolean;\n    /**\n     * Remove the event listener after the first event.\n     *\n     * @default false\n     */\n    once?: boolean;\n}\n\n/**\n * A function to be called when a hover gesture starts.\n *\n * This function can optionally return a function that will be called\n * when the hover gesture ends.\n *\n * @public\n */\ntype OnHoverStartEvent = (element: Element, event: PointerEvent) => void | OnHoverEndEvent;\n/**\n * A function to be called when a hover gesture ends.\n *\n * @public\n */\ntype OnHoverEndEvent = (event: PointerEvent) => void;\n/**\n * Create a hover gesture. hover() is different to .addEventListener(\"pointerenter\")\n * in that it has an easier syntax, filters out polyfilled touch events, interoperates\n * with drag gestures, and automatically removes the \"pointerennd\" event listener when the hover ends.\n *\n * @public\n */\ndeclare function hover(elementOrSelector: ElementOrSelector, onHoverStart: OnHoverStartEvent, options?: EventOptions): VoidFunction;\n\ninterface PressGestureInfo {\n    success: boolean;\n}\ntype OnPressEndEvent = (event: PointerEvent, info: PressGestureInfo) => void;\ntype OnPressStartEvent = (element: Element, event: PointerEvent) => OnPressEndEvent | void;\n\ninterface PointerEventOptions extends EventOptions {\n    useGlobalTarget?: boolean;\n}\n/**\n * Create a press gesture.\n *\n * Press is different to `\"pointerdown\"`, `\"pointerup\"` in that it\n * automatically filters out secondary pointer events like right\n * click and multitouch.\n *\n * It also adds accessibility support for keyboards, where\n * an element with a press gesture will receive focus and\n *  trigger on Enter `\"keydown\"` and `\"keyup\"` events.\n *\n * This is different to a browser's `\"click\"` event, which does\n * respond to keyboards but only for the `\"click\"` itself, rather\n * than the press start and end/cancel. The element also needs\n * to be focusable for this to work, whereas a press gesture will\n * make an element focusable by default.\n *\n * @public\n */\ndeclare function press(targetOrSelector: ElementOrSelector, onPressStart: OnPressStartEvent, options?: PointerEventOptions): VoidFunction;\n\n/**\n * Recursively traverse up the tree to check whether the provided child node\n * is the parent or a descendant of it.\n *\n * @param parent - Element to find\n * @param child - Element to test against parent\n */\ndeclare const isNodeOrChild: (parent: Element | null, child?: Element | null) => boolean;\n\ndeclare const isPrimaryPointer: (event: PointerEvent) => boolean;\n\ninterface EventInfo {\n    point: Point;\n}\n/**\n * A generic set of string/number values\n */\ninterface ResolvedValues {\n    [key: string]: AnyResolvedKeyframe;\n}\ntype AnimationDefinition = VariantLabels | TargetAndTransition | TargetResolver;\n/**\n * An object that specifies values to animate to. Each value may be set either as\n * a single value, or an array of values.\n *\n * It may also option contain these properties:\n *\n * - `transition`: Specifies transitions for all or individual values.\n * - `transitionEnd`: Specifies values to set when the animation finishes.\n *\n * ```jsx\n * const target = {\n *   x: \"0%\",\n *   opacity: 0,\n *   transition: { duration: 1 },\n *   transitionEnd: { display: \"none\" }\n * }\n * ```\n *\n * @public\n */\ntype TargetAndTransition = Target & {\n    transition?: Transition;\n    transitionEnd?: ResolvedValues;\n};\ntype TargetResolver = (custom: any, current: ResolvedValues, velocity: ResolvedValues) => TargetAndTransition | string;\n/**\n * Either a string, or array of strings, that reference variants defined via the `variants` prop.\n * @public\n */\ntype VariantLabels = string | string[];\ntype Variant = TargetAndTransition | TargetResolver;\ninterface Variants {\n    [key: string]: Variant;\n}\n/**\n * @deprecated\n */\ntype LegacyAnimationControls = {\n    /**\n     * Subscribes a component's animation controls to this.\n     *\n     * @param controls - The controls to subscribe\n     * @returns An unsubscribe function.\n     */\n    subscribe(visualElement: any): () => void;\n    /**\n     * Starts an animation on all linked components.\n     *\n     * @remarks\n     *\n     * ```jsx\n     * controls.start(\"variantLabel\")\n     * controls.start({\n     *   x: 0,\n     *   transition: { duration: 1 }\n     * })\n     * ```\n     *\n     * @param definition - Properties or variant label to animate to\n     * @param transition - Optional `transition` to apply to a variant\n     * @returns - A `Promise` that resolves when all animations have completed.\n     *\n     * @public\n     */\n    start(definition: AnimationDefinition, transitionOverride?: Transition): Promise<any>;\n    /**\n     * Instantly set to a set of properties or a variant.\n     *\n     * ```jsx\n     * // With properties\n     * controls.set({ opacity: 0 })\n     *\n     * // With variants\n     * controls.set(\"hidden\")\n     * ```\n     *\n     * @privateRemarks\n     * We could perform a similar trick to `.start` where this can be called before mount\n     * and we maintain a list of of pending actions that get applied on mount. But the\n     * expectation of `set` is that it happens synchronously and this would be difficult\n     * to do before any children have even attached themselves. It's also poor practise\n     * and we should discourage render-synchronous `.start` calls rather than lean into this.\n     *\n     * @public\n     */\n    set(definition: AnimationDefinition): void;\n    /**\n     * Stops animations on all linked components.\n     *\n     * ```jsx\n     * controls.stop()\n     * ```\n     *\n     * @public\n     */\n    stop(): void;\n    mount(): () => void;\n};\ninterface MotionNodeAnimationOptions {\n    /**\n     * Properties, variant label or array of variant labels to start in.\n     *\n     * Set to `false` to initialise with the values in `animate` (disabling the mount animation)\n     *\n     * ```jsx\n     * // As values\n     * <motion.div initial={{ opacity: 1 }} />\n     *\n     * // As variant\n     * <motion.div initial=\"visible\" variants={variants} />\n     *\n     * // Multiple variants\n     * <motion.div initial={[\"visible\", \"active\"]} variants={variants} />\n     *\n     * // As false (disable mount animation)\n     * <motion.div initial={false} animate={{ opacity: 0 }} />\n     * ```\n     */\n    initial?: TargetAndTransition | VariantLabels | boolean;\n    /**\n     * Values to animate to, variant label(s), or `LegacyAnimationControls`.\n     *\n     * ```jsx\n     * // As values\n     * <motion.div animate={{ opacity: 1 }} />\n     *\n     * // As variant\n     * <motion.div animate=\"visible\" variants={variants} />\n     *\n     * // Multiple variants\n     * <motion.div animate={[\"visible\", \"active\"]} variants={variants} />\n     *\n     * // LegacyAnimationControls\n     * <motion.div animate={animation} />\n     * ```\n     */\n    animate?: TargetAndTransition | VariantLabels | boolean | LegacyAnimationControls;\n    /**\n     * A target to animate to when this component is removed from the tree.\n     *\n     * This component **must** be the first animatable child of an `AnimatePresence` to enable this exit animation.\n     *\n     * This limitation exists because React doesn't allow components to defer unmounting until after\n     * an animation is complete. Once this limitation is fixed, the `AnimatePresence` component will be unnecessary.\n     *\n     * ```jsx\n     * import { AnimatePresence, motion } from 'framer-motion'\n     *\n     * export const MyComponent = ({ isVisible }) => {\n     *   return (\n     *     <AnimatePresence>\n     *        {isVisible && (\n     *          <motion.div\n     *            initial={{ opacity: 0 }}\n     *            animate={{ opacity: 1 }}\n     *            exit={{ opacity: 0 }}\n     *          />\n     *        )}\n     *     </AnimatePresence>\n     *   )\n     * }\n     * ```\n     */\n    exit?: TargetAndTransition | VariantLabels;\n    /**\n     * Variants allow you to define animation states and organise them by name. They allow\n     * you to control animations throughout a component tree by switching a single `animate` prop.\n     *\n     * Using `transition` options like `delayChildren` and `when`, you can orchestrate\n     * when children animations play relative to their parent.\n\n     *\n     * After passing variants to one or more `motion` component's `variants` prop, these variants\n     * can be used in place of values on the `animate`, `initial`, `whileFocus`, `whileTap` and `whileHover` props.\n     *\n     * ```jsx\n     * const variants = {\n     *   active: {\n     *       backgroundColor: \"#f00\"\n     *   },\n     *   inactive: {\n     *     backgroundColor: \"#fff\",\n     *     transition: { duration: 2 }\n     *   }\n     * }\n     *\n     * <motion.div variants={variants} animate=\"active\" />\n     * ```\n     */\n    variants?: Variants;\n    /**\n     * Default transition. If no `transition` is defined in `animate`, it will use the transition defined here.\n     * ```jsx\n     * const spring = {\n     *   type: \"spring\",\n     *   damping: 10,\n     *   stiffness: 100\n     * }\n     *\n     * <motion.div transition={spring} animate={{ scale: 1.2 }} />\n     * ```\n     */\n    transition?: Transition;\n}\ninterface MotionNodeEventOptions {\n    /**\n     * Callback with latest motion values, fired max once per frame.\n     *\n     * ```jsx\n     * function onUpdate(latest) {\n     *   console.log(latest.x, latest.opacity)\n     * }\n     *\n     * <motion.div animate={{ x: 100, opacity: 0 }} onUpdate={onUpdate} />\n     * ```\n     */\n    onUpdate?(latest: ResolvedValues): void;\n    /**\n     * Callback when animation defined in `animate` begins.\n     *\n     * The provided callback will be called with the triggering animation definition.\n     * If this is a variant, it'll be the variant name, and if a target object\n     * then it'll be the target object.\n     *\n     * This way, it's possible to figure out which animation has started.\n     *\n     * ```jsx\n     * function onStart() {\n     *   console.log(\"Animation started\")\n     * }\n     *\n     * <motion.div animate={{ x: 100 }} onAnimationStart={onStart} />\n     * ```\n     */\n    onAnimationStart?(definition: AnimationDefinition): void;\n    /**\n     * Callback when animation defined in `animate` is complete.\n     *\n     * The provided callback will be called with the triggering animation definition.\n     * If this is a variant, it'll be the variant name, and if a target object\n     * then it'll be the target object.\n     *\n     * This way, it's possible to figure out which animation has completed.\n     *\n     * ```jsx\n     * function onComplete() {\n     *   console.log(\"Animation completed\")\n     * }\n     *\n     * <motion.div\n     *   animate={{ x: 100 }}\n     *   onAnimationComplete={definition => {\n     *     console.log('Completed animating', definition)\n     *   }}\n     * />\n     * ```\n     */\n    onAnimationComplete?(definition: AnimationDefinition): void;\n    onBeforeLayoutMeasure?(box: Box): void;\n    onLayoutMeasure?(box: Box, prevBox: Box): void;\n    onLayoutAnimationStart?(): void;\n    onLayoutAnimationComplete?(): void;\n}\ninterface MotionNodePanHandlers {\n    /**\n     * Callback function that fires when the pan gesture is recognised on this element.\n     *\n     * **Note:** For pan gestures to work correctly with touch input, the element needs\n     * touch scrolling to be disabled on either x/y or both axis with the\n     * [touch-action](https://developer.mozilla.org/en-US/docs/Web/CSS/touch-action) CSS rule.\n     *\n     * ```jsx\n     * function onPan(event, info) {\n     *   console.log(info.point.x, info.point.y)\n     * }\n     *\n     * <motion.div onPan={onPan} />\n     * ```\n     *\n     * @param event - The originating pointer event.\n     * @param info - A {@link PanInfo} object containing `x` and `y` values for:\n     *\n     *   - `point`: Relative to the device or page.\n     *   - `delta`: Distance moved since the last event.\n     *   - `offset`: Offset from the original pan event.\n     *   - `velocity`: Current velocity of the pointer.\n     */\n    onPan?(event: PointerEvent, info: PanInfo): void;\n    /**\n     * Callback function that fires when the pan gesture begins on this element.\n     *\n     * ```jsx\n     * function onPanStart(event, info) {\n     *   console.log(info.point.x, info.point.y)\n     * }\n     *\n     * <motion.div onPanStart={onPanStart} />\n     * ```\n     *\n     * @param event - The originating pointer event.\n     * @param info - A {@link PanInfo} object containing `x`/`y` values for:\n     *\n     *   - `point`: Relative to the device or page.\n     *   - `delta`: Distance moved since the last event.\n     *   - `offset`: Offset from the original pan event.\n     *   - `velocity`: Current velocity of the pointer.\n     */\n    onPanStart?(event: PointerEvent, info: PanInfo): void;\n    /**\n     * Callback function that fires when we begin detecting a pan gesture. This\n     * is analogous to `onMouseStart` or `onTouchStart`.\n     *\n     * ```jsx\n     * function onPanSessionStart(event, info) {\n     *   console.log(info.point.x, info.point.y)\n     * }\n     *\n     * <motion.div onPanSessionStart={onPanSessionStart} />\n     * ```\n     *\n     * @param event - The originating pointer event.\n     * @param info - An {@link EventInfo} object containing `x`/`y` values for:\n     *\n     *   - `point`: Relative to the device or page.\n     */\n    onPanSessionStart?(event: PointerEvent, info: EventInfo): void;\n    /**\n     * Callback function that fires when the pan gesture ends on this element.\n     *\n     * ```jsx\n     * function onPanEnd(event, info) {\n     *   console.log(info.point.x, info.point.y)\n     * }\n     *\n     * <motion.div onPanEnd={onPanEnd} />\n     * ```\n     *\n     * @param event - The originating pointer event.\n     * @param info - A {@link PanInfo} object containing `x`/`y` values for:\n     *\n     *   - `point`: Relative to the device or page.\n     *   - `delta`: Distance moved since the last event.\n     *   - `offset`: Offset from the original pan event.\n     *   - `velocity`: Current velocity of the pointer.\n     */\n    onPanEnd?(event: PointerEvent, info: PanInfo): void;\n}\ninterface MotionNodeHoverHandlers {\n    /**\n     * Properties or variant label to animate to while the hover gesture is recognised.\n     *\n     * ```jsx\n     * <motion.div whileHover={{ scale: 1.2 }} />\n     * ```\n     */\n    whileHover?: VariantLabels | TargetAndTransition;\n    /**\n     * Callback function that fires when pointer starts hovering over the component.\n     *\n     * ```jsx\n     * <motion.div onHoverStart={() => console.log('Hover starts')} />\n     * ```\n     */\n    onHoverStart?(event: MouseEvent, info: EventInfo): void;\n    /**\n     * Callback function that fires when pointer stops hovering over the component.\n     *\n     * ```jsx\n     * <motion.div onHoverEnd={() => console.log(\"Hover ends\")} />\n     * ```\n     */\n    onHoverEnd?(event: MouseEvent, info: EventInfo): void;\n}\n/**\n * Passed in to tap event handlers like `onTap` the `TapInfo` object contains\n * information about the tap gesture such as it‘s location.\n *\n * ```jsx\n * function onTap(event, info) {\n *   console.log(info.point.x, info.point.y)\n * }\n *\n * <motion.div onTap={onTap} />\n * ```\n *\n * @public\n */\ninterface TapInfo {\n    /**\n     * Contains `x` and `y` values for the tap gesture relative to the\n     * device or page.\n     *\n     * ```jsx\n     * function onTapStart(event, info) {\n     *   console.log(info.point.x, info.point.y)\n     * }\n     *\n     * <motion.div onTapStart={onTapStart} />\n     * ```\n     *\n     * @public\n     */\n    point: Point;\n}\ninterface MotionNodeTapHandlers {\n    /**\n     * Callback when the tap gesture successfully ends on this element.\n     *\n     * ```jsx\n     * function onTap(event, info) {\n     *   console.log(info.point.x, info.point.y)\n     * }\n     *\n     * <motion.div onTap={onTap} />\n     * ```\n     *\n     * @param event - The originating pointer event.\n     * @param info - An {@link TapInfo} object containing `x` and `y` values for the `point` relative to the device or page.\n     */\n    onTap?(event: MouseEvent | TouchEvent | PointerEvent, info: TapInfo): void;\n    /**\n     * Callback when the tap gesture starts on this element.\n     *\n     * ```jsx\n     * function onTapStart(event, info) {\n     *   console.log(info.point.x, info.point.y)\n     * }\n     *\n     * <motion.div onTapStart={onTapStart} />\n     * ```\n     *\n     * @param event - The originating pointer event.\n     * @param info - An {@link TapInfo} object containing `x` and `y` values for the `point` relative to the device or page.\n     */\n    onTapStart?(event: MouseEvent | TouchEvent | PointerEvent, info: TapInfo): void;\n    /**\n     * Callback when the tap gesture ends outside this element.\n     *\n     * ```jsx\n     * function onTapCancel(event, info) {\n     *   console.log(info.point.x, info.point.y)\n     * }\n     *\n     * <motion.div onTapCancel={onTapCancel} />\n     * ```\n     *\n     * @param event - The originating pointer event.\n     * @param info - An {@link TapInfo} object containing `x` and `y` values for the `point` relative to the device or page.\n     */\n    onTapCancel?(event: MouseEvent | TouchEvent | PointerEvent, info: TapInfo): void;\n    /**\n     * Properties or variant label to animate to while the component is pressed.\n     *\n     * ```jsx\n     * <motion.div whileTap={{ scale: 0.8 }} />\n     * ```\n     */\n    whileTap?: VariantLabels | TargetAndTransition;\n    /**\n     * If `true`, the tap gesture will attach its start listener to window.\n     *\n     * Note: This is not supported publically.\n     */\n    globalTapTarget?: boolean;\n}\n/**\n * @deprecated - Use MotionNodeTapHandlers\n */\ninterface TapHandlers extends MotionNodeTapHandlers {\n}\ninterface MotionNodeFocusHandlers {\n    /**\n     * Properties or variant label to animate to while the focus gesture is recognised.\n     *\n     * ```jsx\n     * <motion.input whileFocus={{ scale: 1.2 }} />\n     * ```\n     */\n    whileFocus?: VariantLabels | TargetAndTransition;\n}\n/**\n * TODO: Replace with types from inView()\n */\ntype ViewportEventHandler = (entry: IntersectionObserverEntry | null) => void;\ninterface ViewportOptions {\n    root?: {\n        current: Element | null;\n    };\n    once?: boolean;\n    margin?: string;\n    amount?: \"some\" | \"all\" | number;\n}\ninterface MotionNodeViewportOptions {\n    whileInView?: VariantLabels | TargetAndTransition;\n    onViewportEnter?: ViewportEventHandler;\n    onViewportLeave?: ViewportEventHandler;\n    viewport?: ViewportOptions;\n}\ninterface MotionNodeDraggableOptions {\n    /**\n     * Enable dragging for this element. Set to `false` by default.\n     * Set `true` to drag in both directions.\n     * Set `\"x\"` or `\"y\"` to only drag in a specific direction.\n     *\n     * ```jsx\n     * <motion.div drag=\"x\" />\n     * ```\n     */\n    drag?: boolean | \"x\" | \"y\";\n    /**\n     * Properties or variant label to animate to while the drag gesture is recognised.\n     *\n     * ```jsx\n     * <motion.div whileDrag={{ scale: 1.2 }} />\n     * ```\n     */\n    whileDrag?: VariantLabels | TargetAndTransition;\n    /**\n     * If `true`, this will lock dragging to the initially-detected direction. Defaults to `false`.\n     *\n     * ```jsx\n     * <motion.div drag dragDirectionLock />\n     * ```\n     */\n    dragDirectionLock?: boolean;\n    /**\n     * Allows drag gesture propagation to child components. Set to `false` by\n     * default.\n     *\n     * ```jsx\n     * <motion.div drag=\"x\" dragPropagation />\n     * ```\n     */\n    dragPropagation?: boolean;\n    /**\n     * Applies constraints on the permitted draggable area.\n     *\n     * It can accept an object of optional `top`, `left`, `right`, and `bottom` values, measured in pixels.\n     * This will define a distance from the named edge of the draggable component.\n     *\n     * Alternatively, it can accept a `ref` to another component created with React's `useRef` hook.\n     * This `ref` should be passed both to the draggable component's `dragConstraints` prop, and the `ref`\n     * of the component you want to use as constraints.\n     *\n     * ```jsx\n     * // In pixels\n     * <motion.div\n     *   drag=\"x\"\n     *   dragConstraints={{ left: 0, right: 300 }}\n     * />\n     *\n     * // As a ref to another component\n     * const MyComponent = () => {\n     *   const constraintsRef = useRef(null)\n     *\n     *   return (\n     *      <motion.div ref={constraintsRef}>\n     *          <motion.div drag dragConstraints={constraintsRef} />\n     *      </motion.div>\n     *   )\n     * }\n     * ```\n     */\n    dragConstraints?: false | Partial<BoundingBox> | {\n        current: Element | null;\n    };\n    /**\n     * The degree of movement allowed outside constraints. 0 = no movement, 1 =\n     * full movement.\n     *\n     * Set to `0.5` by default. Can also be set as `false` to disable movement.\n     *\n     * By passing an object of `top`/`right`/`bottom`/`left`, individual values can be set\n     * per constraint. Any missing values will be set to `0`.\n     *\n     * ```jsx\n     * <motion.div\n     *   drag\n     *   dragConstraints={{ left: 0, right: 300 }}\n     *   dragElastic={0.2}\n     * />\n     * ```\n     */\n    dragElastic?: DragElastic;\n    /**\n     * Apply momentum from the pan gesture to the component when dragging\n     * finishes. Set to `true` by default.\n     *\n     * ```jsx\n     * <motion.div\n     *   drag\n     *   dragConstraints={{ left: 0, right: 300 }}\n     *   dragMomentum={false}\n     * />\n     * ```\n     */\n    dragMomentum?: boolean;\n    /**\n     * Allows you to change dragging inertia parameters.\n     * 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.\n     * See {@link https://motion.dev/docs/react-motion-component#dragtransition | Inertia} for all properties you can use.\n     *\n     * ```jsx\n     * <motion.div\n     *   drag\n     *   dragTransition={{ bounceStiffness: 600, bounceDamping: 10 }}\n     * />\n     * ```\n     */\n    dragTransition?: InertiaOptions;\n    /**\n     * Usually, dragging is initiated by pressing down on a component and moving it. For some\n     * use-cases, for instance clicking at an arbitrary point on a video scrubber, we\n     * might want to initiate dragging from a different component than the draggable one.\n     *\n     * By creating a `dragControls` using the `useDragControls` hook, we can pass this into\n     * the draggable component's `dragControls` prop. It exposes a `start` method\n     * that can start dragging from pointer events on other components.\n     *\n     * ```jsx\n     * const dragControls = useDragControls()\n     *\n     * function startDrag(event) {\n     *   dragControls.start(event, { snapToCursor: true })\n     * }\n     *\n     * return (\n     *   <>\n     *     <div onPointerDown={startDrag} />\n     *     <motion.div drag=\"x\" dragControls={dragControls} />\n     *   </>\n     * )\n     * ```\n     */\n    dragControls?: any;\n    /**\n     * If true, element will snap back to its origin when dragging ends.\n     *\n     * Enabling this is the equivalent of setting all `dragConstraints` axes to `0`\n     * with `dragElastic={1}`, but when used together `dragConstraints` can define\n     * a wider draggable area and `dragSnapToOrigin` will ensure the element\n     * animates back to its origin on release.\n     */\n    dragSnapToOrigin?: boolean;\n    /**\n     * By default, if `drag` is defined on a component then an event listener will be attached\n     * to automatically initiate dragging when a user presses down on it.\n     *\n     * By setting `dragListener` to `false`, this event listener will not be created.\n     *\n     * ```jsx\n     * const dragControls = useDragControls()\n     *\n     * function startDrag(event) {\n     *   dragControls.start(event, { snapToCursor: true })\n     * }\n     *\n     * return (\n     *   <>\n     *     <div onPointerDown={startDrag} />\n     *     <motion.div\n     *       drag=\"x\"\n     *       dragControls={dragControls}\n     *       dragListener={false}\n     *     />\n     *   </>\n     * )\n     * ```\n     */\n    dragListener?: boolean;\n    /**\n     * If `dragConstraints` is set to a React ref, this callback will call with the measured drag constraints.\n     *\n     * @public\n     */\n    onMeasureDragConstraints?: (constraints: BoundingBox) => BoundingBox | void;\n    /**\n     * Usually, dragging uses the layout project engine, and applies transforms to the underlying VisualElement.\n     * Passing MotionValues as _dragX and _dragY instead applies drag updates to these motion values.\n     * This allows you to manually control how updates from a drag gesture on an element is applied.\n     *\n     * @public\n     */\n    _dragX?: MotionValue<number>;\n    /**\n     * Usually, dragging uses the layout project engine, and applies transforms to the underlying VisualElement.\n     * Passing MotionValues as _dragX and _dragY instead applies drag updates to these motion values.\n     * This allows you to manually control how updates from a drag gesture on an element is applied.\n     *\n     * @public\n     */\n    _dragY?: MotionValue<number>;\n}\ninterface MotionNodeDragHandlers {\n    /**\n     * Callback function that fires when dragging starts.\n     *\n     * ```jsx\n     * <motion.div\n     *   drag\n     *   onDragStart={\n     *     (event, info) => console.log(info.point.x, info.point.y)\n     *   }\n     * />\n     * ```\n     *\n     * @public\n     */\n    onDragStart?(event: MouseEvent | TouchEvent | PointerEvent, info: PanInfo): void;\n    /**\n     * Callback function that fires when dragging ends.\n     *\n     * ```jsx\n     * <motion.div\n     *   drag\n     *   onDragEnd={\n     *     (event, info) => console.log(info.point.x, info.point.y)\n     *   }\n     * />\n     * ```\n     *\n     * @public\n     */\n    onDragEnd?(event: MouseEvent | TouchEvent | PointerEvent, info: PanInfo): void;\n    /**\n     * Callback function that fires when the component is dragged.\n     *\n     * ```jsx\n     * <motion.div\n     *   drag\n     *   onDrag={\n     *     (event, info) => console.log(info.point.x, info.point.y)\n     *   }\n     * />\n     * ```\n     *\n     * @public\n     */\n    onDrag?(event: MouseEvent | TouchEvent | PointerEvent, info: PanInfo): void;\n    /**\n     * Callback function that fires a drag direction is determined.\n     *\n     * ```jsx\n     * <motion.div\n     *   drag\n     *   dragDirectionLock\n     *   onDirectionLock={axis => console.log(axis)}\n     * />\n     * ```\n     *\n     * @public\n     */\n    onDirectionLock?(axis: \"x\" | \"y\"): void;\n    /**\n     * Callback function that fires when drag momentum/bounce transition finishes.\n     *\n     * ```jsx\n     * <motion.div\n     *   drag\n     *   onDragTransitionEnd={() => console.log('Drag transition complete')}\n     * />\n     * ```\n     *\n     * @public\n     */\n    onDragTransitionEnd?(): void;\n}\ninterface MotionNodeLayoutOptions {\n    /**\n     * If `true`, this component will automatically animate to its new position when\n     * its layout changes.\n     *\n     * ```jsx\n     * <motion.div layout />\n     * ```\n     *\n     * This will perform a layout animation using performant transforms. Part of this technique\n     * involved animating an element's scale. This can introduce visual distortions on children,\n     * `boxShadow` and `borderRadius`.\n     *\n     * To correct distortion on immediate children, add `layout` to those too.\n     *\n     * `boxShadow` and `borderRadius` will automatically be corrected if they are already being\n     * animated on this component. Otherwise, set them directly via the `initial` prop.\n     *\n     * If `layout` is set to `\"position\"`, the size of the component will change instantly and\n     * only its position will animate.\n     *\n     * If `layout` is set to `\"size\"`, the position of the component will change instantly and\n     * only its size will animate.\n     *\n     * If `layout` is set to `\"preserve-aspect\"`, the component will animate size & position if\n     * the aspect ratio remains the same between renders, and just position if the ratio changes.\n     *\n     * @public\n     */\n    layout?: boolean | \"position\" | \"size\" | \"preserve-aspect\";\n    /**\n     * Enable shared layout transitions between different components with the same `layoutId`.\n     *\n     * When a component with a layoutId is removed from the React tree, and then\n     * added elsewhere, it will visually animate from the previous component's bounding box\n     * and its latest animated values.\n     *\n     * ```jsx\n     *   {items.map(item => (\n     *      <motion.li layout>\n     *         {item.name}\n     *         {item.isSelected && <motion.div layoutId=\"underline\" />}\n     *      </motion.li>\n     *   ))}\n     * ```\n     *\n     * If the previous component remains in the tree it will crossfade with the new component.\n     *\n     * @public\n     */\n    layoutId?: string;\n    /**\n     * A callback that will fire when a layout animation on this component starts.\n     *\n     * @public\n     */\n    onLayoutAnimationStart?(): void;\n    /**\n     * A callback that will fire when a layout animation on this component completes.\n     *\n     * @public\n     */\n    onLayoutAnimationComplete?(): void;\n    /**\n     * @public\n     */\n    layoutDependency?: any;\n    /**\n     * Whether a projection node should measure its scroll when it or its descendants update their layout.\n     *\n     * @public\n     */\n    layoutScroll?: boolean;\n    /**\n     * Whether an element should be considered a \"layout root\", where\n     * all children will be forced to resolve relatively to it.\n     * Currently used for `position: sticky` elements in Framer.\n     */\n    layoutRoot?: boolean;\n    /**\n     * Attached to a portal root to ensure we attach the child to the document root and don't\n     * perform scale correction on it.\n     */\n    \"data-framer-portal-id\"?: string;\n    /**\n     * By default, shared layout elements will crossfade. By setting this\n     * to `false`, this element will take its default opacity throughout the animation.\n     */\n    layoutCrossfade?: boolean;\n}\n/**\n * @deprecated - Use MotionNodeDragHandlers/MotionNodeDraggableOptions\n */\ninterface DraggableProps extends MotionNodeDragHandlers, MotionNodeDraggableOptions {\n}\ntype TransformTemplate = (transform: TransformProperties, generatedTransform: string) => string;\ninterface MotionNodeAdvancedOptions {\n    /**\n     * Custom data to use to resolve dynamic variants differently for each animating component.\n     *\n     * ```jsx\n     * const variants = {\n     *   visible: (custom) => ({\n     *     opacity: 1,\n     *     transition: { delay: custom * 0.2 }\n     *   })\n     * }\n     *\n     * <motion.div custom={0} animate=\"visible\" variants={variants} />\n     * <motion.div custom={1} animate=\"visible\" variants={variants} />\n     * <motion.div custom={2} animate=\"visible\" variants={variants} />\n     * ```\n     *\n     * @public\n     */\n    custom?: any;\n    /**\n     * @public\n     * Set to `false` to prevent inheriting variant changes from its parent.\n     */\n    inherit?: boolean;\n    /**\n     * @public\n     * Set to `false` to prevent throwing an error when a `motion` component is used within a `LazyMotion` set to strict.\n     */\n    ignoreStrict?: boolean;\n    /**\n     * Provide a set of motion values to perform animations on.\n     */\n    values?: {\n        [key: string]: MotionValue<number> | MotionValue<string>;\n    };\n    /**\n     * By default, Motion generates a `transform` property with a sensible transform order. `transformTemplate`\n     * can be used to create a different order, or to append/preprend the automatically generated `transform` property.\n     *\n     * ```jsx\n     * <motion.div\n     *   style={{ x: 0, rotate: 180 }}\n     *   transformTemplate={\n     *     ({ x, rotate }) => `rotate(${rotate}deg) translateX(${x}px)`\n     *   }\n     * />\n     * ```\n     *\n     * @param transform - The latest animated transform props.\n     * @param generatedTransform - The transform string as automatically generated by Motion\n     *\n     * @public\n     */\n    transformTemplate?: TransformTemplate;\n    \"data-framer-appear-id\"?: string;\n}\ninterface MotionNodeOptions extends MotionNodeAnimationOptions, MotionNodeEventOptions, MotionNodePanHandlers, MotionNodeTapHandlers, MotionNodeHoverHandlers, MotionNodeFocusHandlers, MotionNodeViewportOptions, MotionNodeDragHandlers, MotionNodeDraggableOptions, MotionNodeLayoutOptions, MotionNodeAdvancedOptions {\n}\n\ndeclare function defaultTransformValue(name: string): number;\ndeclare function parseValueFromTransform(transform: string | undefined, name: string): number;\ndeclare const readTransformValue: (instance: HTMLElement, name: string) => number;\n\ndeclare function getComputedStyle(element: HTMLElement | SVGElement, name: string): string;\n\ndeclare function setStyle(element: HTMLElement | SVGElement, name: string, value: AnyResolvedKeyframe): void;\n\ndeclare const positionalKeys: Set<string>;\n\n/**\n * Generate a list of every possible transform key.\n */\ndeclare const transformPropOrder: string[];\n/**\n * A quick lookup for transform props.\n */\ndeclare const transformProps: Set<string>;\n\ninterface ResizeInfo {\n    width: number;\n    height: number;\n}\ntype ResizeHandler<I> = (element: I, info: ResizeInfo) => void;\ntype WindowResizeHandler = (info: ResizeInfo) => void;\n\ndeclare function resize(onResize: WindowResizeHandler): VoidFunction;\ndeclare function resize(target: ElementOrSelector, onResize: ResizeHandler<Element>): VoidFunction;\n\ntype Update = (progress: number) => void;\ndeclare function observeTimeline(update: Update, timeline: ProgressTimeline): () => void;\n\ndeclare const stepsOrder: StepId[];\ntype StepNames = (typeof stepsOrder)[number];\n\ninterface Summary {\n    min: number;\n    max: number;\n    avg: number;\n}\ntype FrameloopStatNames = \"rate\" | StepNames;\ninterface Stats<T> {\n    frameloop: {\n        [key in FrameloopStatNames]: T;\n    };\n    animations: {\n        mainThread: T;\n        waapi: T;\n        layout: T;\n    };\n    layoutProjection: {\n        nodes: T;\n        calculatedTargetDeltas: T;\n        calculatedProjections: T;\n    };\n}\ntype StatsBuffer = number[];\ntype FrameStats = Stats<number>;\ntype StatsRecording = Stats<StatsBuffer>;\ntype StatsSummary = Stats<Summary>;\n\ndeclare function reportStats(): StatsSummary;\ndeclare function recordStats(): typeof reportStats;\n\ndeclare const activeAnimations: {\n    layout: number;\n    mainThread: number;\n    waapi: number;\n};\n\ntype InactiveStatsBuffer = {\n    value: null;\n    addProjectionMetrics: null;\n};\ntype ActiveStatsBuffer = {\n    value: StatsRecording;\n    addProjectionMetrics: (metrics: {\n        nodes: number;\n        calculatedTargetDeltas: number;\n        calculatedProjections: number;\n    }) => void;\n};\ndeclare const statsBuffer: InactiveStatsBuffer | ActiveStatsBuffer;\n\ntype Mixer<T> = (p: number) => T;\ntype MixerFactory<T> = (a: T, b: T) => Mixer<T>;\n\ninterface InterpolateOptions<T> {\n    clamp?: boolean;\n    ease?: EasingFunction | EasingFunction[];\n    mixer?: MixerFactory<T>;\n}\n/**\n * Create a function that maps from a numerical input array to a generic output array.\n *\n * Accepts:\n *   - Numbers\n *   - Colors (hex, hsl, hsla, rgb, rgba)\n *   - Complex (combinations of one or more numbers or strings)\n *\n * ```jsx\n * const mixColor = interpolate([0, 1], ['#fff', '#000'])\n *\n * mixColor(0.5) // 'rgba(128, 128, 128, 1)'\n * ```\n *\n * TODO Revisit this approach once we've moved to data models for values,\n * probably not needed to pregenerate mixer functions.\n *\n * @public\n */\ndeclare function interpolate<T>(input: number[], output: T[], { clamp: isClamp, ease, mixer }?: InterpolateOptions<T>): (v: number) => T;\n\n/**\n * Checks if an element is an HTML element in a way\n * that works across iframes\n */\ndeclare function isHTMLElement(element: unknown): element is HTMLElement;\n\n/**\n * Checks if an element is an SVG element in a way\n * that works across iframes\n */\ndeclare function isSVGElement(element: unknown): element is SVGElement;\n\n/**\n * Checks if an element is specifically an SVGSVGElement (the root SVG element)\n * in a way that works across iframes\n */\ndeclare function isSVGSVGElement(element: unknown): element is SVGSVGElement;\n\ndeclare function mix<T>(from: T, to: T): Mixer<T>;\ndeclare function mix(from: number, to: number, p: number): number;\n\ntype Transformer = (v: any) => any;\ntype ValueType = {\n    test: (v: any) => boolean;\n    parse: (v: any) => any;\n    transform?: Transformer;\n    createTransformer?: (template: string) => Transformer;\n    default?: any;\n    getAnimatableNone?: (v: any) => any;\n};\ntype NumberMap = {\n    [key: string]: number;\n};\ntype RGBA = {\n    red: number;\n    green: number;\n    blue: number;\n    alpha: number;\n};\ntype HSLA = {\n    hue: number;\n    saturation: number;\n    lightness: number;\n    alpha: number;\n};\ntype Color = HSLA | RGBA;\n\ndeclare const mixLinearColor: (from: number, to: number, v: number) => number;\ndeclare const mixColor: (from: Color | string, to: Color | string) => (p: number) => string | Color;\n\ntype MixableArray = Array<number | RGBA | HSLA | string>;\ninterface MixableObject {\n    [key: string]: AnyResolvedKeyframe | RGBA | HSLA;\n}\ndeclare function getMixer<T>(a: T): ((from: string | Color, to: string | Color) => (p: number) => string | Color) | ((origin: AnyResolvedKeyframe, target: AnyResolvedKeyframe) => Function) | typeof mixArray | typeof mixObject;\ndeclare function mixArray(a: MixableArray, b: MixableArray): (p: number) => (string | number | RGBA | HSLA)[];\ndeclare function mixObject(a: MixableObject, b: MixableObject): (v: number) => {\n    [x: string]: AnyResolvedKeyframe | RGBA | HSLA;\n};\ndeclare const mixComplex: (origin: AnyResolvedKeyframe, target: AnyResolvedKeyframe) => Function;\n\ndeclare function mixImmediate<T>(a: T, b: T): (p: number) => T;\n\ndeclare const mixNumber: (from: number, to: number, progress: number) => number;\n\ndeclare const invisibleValues: Set<string>;\n/**\n * Returns a function that, when provided a progress value between 0 and 1,\n * will return the \"none\" or \"hidden\" string only when the progress is that of\n * the origin or target.\n */\ndeclare function mixVisibility(origin: string, target: string): (p: number) => string;\n\ntype StaggerOrigin = \"first\" | \"last\" | \"center\" | number;\ntype StaggerOptions = {\n    startDelay?: number;\n    from?: StaggerOrigin;\n    ease?: Easing;\n};\ndeclare function getOriginIndex(from: StaggerOrigin, total: number): number;\ndeclare function stagger(duration?: number, { startDelay, from, ease }?: StaggerOptions): DynamicOption<number>;\n\n/**\n * Add the ability for test suites to manually set support flags\n * to better test more environments.\n */\ndeclare const supportsFlags: Record<string, boolean | undefined>;\n\ndeclare const supportsLinearEasing: () => boolean;\n\ndeclare global {\n    interface Window {\n        ScrollTimeline: ScrollTimeline;\n    }\n}\ndeclare class ScrollTimeline implements ProgressTimeline {\n    constructor(options: ScrollOptions);\n    currentTime: null | {\n        value: number;\n    };\n    cancel?: VoidFunction;\n}\ndeclare const supportsScrollTimeline: () => boolean;\n\n/**\n * @public\n */\ninterface TransformOptions<T> {\n    /**\n     * Clamp values to within the given range. Defaults to `true`\n     *\n     * @public\n     */\n    clamp?: boolean;\n    /**\n     * Easing functions to use on the interpolations between each value in the input and output ranges.\n     *\n     * If provided as an array, the array must be one item shorter than the input and output ranges, as the easings apply to the transition **between** each.\n     *\n     * @public\n     */\n    ease?: EasingFunction | EasingFunction[];\n    /**\n     * Provide a function that can interpolate between any two values in the provided range.\n     *\n     * @public\n     */\n    mixer?: (from: T, to: T) => (v: number) => any;\n}\n/**\n * Transforms numbers into other values by mapping them from an input range to an output range.\n * Returns the type of the input provided.\n *\n * @remarks\n *\n * Given an input range of `[0, 200]` and an output range of\n * `[0, 1]`, this function will return a value between `0` and `1`.\n * The input range must be a linear series of numbers. The output range\n * can be any supported value type, such as numbers, colors, shadows, arrays, objects and more.\n * Every value in the output range must be of the same type and in the same format.\n *\n * ```jsx\n * export function MyComponent() {\n *    const inputRange = [0, 200]\n *    const outputRange = [0, 1]\n *    const output = transform(100, inputRange, outputRange)\n *\n *    // Returns 0.5\n *    return <div>{output}</div>\n * }\n * ```\n *\n * @param inputValue - A number to transform between the input and output ranges.\n * @param inputRange - A linear series of numbers (either all increasing or decreasing).\n * @param outputRange - A series of numbers, colors, strings, or arrays/objects of those. Must be the same length as `inputRange`.\n * @param options - Clamp: Clamp values to within the given range. Defaults to `true`.\n *\n * @public\n */\ndeclare function transform<T>(inputValue: number, inputRange: number[], outputRange: T[], options?: TransformOptions<T>): T;\n/**\n *\n * Transforms numbers into other values by mapping them from an input range to an output range.\n *\n * Given an input range of `[0, 200]` and an output range of\n * `[0, 1]`, this function will return a value between `0` and `1`.\n * The input range must be a linear series of numbers. The output range\n * can be any supported value type, such as numbers, colors, shadows, arrays, objects and more.\n * Every value in the output range must be of the same type and in the same format.\n *\n * ```jsx\n * export function MyComponent() {\n *     const inputRange = [-200, -100, 100, 200]\n *     const outputRange = [0, 1, 1, 0]\n *     const convertRange = transform(inputRange, outputRange)\n *     const output = convertRange(-150)\n *\n *     // Returns 0.5\n *     return <div>{output}</div>\n * }\n *\n * ```\n *\n * @param inputRange - A linear series of numbers (either all increasing or decreasing).\n * @param outputRange - A series of numbers, colors or strings. Must be the same length as `inputRange`.\n * @param options - Clamp: clamp values to within the given range. Defaults to `true`.\n *\n * @public\n */\ndeclare function transform<T>(inputRange: number[], outputRange: T[], options?: TransformOptions<T>): (inputValue: number) => T;\n\ntype MapInputRange = number[];\n/**\n * Create a `MotionValue` that maps the output of another `MotionValue` by\n * mapping it from one range of values into another.\n *\n * @remarks\n *\n * Given an input range of `[-200, -100, 100, 200]` and an output range of\n * `[0, 1, 1, 0]`, the returned `MotionValue` will:\n *\n * - When provided a value between `-200` and `-100`, will return a value between `0` and  `1`.\n * - When provided a value between `-100` and `100`, will return `1`.\n * - When provided a value between `100` and `200`, will return a value between `1` and  `0`\n *\n * The input range must be a linear series of numbers. The output range\n * can be any value type supported by Motion: numbers, colors, shadows, etc.\n *\n * Every value in the output range must be of the same type and in the same format.\n *\n * ```jsx\n * const x = motionValue(0)\n * const xRange = [-200, -100, 100, 200]\n * const opacityRange = [0, 1, 1, 0]\n * const opacity = mapValue(x, xRange, opacityRange)\n * ```\n *\n * @param inputValue - `MotionValue`\n * @param inputRange - A linear series of numbers (either all increasing or decreasing)\n * @param outputRange - A series of numbers, colors or strings. Must be the same length as `inputRange`.\n * @param options -\n *\n *  - clamp: boolean. Clamp values to within the given range. Defaults to `true`\n *  - ease: EasingFunction[]. Easing functions to use on the interpolations between each value in the input and output ranges. If provided as an array, the array must be one item shorter than the input and output ranges, as the easings apply to the transition between each.\n *\n * @returns `MotionValue`\n *\n * @public\n */\ndeclare function mapValue<O>(inputValue: MotionValue<number>, inputRange: MapInputRange, outputRange: O[], options?: TransformOptions<O>): MotionValue<O>;\n\n/**\n * Create a `MotionValue` that animates to its latest value using a spring.\n * Can either be a value or track another `MotionValue`.\n *\n * ```jsx\n * const x = motionValue(0)\n * const y = transformValue(() => x.get() * 2) // double x\n * ```\n *\n * @param transformer - A transform function. This function must be pure with no side-effects or conditional statements.\n * @returns `MotionValue`\n *\n * @public\n */\ndeclare function springValue<T extends AnyResolvedKeyframe>(source: T | MotionValue<T>, options?: SpringOptions): MotionValue<T>;\ndeclare function attachSpring<T extends AnyResolvedKeyframe>(value: MotionValue<T>, source: T | MotionValue<T>, options?: SpringOptions): VoidFunction;\n\ntype TransformInputRange = number[];\ntype SingleTransformer<I, O> = (input: I) => O;\ntype MultiTransformer<I, O> = (input: I[]) => O;\ntype ValueTransformer<I, O> = SingleTransformer<I, O> | MultiTransformer<I, O>;\n/**\n * Create a `MotionValue` that transforms the output of other `MotionValue`s by\n * passing their latest values through a transform function.\n *\n * Whenever a `MotionValue` referred to in the provided function is updated,\n * it will be re-evaluated.\n *\n * ```jsx\n * const x = motionValue(0)\n * const y = transformValue(() => x.get() * 2) // double x\n * ```\n *\n * @param transformer - A transform function. This function must be pure with no side-effects or conditional statements.\n * @returns `MotionValue`\n *\n * @public\n */\ndeclare function transformValue<O>(transform: () => O): MotionValue<O>;\n\ndeclare const color: {\n    test: (v: any) => boolean;\n    parse: (v: any) => RGBA | HSLA;\n    transform: (v: HSLA | RGBA | string) => string;\n    getAnimatableNone: (v: string) => string;\n};\n\ndeclare function parseHex(v: string): RGBA;\ndeclare const hex: {\n    test: (v: any) => boolean;\n    parse: typeof parseHex;\n    transform: ({ red, green, blue, alpha }: RGBA) => string;\n};\n\ndeclare const hsla: {\n    test: (v: any) => boolean;\n    parse: (v: string | Color) => HSLA;\n    transform: ({ hue, saturation, lightness, alpha }: HSLA) => string;\n};\n\ndeclare function hslaToRgba({ hue, saturation, lightness, alpha }: HSLA): RGBA;\n\ndeclare const rgbUnit: {\n    transform: (v: number) => number;\n    test: (v: number) => boolean;\n    parse: typeof parseFloat;\n};\ndeclare const rgba: {\n    test: (v: any) => boolean;\n    parse: (v: string | Color) => RGBA;\n    transform: ({ red, green, blue, alpha }: RGBA) => string;\n};\n\ndeclare function test(v: any): boolean;\ntype ComplexValues = Array<CSSVariableToken | AnyResolvedKeyframe | Color>;\ninterface ValueIndexes {\n    color: number[];\n    number: number[];\n    var: number[];\n}\ninterface ComplexValueInfo {\n    values: ComplexValues;\n    split: string[];\n    indexes: ValueIndexes;\n    types: Array<keyof ValueIndexes>;\n}\ndeclare function analyseComplexValue(value: AnyResolvedKeyframe): ComplexValueInfo;\ndeclare function parseComplexValue(v: AnyResolvedKeyframe): ComplexValues;\ndeclare function createTransformer(source: AnyResolvedKeyframe): (v: Array<CSSVariableToken | Color | number | string>) => string;\ndeclare function getAnimatableNone$1(v: AnyResolvedKeyframe): string;\ndeclare const complex: {\n    test: typeof test;\n    parse: typeof parseComplexValue;\n    createTransformer: typeof createTransformer;\n    getAnimatableNone: typeof getAnimatableNone$1;\n};\n\n/**\n * A list of value types commonly used for dimensions\n */\ndeclare const dimensionValueTypes: ({\n    test: (v: number) => boolean;\n    parse: typeof parseFloat;\n    transform: (v: number) => number;\n} | {\n    test: (v: AnyResolvedKeyframe) => boolean;\n    parse: typeof parseFloat;\n    transform: (v: string | number) => string;\n} | ValueType)[];\n/**\n * Tests a dimensional value against the list of dimension ValueTypes\n */\ndeclare const findDimensionValueType: (v: any) => {\n    test: (v: number) => boolean;\n    parse: typeof parseFloat;\n    transform: (v: number) => number;\n} | {\n    test: (v: AnyResolvedKeyframe) => boolean;\n    parse: typeof parseFloat;\n    transform: (v: string | number) => string;\n} | ValueType | undefined;\n\ninterface ValueTypeMap {\n    [key: string]: ValueType;\n}\n\n/**\n * A map of default value types for common values\n */\ndeclare const defaultValueTypes: ValueTypeMap;\n/**\n * Gets the default ValueType for the provided value key\n */\ndeclare const getDefaultValueType: (key: string) => ValueType;\n\ndeclare const numberValueTypes: ValueTypeMap;\n\ndeclare const transformValueTypes: ValueTypeMap;\n\ndeclare const number: {\n    test: (v: number) => boolean;\n    parse: typeof parseFloat;\n    transform: (v: number) => number;\n};\ndeclare const alpha: {\n    transform: (v: number) => number;\n    test: (v: number) => boolean;\n    parse: typeof parseFloat;\n};\ndeclare const scale: {\n    default: number;\n    test: (v: number) => boolean;\n    parse: typeof parseFloat;\n    transform: (v: number) => number;\n};\n\ndeclare const degrees: {\n    test: (v: AnyResolvedKeyframe) => boolean;\n    parse: typeof parseFloat;\n    transform: (v: number | string) => string;\n};\ndeclare const percent: {\n    test: (v: AnyResolvedKeyframe) => boolean;\n    parse: typeof parseFloat;\n    transform: (v: number | string) => string;\n};\ndeclare const px: {\n    test: (v: AnyResolvedKeyframe) => boolean;\n    parse: typeof parseFloat;\n    transform: (v: number | string) => string;\n};\ndeclare const vh: {\n    test: (v: AnyResolvedKeyframe) => boolean;\n    parse: typeof parseFloat;\n    transform: (v: number | string) => string;\n};\ndeclare const vw: {\n    test: (v: AnyResolvedKeyframe) => boolean;\n    parse: typeof parseFloat;\n    transform: (v: number | string) => string;\n};\ndeclare const progressPercentage: {\n    parse: (v: string) => number;\n    transform: (v: number) => string;\n    test: (v: AnyResolvedKeyframe) => boolean;\n};\n\n/**\n * Tests a provided value against a ValueType\n */\ndeclare const testValueType: (v: any) => (type: ValueType) => boolean;\n\ndeclare function getAnimatableNone(key: string, value: string): any;\n\n/**\n * Tests a value against the list of ValueTypes\n */\ndeclare const findValueType: (v: any) => {\n    test: (v: number) => boolean;\n    parse: typeof parseFloat;\n    transform: (v: number) => number;\n} | {\n    test: (v: AnyResolvedKeyframe) => boolean;\n    parse: typeof parseFloat;\n    transform: (v: string | number) => string;\n} | ValueType | {\n    test: (v: any) => boolean;\n    parse: (v: any) => RGBA | HSLA;\n    transform: (v: string | RGBA | HSLA) => string;\n    getAnimatableNone: (v: string) => string;\n} | {\n    test: (v: any) => boolean;\n    parse: (v: AnyResolvedKeyframe) => ComplexValues;\n    createTransformer: (source: AnyResolvedKeyframe) => (v: (string | number | Color)[]) => string;\n    getAnimatableNone: (v: AnyResolvedKeyframe) => string;\n} | undefined;\n\n/**\n * Provided a value and a ValueType, returns the value as that value type.\n */\ndeclare const getValueAsType: (value: any, type?: ValueType) => any;\n\ndeclare const isMotionValue: (value: any) => value is MotionValue<any>;\n\ntype ViewTransitionAnimationDefinition = {\n    keyframes: DOMKeyframesDefinition;\n    options: AnimationOptions;\n};\ntype ViewTransitionTarget = {\n    layout?: ViewTransitionAnimationDefinition;\n    enter?: ViewTransitionAnimationDefinition;\n    exit?: ViewTransitionAnimationDefinition;\n    new?: ViewTransitionAnimationDefinition;\n    old?: ViewTransitionAnimationDefinition;\n};\ntype ViewTransitionOptions = AnimationOptions & {\n    interrupt?: \"wait\" | \"immediate\";\n};\ntype ViewTransitionTargetDefinition = string | Element;\n\ndeclare class ViewTransitionBuilder {\n    private currentSubject;\n    targets: Map<ViewTransitionTargetDefinition, ViewTransitionTarget>;\n    update: () => void | Promise<void>;\n    options: ViewTransitionOptions;\n    notifyReady: (value: GroupAnimation) => void;\n    private readyPromise;\n    constructor(update: () => void | Promise<void>, options?: ViewTransitionOptions);\n    get(subject: ViewTransitionTargetDefinition): this;\n    layout(keyframes: DOMKeyframesDefinition, options?: AnimationOptions): this;\n    new(keyframes: DOMKeyframesDefinition, options?: AnimationOptions): this;\n    old(keyframes: DOMKeyframesDefinition, options?: AnimationOptions): this;\n    enter(keyframes: DOMKeyframesDefinition, options?: AnimationOptions): this;\n    exit(keyframes: DOMKeyframesDefinition, options?: AnimationOptions): this;\n    crossfade(options?: AnimationOptions): this;\n    updateTarget(target: \"enter\" | \"exit\" | \"layout\" | \"new\" | \"old\", keyframes: DOMKeyframesDefinition, options?: AnimationOptions): void;\n    then(resolve: () => void, reject?: () => void): Promise<void>;\n}\ndeclare function animateView(update: () => void | Promise<void>, defaultOptions?: ViewTransitionOptions): ViewTransitionBuilder;\n\ndeclare function getViewAnimationLayerInfo(pseudoElement: string): {\n    layer: string;\n    type: string;\n} | null;\n\ndeclare function getViewAnimations(): Animation[];\n\n/**\n * @deprecated\n *\n * Import as `frame` instead.\n */\ndeclare const sync: Batcher;\n/**\n * @deprecated\n *\n * Use cancelFrame(callback) instead.\n */\ndeclare const cancelSync: Record<string, (process: Process) => void>;\n\nexport { type AcceptedAnimations, type ActiveStatsBuffer, type AnimationDefinition, type AnimationGeneratorName, type AnimationGeneratorType, type AnimationOptions, type AnimationOrchestrationOptions, type AnimationPlaybackControls, type AnimationPlaybackControlsWithThen, type AnimationPlaybackLifecycles, type AnimationPlaybackOptions, type AnimationScope, type AnimationState, type AnyResolvedKeyframe, AsyncMotionValueAnimation, type Batcher, type CSSStyleDeclarationWithTransform, type CSSVariableName, type CSSVariableToken, type CancelProcess, type Color, type ComplexValueInfo, type ComplexValues, type DOMKeyframesDefinition, DOMKeyframesResolver, type DOMValueAnimationOptions, type DecayOptions, type DragElastic, type DragHandler, type DraggableProps, type DurationSpringOptions, type DynamicOption, type ElementOrSelector, type EventInfo, type EventOptions, type FrameData, type FrameStats, type GeneratorFactory, type GeneratorFactoryFunction, GroupAnimation, GroupAnimationWithThen, type GroupedAnimations, type HSLA, type InactiveStatsBuffer, type InertiaOptions, type InterpolateOptions, JSAnimation, type KeyframeGenerator, type KeyframeOptions, KeyframeResolver, type LegacyAnimationControls, type MapInputRange, type Mixer, type MixerFactory, type MotionNodeAdvancedOptions, type MotionNodeAnimationOptions, type MotionNodeDragHandlers, type MotionNodeDraggableOptions, type MotionNodeEventOptions, type MotionNodeFocusHandlers, type MotionNodeHoverHandlers, type MotionNodeLayoutOptions, type MotionNodeOptions, type MotionNodePanHandlers, type MotionNodeTapHandlers, type MotionNodeViewportOptions, MotionValue, type MotionValueEventCallbacks, type MotionValueOptions, type MultiTransformer, NativeAnimation, NativeAnimationExtended, type NativeAnimationOptions, type NativeAnimationOptionsExtended, NativeAnimationWrapper, type NumberMap, type OnHoverEndEvent, type OnHoverStartEvent, type OnKeyframesResolved, type OnPressEndEvent, type OnPressStartEvent, type Owner, type PanHandler, type PanInfo, type PassiveEffect, type PointerEventOptions, type PressGestureInfo, type Process, type ProgressTimeline, type RGBA, type RepeatType, type ResolvedConstraints, type ResolvedElastic, type ResolvedKeyframes, type ResolvedValueKeyframe, type ResolvedValues, type SVGAttributes, type SVGForcedAttrKeyframesDefinition, type SVGForcedAttrProperties, type SVGForcedAttrTransitions, type SVGKeyframesDefinition, type SVGPathKeyframesDefinition, type SVGPathProperties, type SVGPathTransitions, type SVGTransitions, type Schedule, type SelectorCache, type SingleTransformer, type Spring, type SpringOptions, type StaggerOptions, type StaggerOrigin, type StartAnimation, type Stats, type StatsBuffer, type StatsRecording, type StatsSummary, type Step, type StepId, type Steps, type StyleKeyframesDefinition, type StyleTransitions, type Subscriber, type Summary, type TapHandlers, type TapInfo, type Target, type TargetAndTransition, type TargetResolver, type TimelineWithFallback, type TransformInputRange, type TransformOptions, type TransformProperties, type TransformTemplate, type Transformer, type Transition, type TransitionWithValueOverrides, type Tween, type UnresolvedKeyframes, type UnresolvedValueKeyframe, type ValueAnimationOptions, type ValueAnimationOptionsWithRenderContext, type ValueAnimationTransition, type ValueAnimationWithDynamicDelay, type ValueIndexes, type ValueKeyframe, type ValueKeyframesDefinition, type ValueTransformer, type ValueTransition, type ValueType, type ValueTypeMap, type VariableKeyframesDefinition, type VariableTransitions, type Variant, type VariantLabels, type Variants, type VelocityOptions, type ViewTransitionAnimationDefinition, ViewTransitionBuilder, type ViewTransitionOptions, type ViewTransitionTarget, type ViewTransitionTargetDefinition, type ViewportEventHandler, type ViewportOptions, type WithQuerySelectorAll, acceleratedValues, activeAnimations, addAttrValue, addStyleValue, alpha, analyseComplexValue, animateValue, animateView, animationMapKey, applyGeneratorOptions, applyPxDefaults, attachSpring, attrEffect, calcGeneratorDuration, cancelFrame, cancelMicrotask, cancelSync, collectMotionValues, color, complex, convertOffsetToTimes, createGeneratorEasing, createRenderBatcher, cubicBezierAsString, defaultEasing, defaultOffset, defaultTransformValue, defaultValueTypes, degrees, dimensionValueTypes, fillOffset, fillWildcards, findDimensionValueType, findValueType, flushKeyframeResolvers, frame, frameData, frameSteps, generateLinearEasing, getAnimatableNone, getAnimationMap, getComputedStyle, getDefaultValueType, getMixer, getOriginIndex, getValueAsType, getValueTransition, getVariableValue, getViewAnimationLayerInfo, getViewAnimations, hex, hover, hsla, hslaToRgba, inertia, interpolate, invisibleValues, isCSSVariableName, isCSSVariableToken, isDragActive, isDragging, isGenerator, isHTMLElement, isMotionValue, isNodeOrChild, isPrimaryPointer, isSVGElement, isSVGSVGElement, isWaapiSupportedEasing, keyframes, makeAnimationInstant, mapEasingToNativeEasing, mapValue, maxGeneratorDuration, microtask, mix, mixArray, mixColor, mixComplex, mixImmediate, mixLinearColor, mixNumber, mixObject, mixVisibility, motionValue, number, numberValueTypes, observeTimeline, parseCSSVariable, parseValueFromTransform, percent, positionalKeys, press, progressPercentage, propEffect, px, readTransformValue, recordStats, resize, resolveElements, rgbUnit, rgba, scale, setDragLock, setStyle, spring, springValue, stagger, startWaapiAnimation, statsBuffer, styleEffect, supportedWaapiEasing, supportsBrowserAnimation, supportsFlags, supportsLinearEasing, supportsPartialKeyframes, supportsScrollTimeline, svgEffect, sync, testValueType, time, transform, transformPropOrder, transformProps, transformValue, transformValueTypes, vh, vw };\n"],"x_google_ignoreList":[0],"mappings":"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"}

package/index6.d.ts

@@ -1,6 +0,0 @@
-/// <reference types="react" />
-import { BezierDefinition, Easing, EasingDefinition, EasingFunction } from "./index4.js";
-import { AnimationGeneratorName, AnimationGeneratorType, AnimationOrchestrationOptions, AnimationPlaybackControls, AnimationPlaybackControlsWithThen, AnimationPlaybackLifecycles, AnimationPlaybackOptions, AnimationState, AnyResolvedKeyframe, Batcher, CSSStyleDeclarationWithTransform, DOMKeyframesDefinition, DecayOptions, DurationSpringOptions, DynamicOption, FrameData, GeneratorFactory, GeneratorFactoryFunction, InertiaOptions, KeyframeGenerator, KeyframeOptions, MotionValue, MotionValueEventCallbacks, MotionValueOptions, Owner, PassiveEffect, Process, ProgressTimeline, RepeatType, SVGAttributes, SVGForcedAttrKeyframesDefinition, SVGForcedAttrProperties, SVGForcedAttrTransitions, SVGKeyframesDefinition, SVGPathKeyframesDefinition, SVGPathProperties, SVGPathTransitions, SVGTransitions, Schedule, SpringOptions, StartAnimation, StepId, StyleKeyframesDefinition, StyleTransitions, Subscriber, Target, TargetAndTransition, TargetResolver, TimelineWithFallback, TransformProperties, Transition, TransitionWithValueOverrides, UnresolvedValueKeyframe, ValueAnimationOptions, ValueAnimationTransition, ValueKeyframe, ValueKeyframesDefinition, ValueTransition, VariableKeyframesDefinition, VariableTransitions, Variant, Variants, VelocityOptions } from "./index5.js";
-import { optimizedAppearDataAttribute } from "./types.d-BJcRxCew.js";
-import { useEffect } from "react";
-import "react/jsx-runtime";

package/react.d.ts

@@ -1,4 +0,0 @@
-import { BezierDefinition, Easing, EasingDefinition, EasingFunction } from "./index4.js";
-import { AnimationGeneratorName, AnimationGeneratorType, AnimationOrchestrationOptions, AnimationPlaybackControls, AnimationPlaybackControlsWithThen, AnimationPlaybackLifecycles, AnimationPlaybackOptions, AnimationState, AnyResolvedKeyframe, Batcher, CSSStyleDeclarationWithTransform, DOMKeyframesDefinition, DecayOptions, DurationSpringOptions, DynamicOption, FrameData, GeneratorFactory, GeneratorFactoryFunction, InertiaOptions, KeyframeGenerator, KeyframeOptions, MotionValue, MotionValueEventCallbacks, MotionValueOptions, Owner, PassiveEffect, Process, ProgressTimeline, RepeatType, SVGAttributes, SVGForcedAttrKeyframesDefinition, SVGForcedAttrProperties, SVGForcedAttrTransitions, SVGKeyframesDefinition, SVGPathKeyframesDefinition, SVGPathProperties, SVGPathTransitions, SVGTransitions, Schedule, SpringOptions, StartAnimation, StepId, StyleKeyframesDefinition, StyleTransitions, Subscriber, Target, TargetAndTransition, TargetResolver, TimelineWithFallback, TransformProperties, Transition, TransitionWithValueOverrides, UnresolvedValueKeyframe, ValueAnimationOptions, ValueAnimationTransition, ValueKeyframe, ValueKeyframesDefinition, ValueTransition, VariableKeyframesDefinition, VariableTransitions, Variant, Variants, VelocityOptions } from "./index5.js";
-import { optimizedAppearDataAttribute } from "./types.d-BJcRxCew.js";
-import "./index6.js";

package/support/components/text-effect.d.ts

@@ -1,53 +0,0 @@
-import { Transition, Variants } from "../../index5.js";
-import "../../react.js";
-import React from "react";
-
-//#region src/support/components/text-effect.d.ts
-type PresetType = "blur" | "fade-in-blur" | "scale" | "fade" | "slide";
-type PerType = "word" | "char" | "line";
-type TextEffectProps = {
-  children: string | string[];
-  per?: PerType;
-  as?: keyof React.JSX.IntrinsicElements;
-  variants?: {
-    container?: Variants;
-    item?: Variants;
-  };
-  className?: string;
-  preset?: PresetType;
-  delay?: number;
-  speedReveal?: number;
-  speedSegment?: number;
-  trigger?: boolean;
-  onAnimationComplete?: () => void;
-  onAnimationStart?: () => void;
-  segmentWrapperClassName?: string;
-  containerTransition?: Transition;
-  segmentTransition?: Transition;
-  style?: React.CSSProperties;
-};
-/**
- * Animated typography helper that reveals text word-by-word or letter-by-letter
- * with configurable motion presets.
- */
-declare function TextEffect({
-  children,
-  per,
-  as,
-  variants,
-  className,
-  preset,
-  delay,
-  speedReveal,
-  speedSegment,
-  trigger,
-  onAnimationComplete,
-  onAnimationStart,
-  segmentWrapperClassName,
-  containerTransition,
-  segmentTransition,
-  style
-}: TextEffectProps): React.ReactElement;
-//#endregion
-export { PerType, PresetType, TextEffect, TextEffectProps };
-//# sourceMappingURL=text-effect.d.ts.map

package/support/components/text-effect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"text-effect.d.ts","names":[],"sources":["../../../src/support/components/text-effect.tsx"],"sourcesContent":[],"mappings":";;;;;KAWY,UAAA;KAEA,OAAA;KAIA,eAAA;EANA,QAAA,EAAA,MAAU,GAAA,MAAA,EAAA;EAEV,GAAA,CAAA,EAML,OANY;EAIP,EAAA,CAAA,EAAA,MAGA,KAAA,CAAM,GAAA,CAAI,iBAHK;EAEpB,QAAA,CAAA,EAAA;IACW,SAAI,CAAA,EAER,QAFQ;IAER,IAAA,CAAA,EACL,QADK;EACL,CAAA;EAGC,SAAA,CAAA,EAAA,MAAA;EAQa,MAAA,CAAA,EARb,UAQa;EACF,KAAA,CAAA,EAAA,MAAA;EACZ,WAAM,CAAA,EAAA,MAAA;EAAa,YAAA,CAAA,EAAA,MAAA;EAmLZ,OAAA,CAAA,EAAA,OAAU;EACzB,mBAAA,CAAA,EAAA,GAAA,GAAA,IAAA;EACA,gBAAA,CAAA,EAAA,GAAA,GAAA,IAAA;EACA,uBAAA,CAAA,EAAA,MAAA;EACA,mBAAA,CAAA,EAzLsB,UAyLtB;EACA,iBAAA,CAAA,EAzLoB,UAyLpB;EACA,KAAA,CAAA,EAzLQ,KAAA,CAAM,aAyLd;CACA;;;;;AAKA,iBAZe,UAAA,CAYf;EAAA,QAAA;EAAA,GAAA;EAAA,EAAA;EAAA,QAAA;EAAA,SAAA;EAAA,MAAA;EAAA,KAAA;EAAA,WAAA;EAAA,YAAA;EAAA,OAAA;EAAA,mBAAA;EAAA,gBAAA;EAAA,uBAAA;EAAA,mBAAA;EAAA,iBAAA;EAAA;AAAA,CAAA,EAKE,eALF,CAAA,EAKoB,KAAA,CAAM,YAL1B"}