ui/ui-animation-core/api/0.1.0-dev15.txt - platform/frameworks/support - Git at Google

 // 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);
  }

 }