maquinaweb-ui 2.75.0 → 2.75.2

package/dist/node_modules/motion-dom/dist/index.d.ts

@@ -0,0 +1,1001 @@
+import { Easing, EasingFunction } from "../../motion-utils/dist/index.js";
+
+//#region node_modules/motion-dom/dist/index.d.ts
+interface SVGAttributes {
+  accentHeight?: AnyResolvedKeyframe | undefined;
+  accumulate?: "none" | "sum" | undefined;
+  additive?: "replace" | "sum" | undefined;
+  alignmentBaseline?: "auto" | "baseline" | "before-edge" | "text-before-edge" | "middle" | "central" | "after-edge" | "text-after-edge" | "ideographic" | "alphabetic" | "hanging" | "mathematical" | "inherit" | undefined;
+  allowReorder?: "no" | "yes" | undefined;
+  alphabetic?: AnyResolvedKeyframe | undefined;
+  amplitude?: AnyResolvedKeyframe | undefined;
+  arabicForm?: "initial" | "medial" | "terminal" | "isolated" | undefined;
+  ascent?: AnyResolvedKeyframe | undefined;
+  attributeName?: string | undefined;
+  attributeType?: string | undefined;
+  autoReverse?: boolean | undefined;
+  azimuth?: AnyResolvedKeyframe | undefined;
+  baseFrequency?: AnyResolvedKeyframe | undefined;
+  baselineShift?: AnyResolvedKeyframe | undefined;
+  baseProfile?: AnyResolvedKeyframe | undefined;
+  bbox?: AnyResolvedKeyframe | undefined;
+  begin?: AnyResolvedKeyframe | undefined;
+  bias?: AnyResolvedKeyframe | undefined;
+  by?: AnyResolvedKeyframe | undefined;
+  calcMode?: AnyResolvedKeyframe | undefined;
+  capHeight?: AnyResolvedKeyframe | undefined;
+  clip?: AnyResolvedKeyframe | undefined;
+  clipPath?: string | undefined;
+  clipPathUnits?: AnyResolvedKeyframe | undefined;
+  clipRule?: AnyResolvedKeyframe | undefined;
+  colorInterpolation?: AnyResolvedKeyframe | undefined;
+  colorInterpolationFilters?: "auto" | "sRGB" | "linearRGB" | "inherit" | undefined;
+  colorProfile?: AnyResolvedKeyframe | undefined;
+  colorRendering?: AnyResolvedKeyframe | undefined;
+  contentScriptType?: AnyResolvedKeyframe | undefined;
+  contentStyleType?: AnyResolvedKeyframe | undefined;
+  cursor?: AnyResolvedKeyframe | undefined;
+  cx?: AnyResolvedKeyframe | undefined;
+  cy?: AnyResolvedKeyframe | undefined;
+  d?: string | undefined;
+  decelerate?: AnyResolvedKeyframe | undefined;
+  descent?: AnyResolvedKeyframe | undefined;
+  diffuseConstant?: AnyResolvedKeyframe | undefined;
+  direction?: AnyResolvedKeyframe | undefined;
+  display?: AnyResolvedKeyframe | undefined;
+  divisor?: AnyResolvedKeyframe | undefined;
+  dominantBaseline?: AnyResolvedKeyframe | undefined;
+  dur?: AnyResolvedKeyframe | undefined;
+  dx?: AnyResolvedKeyframe | undefined;
+  dy?: AnyResolvedKeyframe | undefined;
+  edgeMode?: AnyResolvedKeyframe | undefined;
+  elevation?: AnyResolvedKeyframe | undefined;
+  enableBackground?: AnyResolvedKeyframe | undefined;
+  end?: AnyResolvedKeyframe | undefined;
+  exponent?: AnyResolvedKeyframe | undefined;
+  externalResourcesRequired?: boolean | undefined;
+  fill?: string | undefined;
+  fillOpacity?: AnyResolvedKeyframe | undefined;
+  fillRule?: "nonzero" | "evenodd" | "inherit" | undefined;
+  filter?: string | undefined;
+  filterRes?: AnyResolvedKeyframe | undefined;
+  filterUnits?: AnyResolvedKeyframe | undefined;
+  floodColor?: AnyResolvedKeyframe | undefined;
+  floodOpacity?: AnyResolvedKeyframe | undefined;
+  focusable?: boolean | "auto" | undefined;
+  fontFamily?: string | undefined;
+  fontSize?: AnyResolvedKeyframe | undefined;
+  fontSizeAdjust?: AnyResolvedKeyframe | undefined;
+  fontStretch?: AnyResolvedKeyframe | undefined;
+  fontStyle?: AnyResolvedKeyframe | undefined;
+  fontVariant?: AnyResolvedKeyframe | undefined;
+  fontWeight?: AnyResolvedKeyframe | undefined;
+  format?: AnyResolvedKeyframe | undefined;
+  fr?: AnyResolvedKeyframe | undefined;
+  from?: AnyResolvedKeyframe | undefined;
+  fx?: AnyResolvedKeyframe | undefined;
+  fy?: AnyResolvedKeyframe | undefined;
+  g1?: AnyResolvedKeyframe | undefined;
+  g2?: AnyResolvedKeyframe | undefined;
+  glyphName?: AnyResolvedKeyframe | undefined;
+  glyphOrientationHorizontal?: AnyResolvedKeyframe | undefined;
+  glyphOrientationVertical?: AnyResolvedKeyframe | undefined;
+  glyphRef?: AnyResolvedKeyframe | undefined;
+  gradientTransform?: string | undefined;
+  gradientUnits?: string | undefined;
+  hanging?: AnyResolvedKeyframe | undefined;
+  horizAdvX?: AnyResolvedKeyframe | undefined;
+  horizOriginX?: AnyResolvedKeyframe | undefined;
+  href?: string | undefined;
+  ideographic?: AnyResolvedKeyframe | undefined;
+  imageRendering?: AnyResolvedKeyframe | undefined;
+  in2?: AnyResolvedKeyframe | undefined;
+  in?: string | undefined;
+  intercept?: AnyResolvedKeyframe | undefined;
+  k1?: AnyResolvedKeyframe | undefined;
+  k2?: AnyResolvedKeyframe | undefined;
+  k3?: AnyResolvedKeyframe | undefined;
+  k4?: AnyResolvedKeyframe | undefined;
+  k?: AnyResolvedKeyframe | undefined;
+  kernelMatrix?: AnyResolvedKeyframe | undefined;
+  kernelUnitLength?: AnyResolvedKeyframe | undefined;
+  kerning?: AnyResolvedKeyframe | undefined;
+  keyPoints?: AnyResolvedKeyframe | undefined;
+  keySplines?: AnyResolvedKeyframe | undefined;
+  keyTimes?: AnyResolvedKeyframe | undefined;
+  lengthAdjust?: AnyResolvedKeyframe | undefined;
+  letterSpacing?: AnyResolvedKeyframe | undefined;
+  lightingColor?: AnyResolvedKeyframe | undefined;
+  limitingConeAngle?: AnyResolvedKeyframe | undefined;
+  local?: AnyResolvedKeyframe | undefined;
+  markerEnd?: string | undefined;
+  markerHeight?: AnyResolvedKeyframe | undefined;
+  markerMid?: string | undefined;
+  markerStart?: string | undefined;
+  markerUnits?: AnyResolvedKeyframe | undefined;
+  markerWidth?: AnyResolvedKeyframe | undefined;
+  mask?: string | undefined;
+  maskContentUnits?: AnyResolvedKeyframe | undefined;
+  maskUnits?: AnyResolvedKeyframe | undefined;
+  mathematical?: AnyResolvedKeyframe | undefined;
+  mode?: AnyResolvedKeyframe | undefined;
+  numOctaves?: AnyResolvedKeyframe | undefined;
+  offset?: AnyResolvedKeyframe | undefined;
+  opacity?: AnyResolvedKeyframe | undefined;
+  operator?: AnyResolvedKeyframe | undefined;
+  order?: AnyResolvedKeyframe | undefined;
+  orient?: AnyResolvedKeyframe | undefined;
+  orientation?: AnyResolvedKeyframe | undefined;
+  origin?: AnyResolvedKeyframe | undefined;
+  overflow?: AnyResolvedKeyframe | undefined;
+  overlinePosition?: AnyResolvedKeyframe | undefined;
+  overlineThickness?: AnyResolvedKeyframe | undefined;
+  paintOrder?: AnyResolvedKeyframe | undefined;
+  panose1?: AnyResolvedKeyframe | undefined;
+  path?: string | undefined;
+  pathLength?: AnyResolvedKeyframe | undefined;
+  patternContentUnits?: string | undefined;
+  patternTransform?: AnyResolvedKeyframe | undefined;
+  patternUnits?: string | undefined;
+  pointerEvents?: AnyResolvedKeyframe | undefined;
+  points?: string | undefined;
+  pointsAtX?: AnyResolvedKeyframe | undefined;
+  pointsAtY?: AnyResolvedKeyframe | undefined;
+  pointsAtZ?: AnyResolvedKeyframe | undefined;
+  preserveAlpha?: boolean | undefined;
+  preserveAspectRatio?: string | undefined;
+  primitiveUnits?: AnyResolvedKeyframe | undefined;
+  r?: AnyResolvedKeyframe | undefined;
+  radius?: AnyResolvedKeyframe | undefined;
+  refX?: AnyResolvedKeyframe | undefined;
+  refY?: AnyResolvedKeyframe | undefined;
+  renderingIntent?: AnyResolvedKeyframe | undefined;
+  repeatCount?: AnyResolvedKeyframe | undefined;
+  repeatDur?: AnyResolvedKeyframe | undefined;
+  requiredExtensions?: AnyResolvedKeyframe | undefined;
+  requiredFeatures?: AnyResolvedKeyframe | undefined;
+  restart?: AnyResolvedKeyframe | undefined;
+  result?: string | undefined;
+  rotate?: AnyResolvedKeyframe | undefined;
+  rx?: AnyResolvedKeyframe | undefined;
+  ry?: AnyResolvedKeyframe | undefined;
+  scale?: AnyResolvedKeyframe | undefined;
+  seed?: AnyResolvedKeyframe | undefined;
+  shapeRendering?: AnyResolvedKeyframe | undefined;
+  slope?: AnyResolvedKeyframe | undefined;
+  spacing?: AnyResolvedKeyframe | undefined;
+  specularConstant?: AnyResolvedKeyframe | undefined;
+  specularExponent?: AnyResolvedKeyframe | undefined;
+  speed?: AnyResolvedKeyframe | undefined;
+  spreadMethod?: string | undefined;
+  startOffset?: AnyResolvedKeyframe | undefined;
+  stdDeviation?: AnyResolvedKeyframe | undefined;
+  stemh?: AnyResolvedKeyframe | undefined;
+  stemv?: AnyResolvedKeyframe | undefined;
+  stitchTiles?: AnyResolvedKeyframe | undefined;
+  stopColor?: string | undefined;
+  stopOpacity?: AnyResolvedKeyframe | undefined;
+  strikethroughPosition?: AnyResolvedKeyframe | undefined;
+  strikethroughThickness?: AnyResolvedKeyframe | undefined;
+  string?: AnyResolvedKeyframe | undefined;
+  stroke?: string | undefined;
+  strokeDasharray?: AnyResolvedKeyframe | undefined;
+  strokeDashoffset?: AnyResolvedKeyframe | undefined;
+  strokeLinecap?: "butt" | "round" | "square" | "inherit" | undefined;
+  strokeLinejoin?: "miter" | "round" | "bevel" | "inherit" | undefined;
+  strokeMiterlimit?: AnyResolvedKeyframe | undefined;
+  strokeOpacity?: AnyResolvedKeyframe | undefined;
+  strokeWidth?: AnyResolvedKeyframe | undefined;
+  surfaceScale?: AnyResolvedKeyframe | undefined;
+  systemLanguage?: AnyResolvedKeyframe | undefined;
+  tableValues?: AnyResolvedKeyframe | undefined;
+  targetX?: AnyResolvedKeyframe | undefined;
+  targetY?: AnyResolvedKeyframe | undefined;
+  textAnchor?: string | undefined;
+  textDecoration?: AnyResolvedKeyframe | undefined;
+  textLength?: AnyResolvedKeyframe | undefined;
+  textRendering?: AnyResolvedKeyframe | undefined;
+  to?: AnyResolvedKeyframe | undefined;
+  transform?: string | undefined;
+  u1?: AnyResolvedKeyframe | undefined;
+  u2?: AnyResolvedKeyframe | undefined;
+  underlinePosition?: AnyResolvedKeyframe | undefined;
+  underlineThickness?: AnyResolvedKeyframe | undefined;
+  unicode?: AnyResolvedKeyframe | undefined;
+  unicodeBidi?: AnyResolvedKeyframe | undefined;
+  unicodeRange?: AnyResolvedKeyframe | undefined;
+  unitsPerEm?: AnyResolvedKeyframe | undefined;
+  vAlphabetic?: AnyResolvedKeyframe | undefined;
+  values?: string | undefined;
+  vectorEffect?: AnyResolvedKeyframe | undefined;
+  version?: string | undefined;
+  vertAdvY?: AnyResolvedKeyframe | undefined;
+  vertOriginX?: AnyResolvedKeyframe | undefined;
+  vertOriginY?: AnyResolvedKeyframe | undefined;
+  vHanging?: AnyResolvedKeyframe | undefined;
+  vIdeographic?: AnyResolvedKeyframe | undefined;
+  viewBox?: string | undefined;
+  viewTarget?: AnyResolvedKeyframe | undefined;
+  visibility?: AnyResolvedKeyframe | undefined;
+  vMathematical?: AnyResolvedKeyframe | undefined;
+  widths?: AnyResolvedKeyframe | undefined;
+  wordSpacing?: AnyResolvedKeyframe | undefined;
+  writingMode?: AnyResolvedKeyframe | undefined;
+  x1?: AnyResolvedKeyframe | undefined;
+  x2?: AnyResolvedKeyframe | undefined;
+  x?: AnyResolvedKeyframe | undefined;
+  xChannelSelector?: string | undefined;
+  xHeight?: AnyResolvedKeyframe | undefined;
+  xlinkActuate?: string | undefined;
+  xlinkArcrole?: string | undefined;
+  xlinkHref?: string | undefined;
+  xlinkRole?: string | undefined;
+  xlinkShow?: string | undefined;
+  xlinkTitle?: string | undefined;
+  xlinkType?: string | undefined;
+  xmlBase?: string | undefined;
+  xmlLang?: string | undefined;
+  xmlns?: string | undefined;
+  xmlnsXlink?: string | undefined;
+  xmlSpace?: string | undefined;
+  y1?: AnyResolvedKeyframe | undefined;
+  y2?: AnyResolvedKeyframe | undefined;
+  y?: AnyResolvedKeyframe | undefined;
+  yChannelSelector?: string | undefined;
+  z?: AnyResolvedKeyframe | undefined;
+  zoomAndPan?: string | undefined;
+}
+/**
+ * An update function. It accepts a timestamp used to advance the animation.
+ */
+type Update$1 = (timestamp: number) => void;
+/**
+ * Drivers accept a update function and call it at an interval. This interval
+ * could be a synchronous loop, a setInterval, or tied to the device's framerate.
+ */
+interface DriverControls {
+  start: (keepAlive?: boolean) => void;
+  stop: () => void;
+  now: () => number;
+}
+type Driver = (update: Update$1) => DriverControls;
+/**
+ * Temporary subset of VisualElement until VisualElement is
+ * moved to motion-dom
+ */
+type AnyResolvedKeyframe = string | number;
+interface ProgressTimeline {
+  currentTime: null | {
+    value: number;
+  };
+  cancel?: VoidFunction;
+}
+interface TimelineWithFallback {
+  timeline?: ProgressTimeline;
+  rangeStart?: string;
+  rangeEnd?: string;
+  observe: (animation: AnimationPlaybackControls) => VoidFunction;
+}
+/**
+ * Methods to control an animation.
+ */
+interface AnimationPlaybackControls {
+  /**
+   * The current time of the animation, in seconds.
+   */
+  time: number;
+  /**
+   * The playback speed of the animation.
+   * 1 = normal speed, 2 = double speed, 0.5 = half speed.
+   */
+  speed: number;
+  /**
+   * The start time of the animation, in milliseconds.
+   */
+  startTime: number | null;
+  /**
+   * The state of the animation.
+   *
+   * This is currently for internal use only.
+   */
+  state: AnimationPlayState;
+  duration: number;
+  /**
+   * The duration of the animation, including any delay.
+   */
+  iterationDuration: number;
+  /**
+   * Stops the animation at its current state, and prevents it from
+   * resuming when the animation is played again.
+   */
+  stop: () => void;
+  /**
+   * Plays the animation.
+   */
+  play: () => void;
+  /**
+   * Pauses the animation.
+   */
+  pause: () => void;
+  /**
+   * Completes the animation and applies the final state.
+   */
+  complete: () => void;
+  /**
+   * Cancels the animation and applies the initial state.
+   */
+  cancel: () => void;
+  /**
+   * Attaches a timeline to the animation, for instance the `ScrollTimeline`.
+   *
+   * This is currently for internal use only.
+   */
+  attachTimeline: (timeline: TimelineWithFallback) => VoidFunction;
+  finished: Promise<any>;
+}
+type AnimationPlaybackControlsWithThen = AnimationPlaybackControls & {
+  then: (onResolve: VoidFunction, onReject?: VoidFunction) => Promise<void>;
+};
+interface AnimationState$1<V> {
+  value: V;
+  done: boolean;
+}
+interface KeyframeGenerator<V> {
+  calculatedDuration: null | number;
+  next: (t: number) => AnimationState$1<V>;
+  velocity?: (t: number) => number;
+  toString: () => string;
+}
+interface ValueAnimationOptions<V extends AnyResolvedKeyframe = number> extends ValueAnimationTransition {
+  keyframes: V[];
+  element?: any;
+  name?: string;
+  motionValue?: MotionValue<V>;
+  from?: any;
+  isHandoff?: boolean;
+  allowFlatten?: boolean;
+  finalKeyframe?: V;
+}
+type GeneratorFactoryFunction = (options: ValueAnimationOptions<any>) => KeyframeGenerator<any>;
+interface GeneratorFactory extends GeneratorFactoryFunction {
+  applyToOptions?: (options: Transition) => Transition;
+}
+type AnimationGeneratorName = "decay" | "spring" | "keyframes" | "tween" | "inertia";
+type AnimationGeneratorType = GeneratorFactory | AnimationGeneratorName | false;
+interface AnimationPlaybackLifecycles<V> {
+  onUpdate?: (latest: V) => void;
+  onPlay?: () => void;
+  onComplete?: () => void;
+  onRepeat?: () => void;
+  onStop?: () => void;
+}
+interface ValueAnimationTransition<V = any> extends ValueTransition, AnimationPlaybackLifecycles<V> {
+  isSync?: boolean;
+}
+type RepeatType = "loop" | "reverse" | "mirror";
+interface AnimationPlaybackOptions {
+  /**
+   * The number of times to repeat the transition. Set to `Infinity` for perpetual repeating.
+   *
+   * Without setting `repeatType`, this will loop the animation.
+   *
+   * @public
+   */
+  repeat?: number;
+  /**
+   * How to repeat the animation. This can be either:
+   *
+   * "loop": Repeats the animation from the start
+   *
+   * "reverse": Alternates between forward and backwards playback
+   *
+   * "mirror": Switches `from` and `to` alternately
+   *
+   * @public
+   */
+  repeatType?: RepeatType;
+  /**
+   * When repeating an animation, `repeatDelay` will set the
+   * duration of the time to wait, in seconds, between each repetition.
+   *
+   * @public
+   */
+  repeatDelay?: number;
+}
+interface VelocityOptions {
+  velocity?: number;
+  /**
+   * End animation if absolute speed (in units per second) drops below this
+   * value and delta is smaller than `restDelta`. Set to `0.01` by default.
+   *
+   * @public
+   */
+  restSpeed?: number;
+  /**
+   * End animation if distance is below this value and speed is below
+   * `restSpeed`. When animation ends, spring gets "snapped" to. Set to
+   * `0.01` by default.
+   *
+   * @public
+   */
+  restDelta?: number;
+}
+interface DurationSpringOptions {
+  /**
+   * The total duration of the animation. Set to `0.3` by default.
+   *
+   * @public
+   */
+  duration?: number;
+  /**
+   * If visualDuration is set, this will override duration.
+   *
+   * The visual duration is a time, set in seconds, that the animation will take to visually appear to reach its target.
+   *
+   * In other words, the bulk of the transition will occur before this time, and the "bouncy bit" will mostly happen after.
+   *
+   * This makes it easier to edit a spring, as well as visually coordinate it with other time-based animations.
+   *
+   * @public
+   */
+  visualDuration?: number;
+  /**
+   * `bounce` determines the "bounciness" of a spring animation.
+   *
+   * `0` is no bounce, and `1` is extremely bouncy.
+   *
+   * If `duration` is set, this defaults to `0.25`.
+   *
+   * Note: `bounce` and `duration` will be overridden if `stiffness`, `damping` or `mass` are set.
+   *
+   * @public
+   */
+  bounce?: number;
+}
+interface SpringOptions extends DurationSpringOptions, VelocityOptions {
+  /**
+   * Stiffness of the spring. Higher values will create more sudden movement.
+   * Set to `100` by default.
+   *
+   * @public
+   */
+  stiffness?: number;
+  /**
+   * Strength of opposing force. If set to 0, spring will oscillate
+   * indefinitely. Set to `10` by default.
+   *
+   * @public
+   */
+  damping?: number;
+  /**
+   * Mass of the moving object. Higher values will result in more lethargic
+   * movement. Set to `1` by default.
+   *
+   * @public
+   */
+  mass?: number;
+}
+/**
+ * @deprecated Use SpringOptions instead
+ */
+interface DecayOptions extends VelocityOptions {
+  keyframes?: number[];
+  /**
+   * A higher power value equals a further target. Set to `0.8` by default.
+   *
+   * @public
+   */
+  power?: number;
+  /**
+   * Adjusting the time constant will change the duration of the
+   * deceleration, thereby affecting its feel. Set to `700` by default.
+   *
+   * @public
+   */
+  timeConstant?: number;
+  /**
+   * A function that receives the automatically-calculated target and returns a new one. Useful for snapping the target to a grid.
+   *
+   * @public
+   */
+  modifyTarget?: (v: number) => number;
+}
+interface InertiaOptions extends DecayOptions {
+  /**
+   * If `min` or `max` is set, this affects the stiffness of the bounce
+   * spring. Higher values will create more sudden movement. Set to `500` by
+   * default.
+   *
+   * @public
+   */
+  bounceStiffness?: number;
+  /**
+   * If `min` or `max` is set, this affects the damping of the bounce spring.
+   * If set to `0`, spring will oscillate indefinitely. Set to `10` by
+   * default.
+   *
+   * @public
+   */
+  bounceDamping?: number;
+  /**
+   * 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).
+   *
+   * @public
+   */
+  min?: number;
+  /**
+   * Maximum constraint. If set, the value will "bump" against this value (or immediately snap to it, if the initial animation value exceeds this value).
+   *
+   * @public
+   */
+  max?: number;
+}
+interface AnimationOrchestrationOptions {
+  /**
+   * Delay the animation by this duration (in seconds). Defaults to `0`.
+   *
+   * @public
+   */
+  delay?: number;
+  /**
+   * Describes the relationship between the transition and its children. Set
+   * to `false` by default.
+   *
+   * @remarks
+   * When using variants, the transition can be scheduled in relation to its
+   * children with either `"beforeChildren"` to finish this transition before
+   * starting children transitions, `"afterChildren"` to finish children
+   * transitions before starting this transition.
+   *
+   * @public
+   */
+  when?: false | "beforeChildren" | "afterChildren" | string;
+  /**
+   * When using variants, children animations will start after this duration
+   * (in seconds). You can add the `transition` property to both the `motion.div` and the
+   * `variant` directly. Adding it to the `variant` generally offers more flexibility,
+   * as it allows you to customize the delay per visual state.
+   *
+   * @public
+   */
+  delayChildren?: number | DynamicOption<number>;
+  /**
+   * When using variants, animations of child components can be staggered by this
+   * duration (in seconds).
+   *
+   * For instance, if `staggerChildren` is `0.01`, the first child will be
+   * delayed by `0` seconds, the second by `0.01`, the third by `0.02` and so
+   * on.
+   *
+   * The calculated stagger delay will be added to `delayChildren`.
+   *
+   * @deprecated - Use `delayChildren: stagger(interval)` instead.
+   */
+  staggerChildren?: number;
+  /**
+   * The direction in which to stagger children.
+   *
+   * A value of `1` staggers from the first to the last while `-1`
+   * staggers from the last to the first.
+   *
+   * @deprecated - Use `delayChildren: stagger(interval, { from: "last" })` instead.
+   */
+  staggerDirection?: number;
+}
+interface KeyframeOptions {
+  /**
+   * The total duration of the animation. Set to `0.3` by default.
+   *
+   * @public
+   */
+  duration?: number;
+  ease?: Easing | Easing[];
+  times?: number[];
+}
+interface ValueTransition extends AnimationOrchestrationOptions, AnimationPlaybackOptions, Omit<SpringOptions, "keyframes">, Omit<InertiaOptions, "keyframes">, KeyframeOptions {
+  /**
+   * Delay the animation by this duration (in seconds). Defaults to `0`.
+   *
+   * @public
+   */
+  delay?: number;
+  /**
+   * The duration of time already elapsed in the animation. Set to `0` by
+   * default.
+   */
+  elapsed?: number;
+  driver?: Driver;
+  /**
+   * Type of animation to use.
+   *
+   * - "tween": Duration-based animation with ease curve
+   * - "spring": Physics or duration-based spring animation
+   * - false: Use an instant animation
+   */
+  type?: AnimationGeneratorType;
+  /**
+   * The duration of the tween animation. Set to `0.3` by default, 0r `0.8` if animating a series of keyframes.
+   *
+   * @public
+   */
+  duration?: number;
+  autoplay?: boolean;
+  startTime?: number;
+  from?: any;
+  /**
+   * If true, this transition will shallow-merge with its parent transition
+   * instead of replacing it. Inner keys win.
+   *
+   * @public
+   */
+  inherit?: boolean;
+}
+/**
+ * @deprecated Use KeyframeOptions instead
+ */
+type SVGForcedAttrTransitions = { [K in keyof SVGForcedAttrProperties]: ValueTransition };
+type SVGPathTransitions = { [K in keyof SVGPathProperties]: ValueTransition };
+type SVGTransitions = { [K in keyof Omit<SVGAttributes, "from">]: ValueTransition };
+interface VariableTransitions {
+  [key: `--${string}`]: ValueTransition;
+}
+type StyleTransitions = { [K in keyof CSSStyleDeclarationWithTransform]?: ValueTransition };
+type CSSPropertyKeys = { [K in keyof CSSStyleDeclaration as K extends string ? CSSStyleDeclaration[K] extends AnyResolvedKeyframe ? K : never : never]: CSSStyleDeclaration[K] };
+interface CSSStyleDeclarationWithTransform extends Omit<CSSPropertyKeys, "direction" | "transition" | "x" | "y" | "z"> {
+  x: number | string;
+  y: number | string;
+  z: number | string;
+  originX: number;
+  originY: number;
+  originZ: number;
+  translateX: number | string;
+  translateY: number | string;
+  translateZ: number | string;
+  rotateX: number | string;
+  rotateY: number | string;
+  rotateZ: number | string;
+  scaleX: number;
+  scaleY: number;
+  scaleZ: number;
+  skewX: number | string;
+  skewY: number | string;
+  transformPerspective: number;
+}
+type TransitionWithValueOverrides<V> = ValueAnimationTransition<V> & StyleTransitions & SVGPathTransitions & SVGForcedAttrTransitions & SVGTransitions & VariableTransitions & {
+  default?: ValueTransition;
+  layout?: ValueTransition;
+};
+type Transition<V = any> = ValueAnimationTransition<V> | TransitionWithValueOverrides<V>;
+type DynamicOption<T> = (i: number, total: number) => T;
+interface TransformProperties {
+  x?: AnyResolvedKeyframe;
+  y?: AnyResolvedKeyframe;
+  z?: AnyResolvedKeyframe;
+  translateX?: AnyResolvedKeyframe;
+  translateY?: AnyResolvedKeyframe;
+  translateZ?: AnyResolvedKeyframe;
+  rotate?: AnyResolvedKeyframe;
+  rotateX?: AnyResolvedKeyframe;
+  rotateY?: AnyResolvedKeyframe;
+  rotateZ?: AnyResolvedKeyframe;
+  scale?: AnyResolvedKeyframe;
+  scaleX?: AnyResolvedKeyframe;
+  scaleY?: AnyResolvedKeyframe;
+  scaleZ?: AnyResolvedKeyframe;
+  skew?: AnyResolvedKeyframe;
+  skewX?: AnyResolvedKeyframe;
+  skewY?: AnyResolvedKeyframe;
+  originX?: AnyResolvedKeyframe;
+  originY?: AnyResolvedKeyframe;
+  originZ?: AnyResolvedKeyframe;
+  perspective?: AnyResolvedKeyframe;
+  transformPerspective?: AnyResolvedKeyframe;
+}
+interface SVGForcedAttrProperties {
+  attrX?: number;
+  attrY?: number;
+  attrScale?: number;
+}
+interface SVGPathProperties {
+  pathLength?: number;
+  pathOffset?: number;
+  pathSpacing?: number;
+}
+/**
+ * @public
+ */
+type Subscriber<T> = (v: T) => void;
+/**
+ * @public
+ */
+type PassiveEffect<T> = (v: T, safeSetter: (v: T) => void) => void;
+type StartAnimation = (complete: () => void) => AnimationPlaybackControlsWithThen | undefined;
+interface MotionValueEventCallbacks<V> {
+  animationStart: () => void;
+  animationComplete: () => void;
+  animationCancel: () => void;
+  change: (latestValue: V) => void;
+  destroy: () => void;
+}
+interface ResolvedValues {
+  [key: string]: AnyResolvedKeyframe;
+}
+interface Owner {
+  current: HTMLElement | unknown;
+  getProps: () => {
+    onUpdate?: (latest: ResolvedValues) => void;
+    transformTemplate?: (transform: TransformProperties, generatedTransform: string) => string;
+  };
+}
+interface AccelerateConfig {
+  factory: (animation: AnimationPlaybackControlsWithThen) => VoidFunction;
+  times: number[];
+  keyframes: any[];
+  ease?: EasingFunction | EasingFunction[];
+  duration: number;
+  isTransformed?: boolean;
+}
+interface MotionValueOptions {
+  owner?: Owner;
+}
+/**
+ * `MotionValue` is used to track the state and velocity of motion values.
+ *
+ * @public
+ */
+declare class MotionValue<V = any> {
+  /**
+   * If a MotionValue has an owner, it was created internally within Motion
+   * and therefore has no external listeners. It is therefore safe to animate via WAAPI.
+   */
+  owner?: Owner;
+  /**
+   * The current state of the `MotionValue`.
+   */
+  private current;
+  /**
+   * The previous state of the `MotionValue`.
+   */
+  private prev;
+  /**
+   * The previous state of the `MotionValue` at the end of the previous frame.
+   */
+  private prevFrameValue;
+  /**
+   * The last time the `MotionValue` was updated.
+   */
+  updatedAt: number;
+  /**
+   * The time `prevFrameValue` was updated.
+   */
+  prevUpdatedAt: number | undefined;
+  private stopPassiveEffect?;
+  /**
+   * Whether the passive effect is active.
+   */
+  isEffectActive?: boolean;
+  /**
+   * A reference to the currently-controlling animation.
+   */
+  animation?: AnimationPlaybackControlsWithThen;
+  /**
+   * A list of MotionValues whose values are computed from this one.
+   * This is a rough start to a proper signal-like dirtying system.
+   */
+  private dependents;
+  /**
+   * Tracks whether this value should be removed
+   */
+  liveStyle?: boolean;
+  /**
+   * Scroll timeline acceleration metadata. When set, VisualElement
+   * can create a native WAAPI animation attached to a scroll timeline
+   * instead of driving updates through JS.
+   */
+  accelerate?: AccelerateConfig;
+  /**
+   * @param init - The initiating value
+   * @param config - Optional configuration options
+   *
+   * -  `transformer`: A function to transform incoming values with.
+   */
+  constructor(init: V, options?: MotionValueOptions);
+  setCurrent(current: V): void;
+  setPrevFrameValue(prevFrameValue?: V | undefined): void;
+  /**
+   * Adds a function that will be notified when the `MotionValue` is updated.
+   *
+   * It returns a function that, when called, will cancel the subscription.
+   *
+   * When calling `onChange` inside a React component, it should be wrapped with the
+   * `useEffect` hook. As it returns an unsubscribe function, this should be returned
+   * from the `useEffect` function to ensure you don't add duplicate subscribers..
+   *
+   * ```jsx
+   * export const MyComponent = () => {
+   *   const x = useMotionValue(0)
+   *   const y = useMotionValue(0)
+   *   const opacity = useMotionValue(1)
+   *
+   *   useEffect(() => {
+   *     function updateOpacity() {
+   *       const maxXY = Math.max(x.get(), y.get())
+   *       const newOpacity = transform(maxXY, [0, 100], [1, 0])
+   *       opacity.set(newOpacity)
+   *     }
+   *
+   *     const unsubscribeX = x.on("change", updateOpacity)
+   *     const unsubscribeY = y.on("change", updateOpacity)
+   *
+   *     return () => {
+   *       unsubscribeX()
+   *       unsubscribeY()
+   *     }
+   *   }, [])
+   *
+   *   return <motion.div style={{ x }} />
+   * }
+   * ```
+   *
+   * @param subscriber - A function that receives the latest value.
+   * @returns A function that, when called, will cancel this subscription.
+   *
+   * @deprecated
+   */
+  onChange(subscription: Subscriber<V>): () => void;
+  /**
+   * An object containing a SubscriptionManager for each active event.
+   */
+  private events;
+  on<EventName extends keyof MotionValueEventCallbacks<V>>(eventName: EventName, callback: MotionValueEventCallbacks<V>[EventName]): VoidFunction;
+  clearListeners(): void;
+  /**
+   * Attaches a passive effect to the `MotionValue`.
+   */
+  attach(passiveEffect: PassiveEffect<V>, stopPassiveEffect: VoidFunction): void;
+  /**
+   * Sets the state of the `MotionValue`.
+   *
+   * @remarks
+   *
+   * ```jsx
+   * const x = useMotionValue(0)
+   * x.set(10)
+   * ```
+   *
+   * @param latest - Latest value to set.
+   * @param render - Whether to notify render subscribers. Defaults to `true`
+   *
+   * @public
+   */
+  set(v: V): void;
+  setWithVelocity(prev: V, current: V, delta: number): void;
+  /**
+   * Set the state of the `MotionValue`, stopping any active animations,
+   * effects, and resets velocity to `0`.
+   */
+  jump(v: V, endAnimation?: boolean): void;
+  dirty(): void;
+  addDependent(dependent: MotionValue): void;
+  removeDependent(dependent: MotionValue): void;
+  updateAndNotify: (v: V) => void;
+  /**
+   * Returns the latest state of `MotionValue`
+   *
+   * @returns - The latest state of `MotionValue`
+   *
+   * @public
+   */
+  get(): NonNullable<V>;
+  /**
+   * @public
+   */
+  getPrevious(): V | undefined;
+  /**
+   * Returns the latest velocity of `MotionValue`
+   *
+   * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.
+   *
+   * @public
+   */
+  getVelocity(): number;
+  hasAnimated: boolean;
+  /**
+   * Registers a new animation to control this `MotionValue`. Only one
+   * animation can drive a `MotionValue` at one time.
+   *
+   * ```jsx
+   * value.start()
+   * ```
+   *
+   * @param animation - A function that starts the provided animation
+   */
+  start(startAnimation: StartAnimation): Promise<void>;
+  /**
+   * Stop the currently active animation.
+   *
+   * @public
+   */
+  stop(): void;
+  /**
+   * Returns `true` if this value is currently animating.
+   *
+   * @public
+   */
+  isAnimating(): boolean;
+  private clearAnimation;
+  /**
+   * Destroy and clean up subscribers to this `MotionValue`.
+   *
+   * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically
+   * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually
+   * created a `MotionValue` via the `motionValue` function.
+   *
+   * @public
+   */
+  destroy(): void;
+}
+declare const optimizedAppearDataAttribute: "data-framer-appear-id";
+type Process = (data: FrameData) => void;
+type Schedule = (process: Process, keepAlive?: boolean, immediate?: boolean) => Process;
+type StepId = "setup" | "read" | "resolveKeyframes" | "preUpdate" | "update" | "preRender" | "render" | "postRender";
+type Batcher = { [key in StepId]: Schedule };
+interface FrameData {
+  delta: number;
+  timestamp: number;
+  isProcessing: boolean;
+}
+/**
+ * Expose only the needed part of the VisualElement interface to
+ * ensure React types don't end up in the generic DOM bundle.
+ */
+interface WithAppearProps {
+  props: {
+    [optimizedAppearDataAttribute]?: string;
+    values?: {
+      [key: string]: MotionValue<number> | MotionValue<string>;
+    };
+  };
+}
+type HandoffFunction = (storeId: string, valueName: string, frame: Batcher) => number | null;
+/**
+ * The window global object acts as a bridge between our inline script
+ * triggering the optimized appear animations, and Motion.
+ */
+declare global {
+  interface Window {
+    MotionHandoffAnimation?: HandoffFunction;
+    MotionHandoffMarkAsComplete?: (elementId: string) => void;
+    MotionHandoffIsComplete?: (elementId: string) => boolean;
+    MotionHasOptimisedAnimation?: (elementId?: string, valueName?: string) => boolean;
+    MotionCancelOptimisedAnimation?: (elementId?: string, valueName?: string, frame?: Batcher, canResume?: boolean) => void;
+    MotionCheckAppearSync?: (visualElement: WithAppearProps, valueName: string, value: MotionValue) => VoidFunction | void;
+    MotionIsMounted?: boolean;
+  }
+}
+declare global {
+  interface Window {
+    ScrollTimeline: ScrollTimeline;
+    ViewTimeline: ViewTimeline;
+  }
+}
+declare class ScrollTimeline implements ProgressTimeline {
+  constructor(options: ScrollOptions);
+  currentTime: null | {
+    value: number;
+  };
+  cancel?: VoidFunction;
+}
+declare class ViewTimeline implements ProgressTimeline {
+  constructor(options: {
+    subject: Element;
+    axis?: string;
+  });
+  currentTime: null | {
+    value: number;
+  };
+  cancel?: VoidFunction;
+}
+//#endregion
+export { type AccelerateConfig, type AnimationGeneratorName, type AnimationGeneratorType, type AnimationOrchestrationOptions, type AnimationPlaybackControls, type AnimationPlaybackControlsWithThen, type AnimationPlaybackLifecycles, type AnimationPlaybackOptions, type AnyResolvedKeyframe, type Batcher, type CSSStyleDeclarationWithTransform, type DecayOptions, type DurationSpringOptions, type DynamicOption, type FrameData, type GeneratorFactory, type GeneratorFactoryFunction, type HandoffFunction, type InertiaOptions, type KeyframeGenerator, type KeyframeOptions, MotionValue, type MotionValueEventCallbacks, type MotionValueOptions, type Owner, type PassiveEffect, type Process, type ProgressTimeline, type RepeatType, type SVGAttributes, type SVGForcedAttrProperties, type SVGForcedAttrTransitions, type SVGPathProperties, type SVGPathTransitions, type SVGTransitions, type Schedule, type SpringOptions, type StartAnimation, type StepId, type StyleTransitions, type Subscriber, type TimelineWithFallback, type TransformProperties, type Transition, type TransitionWithValueOverrides, type ValueAnimationOptions, type ValueAnimationTransition, type ValueTransition, type VariableTransitions, type VelocityOptions, type WithAppearProps, optimizedAppearDataAttribute };
+//# sourceMappingURL=index.d.ts.map