// 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, V? 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, V visibilityThreshold = typeConverter.invoke(initVal).newInstanceOfValue(Spring.DefaultDisplacementThreshold));
    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 interface Animation<T, V extends androidx.animation.AnimationVector> {
    method public androidx.animation.TwoWayConverter<T,V> getConverter();
    method public long getDurationMillis();
    method public T! getValue(long playTime);
    method public V getVelocityVector(long playTime);
    method public default boolean isFinished(long playTime);
    property public abstract androidx.animation.TwoWayConverter<T,V> converter;
    property public abstract long durationMillis;
  }

  public abstract class AnimationBuilder<T> {
    ctor public AnimationBuilder();
    method public abstract <V extends androidx.animation.AnimationVector> androidx.animation.AnimationSpec<V> build(androidx.animation.TwoWayConverter<T,V> converter);
  }

  public final class AnimationBuilderKt {
    field public static final long DefaultDuration = 300L; // 0x12cL
    field public static final int Infinite = 2147483647; // 0x7fffffff
  }

  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 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 {
    method public static <V extends androidx.animation.AnimationVector> androidx.animation.TargetBasedAnimation<V,V> createAnimation(androidx.animation.AnimationSpec<V>, V startValue, V endValue, V startVelocity);
    method public static <T, V extends androidx.animation.AnimationVector> androidx.animation.TargetBasedAnimation<T,V> createAnimation(androidx.animation.AnimationSpec<V>, T? startValue, T? endValue, V startVelocityVector, androidx.animation.TwoWayConverter<T,V> converter);
    method public static <T, V extends androidx.animation.AnimationVector> T! getVelocity(androidx.animation.Animation<T,V>, long playTime);
  }

  public interface AnimationSpec<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 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.AnimationBuilder<T> anim = defaultPhysicsBuilder(), 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 DecayAnimation implements androidx.animation.Animation<java.lang.Float,androidx.animation.AnimationVector1D> {
    ctor public DecayAnimation(androidx.animation.FloatDecayAnimationSpec anim, float startValue, float startVelocity);
    method public androidx.animation.TwoWayConverter<java.lang.Float,androidx.animation.AnimationVector1D> getConverter();
    method public long getDurationMillis();
    method public Float! getValue(long playTime);
    method public androidx.animation.AnimationVector1D getVelocityVector(long playTime);
    property public androidx.animation.TwoWayConverter<java.lang.Float,androidx.animation.AnimationVector1D> converter;
    property public long durationMillis;
  }

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

  public abstract class DurationBasedAnimationBuilder<T> extends androidx.animation.AnimationBuilder<T> {
    ctor public DurationBasedAnimationBuilder();
    method public abstract <V extends androidx.animation.AnimationVector> androidx.animation.DurationBasedAnimationSpec<V> build(androidx.animation.TwoWayConverter<T,V> converter);
    method public final int getDelay();
    method public final int getDuration();
    method public final void setDelay(int value);
    method public final void setDuration(int value);
    property public final int delay;
    property public final int duration;
  }

  public interface DurationBasedAnimationSpec<V extends androidx.animation.AnimationVector> extends androidx.animation.AnimationSpec<V> {
    method public long getDelay();
    method public long getDuration();
    method public default long getDurationMillis(V start, V end, V startVelocity);
    property public abstract long delay;
    property public abstract long duration;
  }

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

  public final class FloatAnimationSpecKt {
    method public static <V extends androidx.animation.AnimationVector> androidx.animation.AnimationSpec<V> vectorize(androidx.animation.FloatAnimationSpec);
  }

  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 {
    method public static androidx.animation.Animation<java.lang.Float,androidx.animation.AnimationVector1D> createAnimation(androidx.animation.FloatDecayAnimationSpec, float startValue, float startVelocity = 0f);
  }

  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 displacementThreshold);
    ctor public FloatSpringSpec();
    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 FloatTweenSpec implements androidx.animation.FloatAnimationSpec {
    ctor public FloatTweenSpec(long duration, long delay, kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Float> easing);
    ctor public FloatTweenSpec();
    method public long getDelay();
    method public long 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 KeyframesBuilder<T> extends androidx.animation.DurationBasedAnimationBuilder<T> {
    ctor public KeyframesBuilder();
    method public infix androidx.animation.KeyframesBuilder<T>.KeyframeEntity<T> at(T?, int timeStamp);
    method public <V extends androidx.animation.AnimationVector> androidx.animation.DurationBasedAnimationSpec<V> build(androidx.animation.TwoWayConverter<T,V> converter);
    method public infix void with(androidx.animation.KeyframesBuilder<T>.KeyframeEntity<T>, kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Float> easing);
  }

  public final class KeyframesBuilder.KeyframeEntity<T> {
  }

  public final class KeyframesSpec<V extends androidx.animation.AnimationVector> implements androidx.animation.DurationBasedAnimationSpec<V> {
    ctor public KeyframesSpec(java.util.Map<java.lang.Long,? extends kotlin.Pair<? extends V,? extends kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Float>>> keyframes, long duration, long delay);
    method public long getDelay();
    method public long getDuration();
    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 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 final class PhysicsBuilder<T> extends androidx.animation.AnimationBuilder<T> {
    ctor public PhysicsBuilder(float dampingRatio, float stiffness, T? displacementThreshold);
    ctor public PhysicsBuilder();
    method public <V extends androidx.animation.AnimationVector> androidx.animation.SpringSpec<V> build(androidx.animation.TwoWayConverter<T,V> converter);
    method public float getDampingRatio();
    method public float getStiffness();
    method public void setDampingRatio(float p);
    method public void setStiffness(float p);
  }

  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 RepeatableBuilder<T> extends androidx.animation.AnimationBuilder<T> {
    ctor public RepeatableBuilder();
    method public <V extends androidx.animation.AnimationVector> androidx.animation.AnimationSpec<V> build(androidx.animation.TwoWayConverter<T,V> converter);
    method public androidx.animation.DurationBasedAnimationBuilder<T>? getAnimation();
    method public Integer? getIterations();
    method public void setAnimation(androidx.animation.DurationBasedAnimationBuilder<T>? p);
    method public void setIterations(Integer? value);
    property public final androidx.animation.DurationBasedAnimationBuilder<T>? animation;
    property public final Integer? iterations;
  }

  public final class RepeatableSpec<V extends androidx.animation.AnimationVector> implements androidx.animation.AnimationSpec<V> {
    ctor public RepeatableSpec(long iterationCount, androidx.animation.DurationBasedAnimationSpec<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 SnapBuilder<T> extends androidx.animation.AnimationBuilder<T> {
    ctor public SnapBuilder();
    method public <V extends androidx.animation.AnimationVector> androidx.animation.SnapSpec<V> build(androidx.animation.TwoWayConverter<T,V> converter);
    method public int getDelay();
    method public void setDelay(int p);
    property public final int delay;
  }

  public final class SnapSpec<V extends androidx.animation.AnimationVector> implements androidx.animation.DurationBasedAnimationSpec<V> {
    ctor public SnapSpec(long delay);
    ctor public SnapSpec();
    method public long getDelay();
    method public long getDuration();
    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 long duration;
  }

  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 {
    method @VisibleForTesting(otherwise=3) public static long estimateAnimationDurationMillis(float stiffness, float dampingRatio, float initialVelocity, float initialDisplacement, float delta);
    method @VisibleForTesting(otherwise=3) public static long estimateAnimationDurationMillis(double stiffness, double dampingRatio, double initialVelocity, double initialDisplacement, double delta);
    method @VisibleForTesting(otherwise=3) public static long estimateAnimationDurationMillis(double springConstant, double dampingCoefficient, double mass, double initialVelocity, double initialDisplacement, double delta);
  }

  public final class SpringSimulationKt {
  }

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

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

  public final class TargetBasedAnimation<T, V extends androidx.animation.AnimationVector> implements androidx.animation.Animation<T,V> {
    ctor public TargetBasedAnimation(androidx.animation.AnimationSpec<V> animationSpec, T! startValue, T! endValue, V startVelocityVector, androidx.animation.TwoWayConverter<T,V> converter);
    ctor public TargetBasedAnimation(androidx.animation.AnimationSpec<V> animationSpec, T! startValue, T! endValue, T! startVelocity, androidx.animation.TwoWayConverter<T,V> converter);
    method public androidx.animation.TwoWayConverter<T,V> getConverter();
    method public long getDurationMillis();
    method public T! getEndValue();
    method public T! getValue(long playTime);
    method public V getVelocityVector(long playTime);
    property public long durationMillis;
  }

  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.TransitionDefinition<T> transitionDefinition(@kotlin.BuilderInference kotlin.jvm.functions.Function1<? super androidx.animation.TransitionDefinition<T>,kotlin.Unit> init);
  }

  public final class TransitionSpec<S> {
    method public androidx.animation.InterruptionHandling getInterruptionHandling();
    method public S? getNextState();
    method public <T> androidx.animation.KeyframesBuilder<T> keyframes(kotlin.jvm.functions.Function1<? super androidx.animation.KeyframesBuilder<T>,kotlin.Unit> init);
    method public <T> androidx.animation.AnimationBuilder<T> physics(kotlin.jvm.functions.Function1<? super androidx.animation.PhysicsBuilder<T>,kotlin.Unit> init);
    method public <T> androidx.animation.AnimationBuilder<T> repeatable(kotlin.jvm.functions.Function1<? super androidx.animation.RepeatableBuilder<T>,kotlin.Unit> init);
    method public void setInterruptionHandling(androidx.animation.InterruptionHandling p);
    method public void setNextState(S? p);
    method public <T> androidx.animation.AnimationBuilder<T> snap();
    method public <T> androidx.animation.DurationBasedAnimationBuilder<T> tween(kotlin.jvm.functions.Function1<? super androidx.animation.TweenBuilder<T>,kotlin.Unit> init);
    method public infix <T, V extends androidx.animation.AnimationVector> void using(androidx.animation.PropKey<T,V>, androidx.animation.AnimationBuilder<T> builder);
    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 TweenBuilder<T> extends androidx.animation.DurationBasedAnimationBuilder<T> {
    ctor public TweenBuilder();
    method public <V extends androidx.animation.AnimationVector> androidx.animation.TweenSpec<V> build(androidx.animation.TwoWayConverter<T,V> converter);
    method public kotlin.jvm.functions.Function1<java.lang.Float,java.lang.Float> getEasing();
    method public void setEasing(kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Float> p);
    property public final kotlin.jvm.functions.Function1<java.lang.Float,java.lang.Float> easing;
  }

  public final class TweenSpec<V extends androidx.animation.AnimationVector> implements androidx.animation.DurationBasedAnimationSpec<V> {
    ctor public TweenSpec(long duration, long delay, kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Float> easing);
    ctor public TweenSpec();
    method public long getDelay();
    method public long getDuration();
    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);
  }

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

}