/**
 * `<Motion>` is a declarative wrapper around `play()`. It renders a
 * host element (configurable via the `as` prop) and drives animation
 * via a template ref.
 *
 *   <Motion as="div" :initial="{ opacity: 0 }" :animate="{ opacity: 1 }"
 *           :transition="{ duration: 400 }" />
 *
 * Variants. Pass a `variants` map of named `MotionValues` and use a
 * string key for `initial`, `animate`, `exit`, `whileHover`, or
 * `whileTap` to drive a declarative state machine:
 *
 *   const v = { closed: { opacity: 0 }, open: { opacity: 1 } }
 *   <Motion :variants="v" initial="closed" :animate="isOpen ? 'open' : 'closed'" />
 *
 * Parent-child propagation. A `<Motion>` whose `animate` is a key
 * provides that key (via `inject`) to descendants that have their own
 * `variants` but no explicit `animate`. The descendants resolve the
 * inherited key against their own map.
 *
 * whileHover / whileTap. Resolved values from these props temporarily
 * override `animate` while the pointer is over (hover) or pressed
 * (tap). Tap takes precedence over hover.
 *
 * The resolved `initial` object is applied as inline styles on first
 * render so the element paints at the starting state before any animation
 * frame runs.
 */
import type { EasingFn, NormalizedVelocity, PlayOpts } from "@kinem/core";
import { type PropType } from "vue";
export type MotionValues = Readonly<Record<string, string | number>>;
export type Variants = Readonly<Record<string, MotionValues>>;
/**
 * What `initial`, `animate`, `exit`, `whileHover`, and `whileTap` accept:
 * inline values, a single variant key, or an array of keys merged in
 * order (later wins). String / array forms require a `variants` map;
 * otherwise they resolve to `undefined` and the prop is ignored.
 */
export type VariantTarget = MotionValues | string | readonly string[];
export interface MotionTransition {
    /**
     * "tween" (default) plays a fixed-duration easing; "spring" plays a
     * physical spring. When omitted, the presence of any spring field
     * implies "spring".
     */
    readonly type?: "tween" | "spring";
    readonly duration?: number;
    readonly easing?: EasingFn;
    readonly stiffness?: number;
    readonly damping?: number;
    readonly mass?: number;
    /**
     * Spring: initial velocity, in normalized [0, 1]/sec units of travel.
     * Mint with `normalizedVelocity()` or `velocityFromSpan()` from
     * `@kinem/core`.
     */
    readonly velocity?: NormalizedVelocity;
    readonly backend?: PlayOpts["backend"];
    /**
     * Per-element delay in ms before the tween starts. Composes with any
     * stagger delay inherited from a parent.
     */
    readonly delay?: number;
    /**
     * When set on a parent `<Motion>`, descendants that inherit the
     * parent's animate key are staggered by `staggerChildren` ms in
     * mount order: the first child has zero delay, the second
     * `staggerChildren` ms, the third `2 * staggerChildren`, and so on.
     * Applies only to animate-key-driven changes; whileHover and
     * whileTap never stagger.
     */
    readonly staggerChildren?: number;
}
export declare const Motion: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
    as: {
        type: StringConstructor;
        default: string;
    };
    variants: {
        type: PropType<Variants>;
        default: undefined;
    };
    initial: {
        type: PropType<VariantTarget>;
        default: undefined;
    };
    animate: {
        type: PropType<VariantTarget>;
        default: undefined;
    };
    exit: {
        type: PropType<VariantTarget>;
        default: undefined;
    };
    whileHover: {
        type: PropType<VariantTarget>;
        default: undefined;
    };
    whileTap: {
        type: PropType<VariantTarget>;
        default: undefined;
    };
    transition: {
        type: PropType<MotionTransition>;
        default: undefined;
    };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
    as: {
        type: StringConstructor;
        default: string;
    };
    variants: {
        type: PropType<Variants>;
        default: undefined;
    };
    initial: {
        type: PropType<VariantTarget>;
        default: undefined;
    };
    animate: {
        type: PropType<VariantTarget>;
        default: undefined;
    };
    exit: {
        type: PropType<VariantTarget>;
        default: undefined;
    };
    whileHover: {
        type: PropType<VariantTarget>;
        default: undefined;
    };
    whileTap: {
        type: PropType<VariantTarget>;
        default: undefined;
    };
    transition: {
        type: PropType<MotionTransition>;
        default: undefined;
    };
}>> & Readonly<{}>, {
    as: string;
    variants: Readonly<Record<string, Readonly<Record<string, string | number>>>>;
    initial: VariantTarget;
    animate: VariantTarget;
    exit: VariantTarget;
    whileHover: VariantTarget;
    whileTap: VariantTarget;
    transition: MotionTransition;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
//# sourceMappingURL=Motion.d.ts.map