// Signature format: 3.0
package androidx.compose.animation.core {

  public abstract class AnimatedFloat extends androidx.compose.animation.core.BaseAnimatedValue<java.lang.Float,androidx.compose.animation.core.AnimationVector1D> {
    ctor public AnimatedFloat(androidx.compose.animation.core.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 = (-1.0f/0.0f), float max = (1.0f/0.0f));
    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.compose.animation.core.AnimationVector> extends androidx.compose.animation.core.BaseAnimatedValue<T,V> {
    ctor public AnimatedValue(androidx.compose.animation.core.TwoWayConverter<T,V> typeConverter, androidx.compose.animation.core.AnimationClockObservable clock, T? visibilityThreshold);
    method public final V getVelocity();
    property public final V velocity;
  }

  public final class AnimatedValueKt {
    method public static androidx.compose.animation.core.AnimatedFloat AnimatedFloat(float initVal, androidx.compose.animation.core.AnimationClockObservable clock, float visibilityThreshold = 0.01f);
    method public static <T, V extends androidx.compose.animation.core.AnimationVector> androidx.compose.animation.core.AnimatedValue<T,V> AnimatedValue(T? initVal, androidx.compose.animation.core.TwoWayConverter<T,V> typeConverter, androidx.compose.animation.core.AnimationClockObservable clock, T? visibilityThreshold = null);
    method public static <V extends androidx.compose.animation.core.AnimationVector> androidx.compose.animation.core.AnimatedValue<V,V> AnimatedVector(V initVal, androidx.compose.animation.core.AnimationClockObservable clock, V visibilityThreshold = initVal.newInstanceOfValue(Spring.DefaultDisplacementThreshold));
    method public static void fling(androidx.compose.animation.core.AnimatedFloat, float startVelocity, androidx.compose.animation.core.FloatDecayAnimationSpec decay = androidx.compose.animation.core.ExponentialDecay(), kotlin.jvm.functions.Function3<? super androidx.compose.animation.core.AnimationEndReason,? super java.lang.Float,? super java.lang.Float,kotlin.Unit>? onEnd = null);
    method public static void fling(androidx.compose.animation.core.AnimatedFloat, float startVelocity, androidx.compose.animation.core.FloatDecayAnimationSpec decay = androidx.compose.animation.core.ExponentialDecay(), kotlin.jvm.functions.Function1<? super java.lang.Float,androidx.compose.animation.core.TargetAnimation> adjustTarget, kotlin.jvm.functions.Function3<? super androidx.compose.animation.core.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.compose.animation.core.AnimationClockObserver observer);
    method public void unsubscribe(androidx.compose.animation.core.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.compose.animation.core.AnimationConstants INSTANCE;
    field public static final int Infinite = 2147483647; // 0x7fffffff
  }

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

  public final class AnimationKt {
  }

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

  public final class AnimationSpecKt {
  }

  public abstract sealed class AnimationVector {
  }

  public final class AnimationVector1D extends androidx.compose.animation.core.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.compose.animation.core.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.compose.animation.core.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.compose.animation.core.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.compose.animation.core.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.compose.animation.core.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.compose.animation.core.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.compose.animation.core.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.compose.animation.core.AnimationVector1D AnimationVector(float v1);
    method public static androidx.compose.animation.core.AnimationVector2D AnimationVector(float v1, float v2);
    method public static androidx.compose.animation.core.AnimationVector3D AnimationVector(float v1, float v2, float v3);
    method public static androidx.compose.animation.core.AnimationVector4D AnimationVector(float v1, float v2, float v3, float v4);
  }

  public abstract sealed class BaseAnimatedValue<T, V extends androidx.compose.animation.core.AnimationVector> {
    method public final void animateTo(T? targetValue, androidx.compose.animation.core.AnimationSpec<T> anim = androidx.compose.animation.core.BaseAnimatedValue.defaultSpringSpec, kotlin.jvm.functions.Function2<? super androidx.compose.animation.core.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.compose.animation.core.AnimationClockObservable {
    ctor public BaseAnimationClock();
    method public void subscribe(androidx.compose.animation.core.AnimationClockObserver observer);
    method public void unsubscribe(androidx.compose.animation.core.AnimationClockObserver observer);
    field @Deprecated public static final androidx.compose.animation.core.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.compose.animation.core.BaseAnimationClock {
    ctor public DefaultAnimationClock();
    method public void dispatchTime$lintWithKotlin(long frameTimeMillis);
  }

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

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

  public final class ExponentialDecay implements androidx.compose.animation.core.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.compose.animation.core.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.compose.animation.core.AnimationVector> androidx.compose.animation.core.VectorizedFloatAnimationSpec<V> vectorize(androidx.compose.animation.core.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.compose.animation.core.PropKey<java.lang.Float,androidx.compose.animation.core.AnimationVector1D> {
    ctor public FloatPropKey(String label);
    ctor public FloatPropKey();
    method public androidx.compose.animation.core.TwoWayConverter<java.lang.Float,androidx.compose.animation.core.AnimationVector1D> getTypeConverter();
    property public androidx.compose.animation.core.TwoWayConverter<java.lang.Float,androidx.compose.animation.core.AnimationVector1D> typeConverter;
  }

  public final class FloatSpringSpec implements androidx.compose.animation.core.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.compose.animation.core.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.compose.animation.core.PropKey<java.lang.Integer,androidx.compose.animation.core.AnimationVector1D> {
    ctor public IntPropKey(String label);
    ctor public IntPropKey();
    method public androidx.compose.animation.core.TwoWayConverter<java.lang.Integer,androidx.compose.animation.core.AnimationVector1D> getTypeConverter();
    property public androidx.compose.animation.core.TwoWayConverter<java.lang.Integer,androidx.compose.animation.core.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.compose.animation.core.InterruptionHandling valueOf(String name) throws java.lang.IllegalArgumentException;
    method public static androidx.compose.animation.core.InterruptionHandling[] values();
    enum_constant public static final androidx.compose.animation.core.InterruptionHandling PHYSICS;
    enum_constant public static final androidx.compose.animation.core.InterruptionHandling SNAP_TO_END;
    enum_constant public static final androidx.compose.animation.core.InterruptionHandling TWEEN;
    enum_constant public static final androidx.compose.animation.core.InterruptionHandling UNINTERRUPTIBLE;
  }

  public final class KeyframesSpec<T> implements androidx.compose.animation.core.DurationBasedAnimationSpec<T> {
    ctor public KeyframesSpec(androidx.compose.animation.core.KeyframesSpec.KeyframesSpecConfig<T> config);
    method public androidx.compose.animation.core.KeyframesSpec.KeyframesSpecConfig<T> getConfig();
    method public <V extends androidx.compose.animation.core.AnimationVector> androidx.compose.animation.core.VectorizedKeyframesSpec<V> vectorize(androidx.compose.animation.core.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.compose.animation.core.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.compose.animation.core.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.compose.animation.core.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.compose.animation.core.AnimationVector> void set(androidx.compose.animation.core.PropKey<T,V> propKey, T? prop);
  }

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

  public final class PropKeyKt {
    method public static <T, V extends androidx.compose.animation.core.AnimationVector> androidx.compose.animation.core.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.compose.animation.core.TwoWayConverter<java.lang.Float,androidx.compose.animation.core.AnimationVector1D> getFloatToVectorConverter();
    method public static androidx.compose.animation.core.TwoWayConverter<java.lang.Integer,androidx.compose.animation.core.AnimationVector1D> getIntToVectorConverter();
  }

  public enum RepeatMode {
    method public static androidx.compose.animation.core.RepeatMode valueOf(String name) throws java.lang.IllegalArgumentException;
    method public static androidx.compose.animation.core.RepeatMode[] values();
    enum_constant public static final androidx.compose.animation.core.RepeatMode Restart;
    enum_constant public static final androidx.compose.animation.core.RepeatMode Reverse;
  }

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

  public final class SnapSpec<T> implements androidx.compose.animation.core.AnimationSpec<T> {
    ctor public SnapSpec(int delay);
    ctor public SnapSpec();
    method public int getDelay();
    method public <V extends androidx.compose.animation.core.AnimationVector> androidx.compose.animation.core.VectorizedDurationBasedAnimationSpec<V> vectorize(androidx.compose.animation.core.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.compose.animation.core.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.compose.animation.core.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.compose.animation.core.AnimationVector> androidx.compose.animation.core.VectorizedSpringSpec<V> vectorize(androidx.compose.animation.core.TwoWayConverter<T,V> converter);
  }

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

  public final class ToolingGlueKt {
  }

  public final class TransitionAnimation<T> implements androidx.compose.animation.core.TransitionState {
    ctor public TransitionAnimation(internal androidx.compose.animation.core.TransitionDefinition<T> def, androidx.compose.animation.core.AnimationClockObservable clock, T? initState, String? label);
    method public operator <T, V extends androidx.compose.animation.core.AnimationVector> T! get(androidx.compose.animation.core.PropKey<T,V> propKey);
    method public String? getLabel();
    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.compose.animation.core.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.compose.animation.core.MutableTransitionState,kotlin.Unit> init);
    method public void transition(T? fromState = null, T? toState = null, kotlin.jvm.functions.Function1<? super androidx.compose.animation.core.TransitionSpec<T>,kotlin.Unit> init);
    method public void transition(kotlin.Pair<? extends T,? extends T>![] fromToPairs, kotlin.jvm.functions.Function1<? super androidx.compose.animation.core.TransitionSpec<T>,kotlin.Unit> init);
  }

  public final class TransitionDefinitionKt {
    method public static <T> androidx.compose.animation.core.TransitionAnimation<T> createAnimation(androidx.compose.animation.core.TransitionDefinition<T>, androidx.compose.animation.core.AnimationClockObservable clock, T? initState = null);
    method public static <T> androidx.compose.animation.core.KeyframesSpec<T> keyframes(kotlin.jvm.functions.Function1<? super androidx.compose.animation.core.KeyframesSpec.KeyframesSpecConfig<T>,kotlin.Unit> init);
    method public static <T> androidx.compose.animation.core.AnimationSpec<T> repeatable(int iterations, androidx.compose.animation.core.DurationBasedAnimationSpec<T> animation, androidx.compose.animation.core.RepeatMode repeatMode = androidx.compose.animation.core.RepeatMode.Restart);
    method public static <T> androidx.compose.animation.core.AnimationSpec<T> snap(int delayMillis = 0);
    method public static <T> androidx.compose.animation.core.SpringSpec<T> spring(float dampingRatio = 1.0f, float stiffness = 1500.0f, T? visibilityThreshold = null);
    method public static <T> androidx.compose.animation.core.TransitionDefinition<T> transitionDefinition(kotlin.jvm.functions.Function1<? super androidx.compose.animation.core.TransitionDefinition<T>,kotlin.Unit> init);
    method public static <T> androidx.compose.animation.core.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.compose.animation.core.InterruptionHandling getInterruptionHandling();
    method public S? getNextState();
    method public void setInterruptionHandling(androidx.compose.animation.core.InterruptionHandling p);
    method public void setNextState(S? p);
    method public infix <T, V extends androidx.compose.animation.core.AnimationVector> void using(androidx.compose.animation.core.PropKey<T,V>, androidx.compose.animation.core.AnimationSpec<T> animationSpec);
    property public final androidx.compose.animation.core.InterruptionHandling interruptionHandling;
    property public final S? nextState;
  }

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

  public final class TweenSpec<T> implements androidx.compose.animation.core.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.compose.animation.core.AnimationVector> androidx.compose.animation.core.VectorizedTweenSpec<V> vectorize(androidx.compose.animation.core.TwoWayConverter<T,V> converter);
  }

  public interface TwoWayConverter<T, V extends androidx.compose.animation.core.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.compose.animation.core.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.compose.animation.core.AnimationVector> extends androidx.compose.animation.core.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.compose.animation.core.AnimationVector> implements androidx.compose.animation.core.VectorizedAnimationSpec<V> {
    ctor public VectorizedFloatAnimationSpec(androidx.compose.animation.core.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.compose.animation.core.AnimationVector> implements androidx.compose.animation.core.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.compose.animation.core.AnimationVector> implements androidx.compose.animation.core.VectorizedAnimationSpec<V> {
    ctor public VectorizedRepeatableSpec(int iterations, androidx.compose.animation.core.VectorizedDurationBasedAnimationSpec<V> animation, androidx.compose.animation.core.RepeatMode repeatMode);
    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.compose.animation.core.AnimationVector> implements androidx.compose.animation.core.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.compose.animation.core.AnimationVector> implements androidx.compose.animation.core.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.compose.animation.core.AnimationVector> implements androidx.compose.animation.core.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);
  }

}