// Signature format: 3.0
package androidx.animation {

  public abstract class AnimatedFloat extends androidx.animation.BaseAnimatedValue<java.lang.Float,androidx.animation.AnimationVector1D> {
    ctor public AnimatedFloat(androidx.animation.AnimationClockObservable clock, float visibilityThreshold);
    method public final float getMax();
    method public final float getMin();
    method public final float getVelocity();
    method public final void setBounds(float min = Float.NEGATIVE_INFINITY, float max = Float.POSITIVE_INFINITY);
    method public void snapTo(float targetValue);
    property public final float max;
    property public final float min;
    property public final float velocity;
  }

  public abstract class AnimatedValue<T, V extends androidx.animation.AnimationVector> extends androidx.animation.BaseAnimatedValue<T,V> {
    ctor public AnimatedValue(androidx.animation.TwoWayConverter<T,V> typeConverter, androidx.animation.AnimationClockObservable clock, T? visibilityThreshold);
    method public final V getVelocity();
    property public final V velocity;
  }

  public final class AnimatedValueKt {
    method public static androidx.animation.AnimatedFloat AnimatedFloat(float initVal, androidx.animation.AnimationClockObservable clock, float visibilityThreshold = 0.01f);
    method public static <T, V extends androidx.animation.AnimationVector> androidx.animation.AnimatedValue<T,V> AnimatedValue(T? initVal, androidx.animation.TwoWayConverter<T,V> typeConverter, androidx.animation.AnimationClockObservable clock, T? visibilityThreshold = null);
    method public static <V extends androidx.animation.AnimationVector> androidx.animation.AnimatedValue<V,V> AnimatedVector(V initVal, androidx.animation.AnimationClockObservable clock, V visibilityThreshold = initVal.newInstanceOfValue(Spring.DefaultDisplacementThreshold));
    method public static void fling(androidx.animation.AnimatedFloat, float startVelocity, androidx.animation.FloatDecayAnimationSpec decay = androidx.animation.ExponentialDecay(), kotlin.jvm.functions.Function3<? super androidx.animation.AnimationEndReason,? super java.lang.Float,? super java.lang.Float,kotlin.Unit>? onEnd = null);
    method public static void fling(androidx.animation.AnimatedFloat, float startVelocity, androidx.animation.FloatDecayAnimationSpec decay = androidx.animation.ExponentialDecay(), kotlin.jvm.functions.Function1<? super java.lang.Float,androidx.animation.TargetAnimation> adjustTarget, kotlin.jvm.functions.Function3<? super androidx.animation.AnimationEndReason,? super java.lang.Float,? super java.lang.Float,kotlin.Unit>? onEnd = null);
  }

  public final class AnimationClockKt {
  }

  public interface AnimationClockObservable {
    method public void subscribe(androidx.animation.AnimationClockObserver observer);
    method public void unsubscribe(androidx.animation.AnimationClockObserver observer);
  }

  public interface AnimationClockObserver {
    method public void onAnimationFrame(long frameTimeMillis);
  }

  public final class AnimationConstants {
    field public static final int DefaultDurationMillis = 300; // 0x12c
    field public static final androidx.animation.AnimationConstants INSTANCE;
    field public static final int Infinite = 2147483647; // 0x7fffffff
  }

  public enum AnimationEndReason {
    method public static androidx.animation.AnimationEndReason valueOf(String name) throws java.lang.IllegalArgumentException;
    method public static androidx.animation.AnimationEndReason[] values();
    enum_constant public static final androidx.animation.AnimationEndReason BoundReached;
    enum_constant public static final androidx.animation.AnimationEndReason Interrupted;
    enum_constant public static final androidx.animation.AnimationEndReason TargetReached;
  }

  public final class AnimationKt {
  }

  public interface AnimationSpec<T> {
    method public <V extends androidx.animation.AnimationVector> androidx.animation.VectorizedAnimationSpec<V> vectorize(androidx.animation.TwoWayConverter<T,V> converter);
  }

  public final class AnimationSpecKt {
  }

  public abstract sealed class AnimationVector {
  }

  public final class AnimationVector1D extends androidx.animation.AnimationVector {
    ctor public AnimationVector1D(float initVal);
    method public float get$lintWithKotlin(int index);
    method public int getSize$lintWithKotlin();
    method public float getValue();
    method public androidx.animation.AnimationVector1D newVector$lintWithKotlin();
    method public void reset$lintWithKotlin();
    method public void set$lintWithKotlin(int index, float value);
    property public int size;
    property public final float value;
  }

  public final class AnimationVector2D extends androidx.animation.AnimationVector {
    ctor public AnimationVector2D(float v1, float v2);
    method public float get$lintWithKotlin(int index);
    method public int getSize$lintWithKotlin();
    method public float getV1();
    method public float getV2();
    method public androidx.animation.AnimationVector2D newVector$lintWithKotlin();
    method public void reset$lintWithKotlin();
    method public void set$lintWithKotlin(int index, float value);
    property public int size;
    property public final float v1;
    property public final float v2;
  }

  public final class AnimationVector3D extends androidx.animation.AnimationVector {
    ctor public AnimationVector3D(float v1, float v2, float v3);
    method public float get$lintWithKotlin(int index);
    method public int getSize$lintWithKotlin();
    method public float getV1();
    method public float getV2();
    method public float getV3();
    method public androidx.animation.AnimationVector3D newVector$lintWithKotlin();
    method public void reset$lintWithKotlin();
    method public void set$lintWithKotlin(int index, float value);
    property public int size;
    property public final float v1;
    property public final float v2;
    property public final float v3;
  }

  public final class AnimationVector4D extends androidx.animation.AnimationVector {
    ctor public AnimationVector4D(float v1, float v2, float v3, float v4);
    method public float get$lintWithKotlin(int index);
    method public int getSize$lintWithKotlin();
    method public float getV1();
    method public float getV2();
    method public float getV3();
    method public float getV4();
    method public androidx.animation.AnimationVector4D newVector$lintWithKotlin();
    method public void reset$lintWithKotlin();
    method public void set$lintWithKotlin(int index, float value);
    property public int size;
    property public final float v1;
    property public final float v2;
    property public final float v3;
    property public final float v4;
  }

  public final class AnimationVectorsKt {
    method public static androidx.animation.AnimationVector1D AnimationVector(float v1);
    method public static androidx.animation.AnimationVector2D AnimationVector(float v1, float v2);
    method public static androidx.animation.AnimationVector3D AnimationVector(float v1, float v2, float v3);
    method public static androidx.animation.AnimationVector4D AnimationVector(float v1, float v2, float v3, float v4);
  }

  public abstract sealed class BaseAnimatedValue<T, V extends androidx.animation.AnimationVector> {
    method public final void animateTo(T? targetValue, androidx.animation.AnimationSpec<T> anim = androidx.animation.BaseAnimatedValue.defaultSpringSpec, kotlin.jvm.functions.Function2<? super androidx.animation.AnimationEndReason,? super T,kotlin.Unit>? onEnd = null);
    method protected void checkFinished(long playtime);
    method public final T! getTargetValue();
    method public abstract T! getValue();
    method public final boolean isRunning();
    method protected abstract void setValue(T! p);
    method public void snapTo(T? targetValue);
    method public final void stop();
    property public final boolean isRunning;
    property public final T! targetValue;
    property public abstract T! value;
  }

  public abstract class BaseAnimationClock implements androidx.animation.AnimationClockObservable {
    ctor public BaseAnimationClock();
    method public void subscribe(androidx.animation.AnimationClockObserver observer);
    method public void unsubscribe(androidx.animation.AnimationClockObserver observer);
    field @Deprecated public static final androidx.animation.BaseAnimationClock.Companion Companion;
  }

  public final class ComplexDoubleKt {
  }

  public final class CubicBezierEasing implements kotlin.jvm.functions.Function1<java.lang.Float,java.lang.Float> {
    ctor public CubicBezierEasing(float a, float b, float c, float d);
    method public Float! invoke(float fraction);
  }

  public final class DefaultAnimationClock extends androidx.animation.BaseAnimationClock {
    ctor public DefaultAnimationClock();
    method public void dispatchTime$lintWithKotlin(long frameTimeMillis);
  }

  public interface DurationBasedAnimationSpec<T> extends androidx.animation.AnimationSpec<T> {
    method public <V extends androidx.animation.AnimationVector> androidx.animation.VectorizedDurationBasedAnimationSpec<V> vectorize(androidx.animation.TwoWayConverter<T,V> converter);
  }

  public final class EasingKt {
    method public static androidx.animation.CubicBezierEasing getFastOutLinearInEasing();
    method public static androidx.animation.CubicBezierEasing getFastOutSlowInEasing();
    method public static kotlin.jvm.functions.Function1<java.lang.Float,java.lang.Float> getLinearEasing();
    method public static androidx.animation.CubicBezierEasing getLinearOutSlowInEasing();
  }

  public final class ExponentialDecay implements androidx.animation.FloatDecayAnimationSpec {
    ctor public ExponentialDecay(@FloatRange(from=null, to=null, fromInclusive=null) float frictionMultiplier, @FloatRange(from=null, to=null, fromInclusive=null) float absVelocityThreshold);
    ctor public ExponentialDecay();
    method public float getAbsVelocityThreshold();
    method public long getDurationMillis(float start, float startVelocity);
    method public float getTarget(float start, float startVelocity);
    method public float getValue(long playTime, float start, float startVelocity);
    method public float getVelocity(long playTime, float start, float startVelocity);
    property public float absVelocityThreshold;
  }

  public interface FloatAnimationSpec extends androidx.animation.AnimationSpec<java.lang.Float> {
    method public long getDurationMillis(float start, float end, float startVelocity);
    method public default float getEndVelocity(float start, float end, float startVelocity);
    method public float getValue(long playTime, float start, float end, float startVelocity);
    method public float getVelocity(long playTime, float start, float end, float startVelocity);
    method public default <V extends androidx.animation.AnimationVector> androidx.animation.VectorizedFloatAnimationSpec<V> vectorize(androidx.animation.TwoWayConverter<java.lang.Float,V> converter);
  }

  public interface FloatDecayAnimationSpec {
    method public float getAbsVelocityThreshold();
    method public long getDurationMillis(float start, float startVelocity);
    method public float getTarget(float start, float startVelocity);
    method public float getValue(long playTime, float start, float startVelocity);
    method public float getVelocity(long playTime, float start, float startVelocity);
    property public abstract float absVelocityThreshold;
  }

  public final class FloatDecayAnimationSpecKt {
  }

  public final class FloatPropKey implements androidx.animation.PropKey<java.lang.Float,androidx.animation.AnimationVector1D> {
    ctor public FloatPropKey(String label);
    ctor public FloatPropKey();
    method public androidx.animation.TwoWayConverter<java.lang.Float,androidx.animation.AnimationVector1D> getTypeConverter();
    property public androidx.animation.TwoWayConverter<java.lang.Float,androidx.animation.AnimationVector1D> typeConverter;
  }

  public final class FloatSpringSpec implements androidx.animation.FloatAnimationSpec {
    ctor public FloatSpringSpec(float dampingRatio, float stiffness, float visibilityThreshold);
    ctor public FloatSpringSpec();
    method public float getDampingRatio();
    method public long getDurationMillis(float start, float end, float startVelocity);
    method public float getStiffness();
    method public float getValue(long playTime, float start, float end, float startVelocity);
    method public float getVelocity(long playTime, float start, float end, float startVelocity);
  }

  public final class FloatTweenSpec implements androidx.animation.FloatAnimationSpec {
    ctor public FloatTweenSpec(int duration, int delay, kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Float> easing);
    ctor public FloatTweenSpec();
    method public int getDelay();
    method public int getDuration();
    method public long getDurationMillis(float start, float end, float startVelocity);
    method public float getValue(long playTime, float start, float end, float startVelocity);
    method public float getVelocity(long playTime, float start, float end, float startVelocity);
  }

  public final class IntPropKey implements androidx.animation.PropKey<java.lang.Integer,androidx.animation.AnimationVector1D> {
    ctor public IntPropKey(String label);
    ctor public IntPropKey();
    method public androidx.animation.TwoWayConverter<java.lang.Integer,androidx.animation.AnimationVector1D> getTypeConverter();
    property public androidx.animation.TwoWayConverter<java.lang.Integer,androidx.animation.AnimationVector1D> typeConverter;
  }

  @kotlin.RequiresOptIn(message="This API is internal to library.") @kotlin.annotation.Target(allowedTargets={AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY}) public @interface InternalAnimationApi {
  }

  public enum InterruptionHandling {
    method public static androidx.animation.InterruptionHandling valueOf(String name) throws java.lang.IllegalArgumentException;
    method public static androidx.animation.InterruptionHandling[] values();
    enum_constant public static final androidx.animation.InterruptionHandling PHYSICS;
    enum_constant public static final androidx.animation.InterruptionHandling SNAP_TO_END;
    enum_constant public static final androidx.animation.InterruptionHandling TWEEN;
    enum_constant public static final androidx.animation.InterruptionHandling UNINTERRUPTIBLE;
  }

  public final class KeyframesSpec<T> implements androidx.animation.DurationBasedAnimationSpec<T> {
    ctor public KeyframesSpec(androidx.animation.KeyframesSpec.KeyframesSpecConfig<T> config);
    method public androidx.animation.KeyframesSpec.KeyframesSpecConfig<T> getConfig();
    method public <V extends androidx.animation.AnimationVector> androidx.animation.VectorizedKeyframesSpec<V> vectorize(androidx.animation.TwoWayConverter<T,V> converter);
  }

  public static final class KeyframesSpec.KeyframeEntity<T> {
  }

  public static final class KeyframesSpec.KeyframesSpecConfig<T> {
    ctor public KeyframesSpec.KeyframesSpecConfig();
    method public infix androidx.animation.KeyframesSpec.KeyframeEntity<T> at(T?, @IntRange(from=0) int timeStamp);
    method public int getDelayMillis();
    method public int getDurationMillis();
    method public void setDelayMillis(int p);
    method public void setDurationMillis(int p);
    method public infix void with(androidx.animation.KeyframesSpec.KeyframeEntity<T>, kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Float> easing);
    property public final int delayMillis;
    property public final int durationMillis;
  }

  public final class ManualAnimationClock extends androidx.animation.BaseAnimationClock {
    ctor public ManualAnimationClock(long initTimeMillis, boolean dispatchOnSubscribe);
    method public long getClockTimeMillis();
    method public boolean getHasObservers();
    method public void setClockTimeMillis(long value);
    property public final long clockTimeMillis;
    property public final boolean hasObservers;
  }

  public interface MutableTransitionState {
    method public operator <T, V extends androidx.animation.AnimationVector> void set(androidx.animation.PropKey<T,V> propKey, T? prop);
  }

  public interface PropKey<T, V extends androidx.animation.AnimationVector> {
    method public default String getLabel();
    method public androidx.animation.TwoWayConverter<T,V> getTypeConverter();
    property public default String label;
    property public abstract androidx.animation.TwoWayConverter<T,V> typeConverter;
  }

  public final class PropKeyKt {
    method public static <T, V extends androidx.animation.AnimationVector> androidx.animation.TwoWayConverter<T,V> TwoWayConverter(kotlin.jvm.functions.Function1<? super T,? extends V> convertToVector, kotlin.jvm.functions.Function1<? super V,? extends T> convertFromVector);
    method public static androidx.animation.TwoWayConverter<java.lang.Float,androidx.animation.AnimationVector1D> getFloatToVectorConverter();
    method public static androidx.animation.TwoWayConverter<java.lang.Integer,androidx.animation.AnimationVector1D> getIntToVectorConverter();
  }

  public final class RepeatableSpec<T> implements androidx.animation.AnimationSpec<T> {
    ctor public RepeatableSpec(int iterations, androidx.animation.DurationBasedAnimationSpec<T> animation);
    method public androidx.animation.DurationBasedAnimationSpec<T> getAnimation();
    method public int getIterations();
    method public <V extends androidx.animation.AnimationVector> androidx.animation.VectorizedAnimationSpec<V> vectorize(androidx.animation.TwoWayConverter<T,V> converter);
  }

  public final class SnapSpec<T> implements androidx.animation.AnimationSpec<T> {
    ctor public SnapSpec(int delay);
    ctor public SnapSpec();
    method public int getDelay();
    method public <V extends androidx.animation.AnimationVector> androidx.animation.VectorizedDurationBasedAnimationSpec<V> vectorize(androidx.animation.TwoWayConverter<T,V> converter);
  }

  public final class Spring {
    field public static final float DampingRatioHighBouncy = 0.2f;
    field public static final float DampingRatioLowBouncy = 0.75f;
    field public static final float DampingRatioMediumBouncy = 0.5f;
    field public static final float DampingRatioNoBouncy = 1.0f;
    field public static final float DefaultDisplacementThreshold = 0.01f;
    field public static final androidx.animation.Spring INSTANCE;
    field public static final float StiffnessHigh = 10000.0f;
    field public static final float StiffnessLow = 200.0f;
    field public static final float StiffnessMedium = 1500.0f;
    field public static final float StiffnessVeryLow = 50.0f;
  }

  public final class SpringEstimationKt {
  }

  public final class SpringSimulationKt {
  }

  public final class SpringSpec<T> implements androidx.animation.AnimationSpec<T> {
    ctor public SpringSpec(float dampingRatio, float stiffness, T? visibilityThreshold);
    ctor public SpringSpec();
    method public float getDampingRatio();
    method public float getStiffness();
    method public T? getVisibilityThreshold();
    method public <V extends androidx.animation.AnimationVector> androidx.animation.VectorizedSpringSpec<V> vectorize(androidx.animation.TwoWayConverter<T,V> converter);
  }

  public final class TargetAnimation {
    ctor public TargetAnimation(float target, androidx.animation.AnimationSpec<java.lang.Float> animation);
    method public float component1();
    method public androidx.animation.AnimationSpec<java.lang.Float> component2();
    method public androidx.animation.TargetAnimation copy(float target, androidx.animation.AnimationSpec<java.lang.Float> animation);
    method public androidx.animation.AnimationSpec<java.lang.Float> getAnimation();
    method public float getTarget();
  }

  public final class ToolingGlueKt {
  }

  public final class TransitionAnimation<T> implements androidx.animation.TransitionState {
    ctor public TransitionAnimation(internal androidx.animation.TransitionDefinition<T> def, androidx.animation.AnimationClockObservable clock, T? initState);
    method public operator <T, V extends androidx.animation.AnimationVector> T! get(androidx.animation.PropKey<T,V> propKey);
    method public kotlin.jvm.functions.Function1<T,kotlin.Unit>? getOnStateChangeFinished();
    method public kotlin.jvm.functions.Function0<kotlin.Unit>? getOnUpdate();
    method public boolean isRunning();
    method public void setOnStateChangeFinished(kotlin.jvm.functions.Function1<? super T,kotlin.Unit>? p);
    method public void setOnUpdate(kotlin.jvm.functions.Function0<kotlin.Unit>? p);
    method public void toState(T? name);
    property public final boolean isRunning;
    property public final kotlin.jvm.functions.Function1<T,kotlin.Unit>? onStateChangeFinished;
    property public final kotlin.jvm.functions.Function0<kotlin.Unit>? onUpdate;
  }

  public final class TransitionAnimationKt {
  }

  public final class TransitionDefinition<T> {
    ctor public TransitionDefinition();
    method public androidx.animation.TransitionState getStateFor(T? name);
    method public void snapTransition(kotlin.Pair<? extends T,? extends T>![] fromToPairs, T? nextState = null);
    method public void state(T? name, kotlin.jvm.functions.Function1<? super androidx.animation.MutableTransitionState,kotlin.Unit> init);
    method public void transition(T? fromState = null, T? toState = null, kotlin.jvm.functions.Function1<? super androidx.animation.TransitionSpec<T>,kotlin.Unit> init);
    method public void transition(kotlin.Pair<? extends T,? extends T>![] fromToPairs, kotlin.jvm.functions.Function1<? super androidx.animation.TransitionSpec<T>,kotlin.Unit> init);
  }

  public final class TransitionDefinitionKt {
    method public static <T> androidx.animation.TransitionAnimation<T> createAnimation(androidx.animation.TransitionDefinition<T>, androidx.animation.AnimationClockObservable clock, T? initState = null);
    method public static <T> androidx.animation.KeyframesSpec<T> keyframes(kotlin.jvm.functions.Function1<? super androidx.animation.KeyframesSpec.KeyframesSpecConfig<T>,kotlin.Unit> init);
    method public static <T> androidx.animation.AnimationSpec<T> repeatable(int iterations, androidx.animation.DurationBasedAnimationSpec<T> animation);
    method public static <T> androidx.animation.AnimationSpec<T> snap(int delayMillis = 0);
    method public static <T> androidx.animation.SpringSpec<T> spring(float dampingRatio = 1.0f, float stiffness = 1500.0f, T? visibilityThreshold = null);
    method public static <T> androidx.animation.TransitionDefinition<T> transitionDefinition(@kotlin.BuilderInference kotlin.jvm.functions.Function1<? super androidx.animation.TransitionDefinition<T>,kotlin.Unit> init);
    method public static <T> androidx.animation.TweenSpec<T> tween(int durationMillis = 300, int delayMillis = 0, kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Float> easing = FastOutSlowInEasing);
  }

  public final class TransitionSpec<S> {
    method public androidx.animation.InterruptionHandling getInterruptionHandling();
    method public S? getNextState();
    method public void setInterruptionHandling(androidx.animation.InterruptionHandling p);
    method public void setNextState(S? p);
    method public infix <T, V extends androidx.animation.AnimationVector> void using(androidx.animation.PropKey<T,V>, androidx.animation.AnimationSpec<T> animationSpec);
    property public final androidx.animation.InterruptionHandling interruptionHandling;
    property public final S? nextState;
  }

  public interface TransitionState {
    method public operator <T, V extends androidx.animation.AnimationVector> T! get(androidx.animation.PropKey<T,V> propKey);
  }

  public final class TweenSpec<T> implements androidx.animation.DurationBasedAnimationSpec<T> {
    ctor public TweenSpec(int durationMillis, int delay, kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Float> easing);
    ctor public TweenSpec();
    method public int getDelay();
    method public int getDurationMillis();
    method public kotlin.jvm.functions.Function1<java.lang.Float,java.lang.Float> getEasing();
    method public <V extends androidx.animation.AnimationVector> androidx.animation.VectorizedTweenSpec<V> vectorize(androidx.animation.TwoWayConverter<T,V> converter);
  }

  public interface TwoWayConverter<T, V extends androidx.animation.AnimationVector> {
    method public kotlin.jvm.functions.Function1<V,T> getConvertFromVector();
    method public kotlin.jvm.functions.Function1<T,V> getConvertToVector();
    property public abstract kotlin.jvm.functions.Function1<V,T> convertFromVector;
    property public abstract kotlin.jvm.functions.Function1<T,V> convertToVector;
  }

  public interface VectorizedAnimationSpec<V extends androidx.animation.AnimationVector> {
    method public long getDurationMillis(V start, V end, V startVelocity);
    method public default V getEndVelocity(V start, V end, V startVelocity);
    method public V getValue(long playTime, V start, V end, V startVelocity);
    method public V getVelocity(long playTime, V start, V end, V startVelocity);
  }

  public final class VectorizedAnimationSpecKt {
  }

  public interface VectorizedDurationBasedAnimationSpec<V extends androidx.animation.AnimationVector> extends androidx.animation.VectorizedAnimationSpec<V> {
    method public int getDelayMillis();
    method public int getDurationMillis();
    method public default long getDurationMillis(V start, V end, V startVelocity);
    property public abstract int delayMillis;
    property public abstract int durationMillis;
  }

  public final class VectorizedFloatAnimationSpec<V extends androidx.animation.AnimationVector> implements androidx.animation.VectorizedAnimationSpec<V> {
    ctor public VectorizedFloatAnimationSpec(androidx.animation.FloatAnimationSpec anim);
    method public long getDurationMillis(V start, V end, V startVelocity);
    method public V getValue(long playTime, V start, V end, V startVelocity);
    method public V getVelocity(long playTime, V start, V end, V startVelocity);
  }

  public final class VectorizedKeyframesSpec<V extends androidx.animation.AnimationVector> implements androidx.animation.VectorizedDurationBasedAnimationSpec<V> {
    ctor public VectorizedKeyframesSpec(java.util.Map<java.lang.Integer,? extends kotlin.Pair<? extends V,? extends kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Float>>> keyframes, int durationMillis, int delayMillis);
    method public int getDelayMillis();
    method public int getDurationMillis();
    method public V getValue(long playTime, V start, V end, V startVelocity);
    method public V getVelocity(long playTime, V start, V end, V startVelocity);
  }

  public final class VectorizedRepeatableSpec<V extends androidx.animation.AnimationVector> implements androidx.animation.VectorizedAnimationSpec<V> {
    ctor public VectorizedRepeatableSpec(int iterations, androidx.animation.VectorizedDurationBasedAnimationSpec<V> animation);
    method public long getDurationMillis(V start, V end, V startVelocity);
    method public V getValue(long playTime, V start, V end, V startVelocity);
    method public V getVelocity(long playTime, V start, V end, V startVelocity);
  }

  public final class VectorizedSnapSpec<V extends androidx.animation.AnimationVector> implements androidx.animation.VectorizedDurationBasedAnimationSpec<V> {
    ctor public VectorizedSnapSpec(int delayMillis);
    ctor public VectorizedSnapSpec();
    method public int getDelayMillis();
    method public int getDurationMillis();
    method public V getValue(long playTime, V start, V end, V startVelocity);
    method public V getVelocity(long playTime, V start, V end, V startVelocity);
    property public int durationMillis;
  }

  public final class VectorizedSpringSpec<V extends androidx.animation.AnimationVector> implements androidx.animation.VectorizedAnimationSpec<V> {
    ctor public VectorizedSpringSpec(float dampingRatio, float stiffness, V? visibilityThreshold);
    method public float getDampingRatio();
    method public float getStiffness();
  }

  public final class VectorizedTweenSpec<V extends androidx.animation.AnimationVector> implements androidx.animation.VectorizedDurationBasedAnimationSpec<V> {
    ctor public VectorizedTweenSpec(int durationMillis, int delayMillis, kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Float> easing);
    ctor public VectorizedTweenSpec();
    method public int getDelayMillis();
    method public int getDurationMillis();
    method public kotlin.jvm.functions.Function1<java.lang.Float,java.lang.Float> getEasing();
    method public V getValue(long playTime, V start, V end, V startVelocity);
    method public V getVelocity(long playTime, V start, V end, V startVelocity);
  }

}