androidx.compose.animation

Animatable

Cmn

Artifact: androidx.compose.animation:animation

@RememberInComposition
fun Animatable(initialValue: Color): Animatable<Color, AnimationVector4D>

This Animatable function creates a Color value holder that automatically animates its value when the value is changed via animateTo. Animatable supports value change during an ongoing value change animation. When that happens, a new animation will transition Animatable from its current value (i.e. value at the point of interruption) to the new target. This ensures that the value change is always continuous using animateTo. If spring animation (i.e. default animation) is used with animateTo, the velocity change will be guaranteed to be continuous as well.

Unlike AnimationState, Animatable ensures mutual exclusiveness on its animation. To do so, when a new animation is started via animateTo (or animateDecay), any ongoing animation job will be cancelled via a CancellationException.

Animatable also supports animating data types other than Color, such as Floats and generic types. See androidx.compose.animation.core.Animatable for other variants.

import androidx.compose.animation.Animatable
import androidx.compose.animation.core.AnimationSpec
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberUpdatedState
import androidx.compose.ui.graphics.Color

@Composable
fun animate(
    targetValue: Color,
    animationSpec: AnimationSpec<Color>,
    onFinished: (Color) -> Unit,
): Color {
    // Creates an Animatable of Color, and remembers it.
    val color = remember { Animatable(targetValue) }
    val finishedListener = rememberUpdatedState(onFinished)
    // Launches a new coroutine whenever the target value or animation spec has changed. This
    // automatically cancels the previous job/animation.
    LaunchedEffect(targetValue, animationSpec) {
        color.animateTo(targetValue, animationSpec)
        // Invokes finished listener. This line will not be executed if the job gets canceled
        // halfway through an animation.
        finishedListener.value(targetValue)
    }
    return color.value
}

Parameters
`initialValue: Color`	initial value of the `Animatable`

AnimatedContent

Cmn

`AnimatedContentScope`	Receiver scope for content lambda for AnimatedContent.	Cmn
`AnimatedContentTransitionScope`	`AnimatedContentTransitionScope` provides functions that are convenient and only applicable in the context of `AnimatedContent`, such as `slideIntoContainer` and `slideOutOfContainer`.	Cmn
`AnimatedVisibilityScope`	This is the scope for the content of `AnimatedVisibility`.	Cmn
`BoundsTransform`	`BoundsTransform` defines the animation spec used to animate from initial bounds to the target bounds.	Cmn
`SharedTransitionScope`	`SharedTransitionScope` provides a coordinator space in which shared elements/ shared bounds (when matched) will transform their bounds from one to another.	Cmn
`SharedTransitionScope.OverlayClip`	`OverlayClip` defines a specific clipping that should be applied to a `sharedBounds` or `sharedElement` in the overlay.	Cmn
`SharedTransitionScope.PlaceHolderSize`	PlaceHolderSize defines the size of the space that was or will be occupied by the exiting or entering `sharedElement`/`sharedBounds`.	Cmn
`SharedTransitionScope.ResizeMode`	There are two different modes to resize child layout of `sharedBounds` during bounds transform: 1) `ScaleToBounds` and 2) `RemeasureToBounds`.	Cmn
`SizeTransform`	`SizeTransform` defines how to transform from one size to another when the size of the content changes.	Cmn

`AnimatedContentTransitionScope.SlideDirection`	`SlideDirection` defines the direction of the slide in/out for `slideIntoContainer` and `slideOutOfContainer`.	Cmn
`ContentTransform`	`ContentTransform` defines how the target content (i.e. content associated with target state) enters `AnimatedContent` and how the initial content disappears.	Cmn
`EnterTransition`	`EnterTransition` defines how an `AnimatedVisibility` Composable appears on screen as it becomes visible.	Cmn
`ExitTransition`	`ExitTransition` defines how an `AnimatedVisibility` Composable disappears on screen as it becomes not visible.	Cmn
`SharedTransitionScope.SharedContentState`	`SharedContentState` is designed to allow access of the properties of `sharedBounds`/`sharedElement`, such as whether a match of the same `key` has been found in the `SharedTransitionScope`, its `clipPathInOverlay` and `parentSharedContentState` if there is a parent `sharedBounds` in the layout tree.	Cmn
`SplineBasedFloatDecayAnimationSpec`	A native Android fling curve decay.	Cmn

`ExperimentalAnimationApi`		Cmn
`ExperimentalSharedTransitionApi`		Cmn

`Animatable<Color, AnimationVector4D>`	`@RememberInComposition Animatable(initialValue: Color)` This `Animatable` function creates a Color value holder that automatically animates its value when the value is changed via `animateTo`.	Cmn
`Unit`	`@Composable <S : Any?> AnimatedContent( targetState: S, modifier: Modifier, transitionSpec: AnimatedContentTransitionScope<S>.() -> ContentTransform, contentAlignment: Alignment, label: String, contentKey: (targetState) -> Any?, content: @Composable AnimatedContentScope.(targetState) -> Unit )` `AnimatedContent` is a container that automatically animates its content when `targetState` changes.	Cmn
`Unit`	`@Composable AnimatedVisibility( visible: Boolean, modifier: Modifier, enter: EnterTransition, exit: ExitTransition, label: String, content: @Composable AnimatedVisibilityScope.() -> Unit )` `AnimatedVisibility` composable animates the appearance and disappearance of its content, as `visible` value changes.	Cmn
`Unit`	`@Composable AnimatedVisibility( visibleState: MutableTransitionState<Boolean>, modifier: Modifier, enter: EnterTransition, exit: ExitTransition, label: String, content: @Composable AnimatedVisibilityScope.() -> Unit )` `AnimatedVisibility` composable animates the appearance and disappearance of its content, as `visibleState`'s `targetState` changes.	Cmn
`Unit`	`@Composable <T : Any?> Crossfade( targetState: T, modifier: Modifier, animationSpec: FiniteAnimationSpec<Float>, label: String, content: @Composable (T) -> Unit )` `Crossfade` allows to switch between two layouts with a crossfade animation.	Cmn
`Unit`	`@ExperimentalSharedTransitionApi @Composable SharedTransitionLayout(modifier: Modifier, content: @Composable SharedTransitionScope.() -> Unit)` `SharedTransitionLayout` creates a layout and a `SharedTransitionScope` for the child layouts in `content`.	Cmn
`Unit`	`@ExperimentalSharedTransitionApi @Composable SharedTransitionScope(content: @Composable SharedTransitionScope.(Modifier) -> Unit)` `SharedTransitionScope` creates a `SharedTransitionScope` for the child layouts in `content`.	Cmn
`SizeTransform`	`SizeTransform( clip: Boolean, sizeAnimationSpec: (initialSize: IntSize, targetSize: IntSize) -> FiniteAnimationSpec<IntSize> )` This creates a `SizeTransform` with the provided `clip` and `sizeAnimationSpec`.	Cmn
`State<Color>`	`@Composable animateColorAsState( targetValue: Color, animationSpec: AnimationSpec<Color>, label: String, finishedListener: ((Color) -> Unit)? )` Fire-and-forget animation function for `Color`.	Cmn
`DecayAnimationSpec<Float>`	`@Composable defaultDecayAnimationSpec()` This function is deprecated. Replace with rememberSplineBasedDecay<Float>	Cmn android
`EnterTransition`	`expandHorizontally( animationSpec: FiniteAnimationSpec<IntSize>, expandFrom: Alignment.Horizontal, clip: Boolean, initialWidth: (fullWidth: Int) -> Int )` This expands the clip bounds of the appearing content horizontally, from the width returned from `initialWidth` to the full width.	Cmn
`EnterTransition`	`expandIn( animationSpec: FiniteAnimationSpec<IntSize>, expandFrom: Alignment, clip: Boolean, initialSize: (fullSize: IntSize) -> IntSize )` This expands the clip bounds of the appearing content from the size returned from `initialSize` to the full size.	Cmn
`EnterTransition`	`expandVertically( animationSpec: FiniteAnimationSpec<IntSize>, expandFrom: Alignment.Vertical, clip: Boolean, initialHeight: (fullHeight: Int) -> Int )` This expands the clip bounds of the appearing content vertically, from the height returned from `initialHeight` to the full height.	Cmn
`EnterTransition`	`fadeIn(animationSpec: FiniteAnimationSpec<Float>, initialAlpha: Float)` This fades in the content of the transition, from the specified starting alpha (i.e. `initialAlpha`) to 1f, using the supplied `animationSpec`.	Cmn
`ExitTransition`	`fadeOut(animationSpec: FiniteAnimationSpec<Float>, targetAlpha: Float)` This fades out the content of the transition, from full opacity to the specified target alpha (i.e. `targetAlpha`), using the supplied `animationSpec`.	Cmn
`DecayAnimationSpec<T>`	`@Composable <T : Any?> rememberSplineBasedDecay()`	Cmn android
`EnterTransition`	`scaleIn( animationSpec: FiniteAnimationSpec<Float>, initialScale: Float, transformOrigin: TransformOrigin )` This scales the content as it appears, from an initial scale (defined in `initialScale`) to 1f.	Cmn
`ExitTransition`	`scaleOut( animationSpec: FiniteAnimationSpec<Float>, targetScale: Float, transformOrigin: TransformOrigin )` This scales the content of the exit transition, from 1f to the target scale defined in `targetScale`.	Cmn
`ExitTransition`	`shrinkHorizontally( animationSpec: FiniteAnimationSpec<IntSize>, shrinkTowards: Alignment.Horizontal, clip: Boolean, targetWidth: (fullWidth: Int) -> Int )` This shrinks the clip bounds of the disappearing content horizontally, from the full width to the width returned from `targetWidth`.	Cmn
`ExitTransition`	`shrinkOut( animationSpec: FiniteAnimationSpec<IntSize>, shrinkTowards: Alignment, clip: Boolean, targetSize: (fullSize: IntSize) -> IntSize )` This shrinks the clip bounds of the disappearing content from the full size to the size returned from `targetSize`.	Cmn
`ExitTransition`	`shrinkVertically( animationSpec: FiniteAnimationSpec<IntSize>, shrinkTowards: Alignment.Vertical, clip: Boolean, targetHeight: (fullHeight: Int) -> Int )` This shrinks the clip bounds of the disappearing content vertically, from the full height to the height returned from `targetHeight`.	Cmn
`EnterTransition`	`slideIn( animationSpec: FiniteAnimationSpec<IntOffset>, initialOffset: (fullSize: IntSize) -> IntOffset )` This slides in the content of the transition, from a starting offset defined in `initialOffset` to `IntOffset(0, 0)`.	Cmn
`EnterTransition`	`slideInHorizontally( animationSpec: FiniteAnimationSpec<IntOffset>, initialOffsetX: (fullWidth: Int) -> Int )` This slides in the content horizontally, from a starting offset defined in `initialOffsetX` to `0` pixels.	Cmn
`EnterTransition`	`slideInVertically( animationSpec: FiniteAnimationSpec<IntOffset>, initialOffsetY: (fullHeight: Int) -> Int )` This slides in the content vertically, from a starting offset defined in `initialOffsetY` to `0` in pixels.	Cmn
`ExitTransition`	`slideOut( animationSpec: FiniteAnimationSpec<IntOffset>, targetOffset: (fullSize: IntSize) -> IntOffset )` This slides out the content of the transition, from an offset of `IntOffset(0, 0)` to the target offset defined in `targetOffset`.	Cmn
`ExitTransition`	`slideOutHorizontally( animationSpec: FiniteAnimationSpec<IntOffset>, targetOffsetX: (fullWidth: Int) -> Int )` This slides out the content horizontally, from 0 to a target offset defined in `targetOffsetX` in pixels.	Cmn
`ExitTransition`	`slideOutVertically( animationSpec: FiniteAnimationSpec<IntOffset>, targetOffsetY: (fullHeight: Int) -> Int )` This slides out the content vertically, from 0 to a target offset defined in `targetOffsetY` in pixels.	Cmn
`DecayAnimationSpec<T>`	`<T : Any?> splineBasedDecay(density: Density)`	Cmn

`Unit`	`@Composable <S : Any?> Transition<S>.AnimatedContent( modifier: Modifier, transitionSpec: AnimatedContentTransitionScope<S>.() -> ContentTransform, contentAlignment: Alignment, contentKey: (targetState) -> Any?, content: @Composable AnimatedContentScope.(targetState) -> Unit )` `AnimatedContent` is a container that automatically animates its content when `Transition.targetState` changes.	Cmn
`Unit`	`@Composable <T : Any?> Transition<T>.AnimatedVisibility( visible: (T) -> Boolean, modifier: Modifier, enter: EnterTransition, exit: ExitTransition, content: @Composable AnimatedVisibilityScope.() -> Unit )` This extension function creates an `AnimatedVisibility` composable as a child Transition of the given Transition.	Cmn
`Unit`	`@Composable RowScope.AnimatedVisibility( visible: Boolean, modifier: Modifier, enter: EnterTransition, exit: ExitTransition, label: String, content: @Composable AnimatedVisibilityScope.() -> Unit )` `RowScope.AnimatedVisibility` composable animates the appearance and disappearance of its content when the `AnimatedVisibility` is in a `Row`.	Cmn
`Unit`	`@Composable ColumnScope.AnimatedVisibility( visible: Boolean, modifier: Modifier, enter: EnterTransition, exit: ExitTransition, label: String, content: @Composable AnimatedVisibilityScope.() -> Unit )` `ColumnScope.AnimatedVisibility` composable animates the appearance and disappearance of its content when the `AnimatedVisibility` is in a `Column`.	Cmn
`Unit`	`@Composable RowScope.AnimatedVisibility( visibleState: MutableTransitionState<Boolean>, modifier: Modifier, enter: EnterTransition, exit: ExitTransition, label: String, content: @Composable AnimatedVisibilityScope.() -> Unit )` `RowScope.AnimatedVisibility` composable animates the appearance and disappearance of its content as `visibleState`'s `targetState` changes.	Cmn
`Unit`	`@Composable ColumnScope.AnimatedVisibility( visibleState: MutableTransitionState<Boolean>, modifier: Modifier, enter: EnterTransition, exit: ExitTransition, label: String, content: @Composable AnimatedVisibilityScope.() -> Unit )` `ColumnScope.AnimatedVisibility` composable animates the appearance and disappearance of its content as `visibleState`'s `targetState` changes.	Cmn
`Unit`	`@ExperimentalAnimationApi @Composable <T : Any?> Transition<T>.Crossfade( modifier: Modifier, animationSpec: FiniteAnimationSpec<Float>, contentKey: (targetState) -> Any?, content: @Composable (targetState) -> Unit )` `Crossfade` allows to switch between two layouts with a crossfade animation.	Cmn
`Modifier`	`@ExperimentalSharedTransitionApi Modifier.animateBounds( lookaheadScope: LookaheadScope, modifier: Modifier, boundsTransform: BoundsTransform, animateMotionFrameOfReference: Boolean )` `Modifier` to animate layout changes (position and/or size) that occur within a `LookaheadScope`.	Cmn
`inline State<Color>`	`@Composable <S : Any?> Transition<S>.animateColor( noinline transitionSpec: @Composable Transition.Segment<S>.() -> FiniteAnimationSpec<Color>, label: String, targetValueByState: @Composable (state) -> Color )` Creates a `Color` animation as a part of the given `Transition`.	Cmn
`State<Color>`	`@Composable InfiniteTransition.animateColor( initialValue: Color, targetValue: Color, animationSpec: InfiniteRepeatableSpec<Color>, label: String )` Creates a Color animation that runs infinitely as a part of the given `InfiniteTransition`.	Cmn
`Modifier`	`Modifier.animateContentSize( animationSpec: FiniteAnimationSpec<IntSize>, finishedListener: ((initialValue: IntSize, targetValue: IntSize) -> Unit)? )` This modifier animates its own size when its child modifier (or the child composable if it is already at the tail of the chain) changes size.	Cmn
`Modifier`	`Modifier.animateContentSize( animationSpec: FiniteAnimationSpec<IntSize>, alignment: Alignment, finishedListener: ((initialValue: IntSize, targetValue: IntSize) -> Unit)? )` This modifier animates its own size when its child modifier (or the child composable if it is already at the tail of the chain) changes size.	Cmn
`infix ContentTransform`	`EnterTransition.togetherWith(exit: ExitTransition)` This creates a `ContentTransform` using the provided `EnterTransition` and `exit`, where the enter and exit transition will be running simultaneously.	Cmn
`infix ContentTransform`	`@ExperimentalAnimationApi EnterTransition.with(exit: ExitTransition)` This function is deprecated. Infix fun EnterTransition.with(ExitTransition) has been renamed to togetherWith	Cmn

Parameters
`visible: Boolean`	defines whether the content should be visible
`modifier: Modifier = Modifier`	modifier for the `Layout` created to contain the `content`
`enter: EnterTransition = fadeIn() + expandIn()`	EnterTransition(s) used for the appearing animation, fading in while expanding by default
`exit: ExitTransition = shrinkOut() + fadeOut()`	ExitTransition(s) used for the disappearing animation, fading out while shrinking by default
`label: String = "AnimatedVisibility"`	A label to differentiate from other animations in Android Studio animation preview.
`content: @Composable AnimatedVisibilityScope.() -> Unit`	Content to appear or disappear based on the value of `visible`

See also
`EnterTransition`
`ExitTransition`
`fadeIn`
`expandIn`
`fadeOut`
`shrinkOut`
`AnimatedVisibilityScope`

Parameters
`visibleState: MutableTransitionState<Boolean>`	defines whether the content should be visible
`modifier: Modifier = Modifier`	modifier for the `Layout` created to contain the `content`
`enter: EnterTransition = fadeIn() + expandIn()`	EnterTransition(s) used for the appearing animation, fading in while expanding by default
`exit: ExitTransition = fadeOut() + shrinkOut()`	ExitTransition(s) used for the disappearing animation, fading out while shrinking by default
`label: String = "AnimatedVisibility"`	A label to differentiate from other animations in Android Studio animation preview.
`content: @Composable AnimatedVisibilityScope.() -> Unit`	Content to appear or disappear based on the value of `visibleState`

Parameters
`targetState: T`	is a key representing your target layout state. Every time you change a key the animation will be triggered. The `content` called with the old key will be faded out while the `content` called with the new key will be faded in.
`modifier: Modifier = Modifier`	Modifier to be applied to the animation container.
`animationSpec: FiniteAnimationSpec<Float> = tween()`	the `AnimationSpec` to configure the animation.
`label: String = "Crossfade"`	An optional label to differentiate from other animations in Android Studio.
`content: @Composable (T) -> Unit`	A mapping from a given state to the content corresponding to that state.

Parameters
`modifier: Modifier = Modifier`	Modifiers to be applied to the layout.
`content: @Composable SharedTransitionScope.() -> Unit`	The children composable to be laid out.

Parameters
`targetValue: Color`	Target value of the animation
`animationSpec: AnimationSpec<Color> = colorDefaultSpring`	The animation that will be used to change the value through time, `spring` by default
`label: String = "ColorAnimation"`	An optional label to differentiate from other animations in Android Studio.
`finishedListener: ((Color) -> Unit)? = null`	An optional listener to get notified when the animation is finished.

Parameters
`animationSpec: FiniteAnimationSpec<IntSize> = spring( stiffness = Spring.StiffnessMediumLow, visibilityThreshold = IntSize.VisibilityThreshold, )`	the animation used for the expanding animation, `spring` by default.
`expandFrom: Alignment.Horizontal = Alignment.End`	the starting point of the expanding bounds, `Alignment.End` by default.
`clip: Boolean = true`	whether the content outside of the animated bounds should be clipped, true by default
`initialWidth: (fullWidth: Int) -> Int = { 0 }`	the start width of the expanding bounds, returning 0 by default.

Parameters
`animationSpec: FiniteAnimationSpec<IntSize> = spring( stiffness = Spring.StiffnessMediumLow, visibilityThreshold = IntSize.VisibilityThreshold, )`	the animation used for the expanding animation, `spring` by default.
`expandFrom: Alignment = Alignment.BottomEnd`	the starting point of the expanding bounds, `Alignment.BottomEnd` by default.
`clip: Boolean = true`	whether the content outside of the animated bounds should be clipped, true by default
`initialSize: (fullSize: IntSize) -> IntSize = { IntSize(0, 0) }`	the start size of the expanding bounds, returning `IntSize(0, 0)` by default.

Parameters
`animationSpec: FiniteAnimationSpec<IntSize> = spring( stiffness = Spring.StiffnessMediumLow, visibilityThreshold = IntSize.VisibilityThreshold, )`	the animation used for the expanding animation, `spring` by default.
`expandFrom: Alignment.Vertical = Alignment.Bottom`	the starting point of the expanding bounds, `Alignment.Bottom` by default.
`clip: Boolean = true`	whether the content outside of the animated bounds should be clipped, true by default
`initialHeight: (fullHeight: Int) -> Int = { 0 }`	the start height of the expanding bounds, returning 0 by default.

Parameters
`animationSpec: FiniteAnimationSpec<Float> = spring(stiffness = Spring.StiffnessMediumLow)`	the `FiniteAnimationSpec` for this animation, `spring` by default
`initialAlpha: Float = 0.0f`	the starting alpha of the enter transition, 0f by default

Parameters
`animationSpec: FiniteAnimationSpec<Float> = spring(stiffness = Spring.StiffnessMediumLow)`	the `FiniteAnimationSpec` for this animation, `spring` by default
`targetAlpha: Float = 0.0f`	the target alpha of the exit transition, 0f by default

Parameters
`animationSpec: FiniteAnimationSpec<Float> = spring(stiffness = Spring.StiffnessMediumLow)`	the animation used for the scale-out, `spring` by default.
`initialScale: Float = 0.0f`	the initial scale for the enter transition, 0 by default.
`transformOrigin: TransformOrigin = TransformOrigin.Center`	the pivot point in terms of fraction of the overall size. By default it's `TransformOrigin.Center`.

Parameters
`animationSpec: FiniteAnimationSpec<Float> = spring(stiffness = Spring.StiffnessMediumLow)`	the animation used for the slide-out, `spring` by default.
`targetScale: Float = 0.0f`	the target scale for the exit transition, 0 by default.
`transformOrigin: TransformOrigin = TransformOrigin.Center`	the pivot point in terms of fraction of the overall size. By default it's `TransformOrigin.Center`.

Parameters
`animationSpec: FiniteAnimationSpec<IntSize> = spring( stiffness = Spring.StiffnessMediumLow, visibilityThreshold = IntSize.VisibilityThreshold, )`	the animation used for the shrinking animation, `spring` by default.
`shrinkTowards: Alignment.Horizontal = Alignment.End`	the ending point of the shrinking bounds, `Alignment.End` by default.
`clip: Boolean = true`	whether the content outside of the animated bounds should be clipped, true by default
`targetWidth: (fullWidth: Int) -> Int = { 0 }`	returns the end width of the shrinking bounds, 0 by default.

Parameters
`animationSpec: FiniteAnimationSpec<IntSize> = spring( stiffness = Spring.StiffnessMediumLow, visibilityThreshold = IntSize.VisibilityThreshold, )`	the animation used for the shrinking animation, `spring` by default.
`shrinkTowards: Alignment = Alignment.BottomEnd`	the ending point of the shrinking bounds, `Alignment.BottomEnd` by default.
`clip: Boolean = true`	whether the content outside of the animated bounds should be clipped, true by default
`targetSize: (fullSize: IntSize) -> IntSize = { IntSize(0, 0) }`	returns the end size of the shrinking bounds, `IntSize(0, 0)` by default.

Interfaces

Classes

Annotations

Enums

Top-level functions summary

Extension functions summary

Extension properties summary

Top-level functions

Animatable

AnimatedContent

AnimatedVisibility

AnimatedVisibility

Crossfade

SharedTransitionLayout

SharedTransitionScope

SizeTransform

animateColorAsState

defaultDecayAnimationSpec

expandHorizontally

expandIn

expandVertically

fadeIn

fadeOut

rememberSplineBasedDecay

scaleIn

scaleOut

shrinkHorizontally

shrinkOut

shrinkVertically

slideIn

slideInHorizontally

slideInVertically

slideOut

slideOutHorizontally

slideOutVertically

splineBasedDecay

Extension functions

AnimatedContent

AnimatedVisibility

AnimatedVisibility

AnimatedVisibility

AnimatedVisibility

AnimatedVisibility

Crossfade

animateBounds

animateColor

animateColor

animateContentSize

animateContentSize

togetherWith

with

Extension properties

VectorConverter

Parameters
`animationSpec: FiniteAnimationSpec<IntSize> = spring( stiffness = Spring.StiffnessMediumLow, visibilityThreshold = IntSize.VisibilityThreshold, )`	the animation used for the shrinking animation, `spring` by default.
`shrinkTowards: Alignment.Vertical = Alignment.Bottom`	the ending point of the shrinking bounds, `Alignment.Bottom` by default.
`clip: Boolean = true`	whether the content outside of the animated bounds should be clipped, true by default
`targetHeight: (fullHeight: Int) -> Int = { 0 }`	returns the end height of the shrinking bounds, 0 by default.

Parameters
`animationSpec: FiniteAnimationSpec<IntOffset> = spring( stiffness = Spring.StiffnessMediumLow, visibilityThreshold = IntOffset.VisibilityThreshold, )`	the animation used for the slide-in, `spring` by default.
`initialOffset: (fullSize: IntSize) -> IntOffset`	a lambda that takes the full size of the content and returns the initial offset for the slide-in

Parameters
`animationSpec: FiniteAnimationSpec<IntOffset> = spring( stiffness = Spring.StiffnessMediumLow, visibilityThreshold = IntOffset.VisibilityThreshold, )`	the animation used for the slide-in, `spring` by default.
`initialOffsetX: (fullWidth: Int) -> Int = { -it / 2 }`	a lambda that takes the full width of the content in pixels and returns the initial offset for the slide-in, by default it returns `-fullWidth/2`

Parameters
`animationSpec: FiniteAnimationSpec<IntOffset> = spring( stiffness = Spring.StiffnessMediumLow, visibilityThreshold = IntOffset.VisibilityThreshold, )`	the animation used for the slide-in, `spring` by default.
`initialOffsetY: (fullHeight: Int) -> Int = { -it / 2 }`	a lambda that takes the full Height of the content and returns the initial offset for the slide-in, by default it returns `-fullHeight/2`

Parameters
`animationSpec: FiniteAnimationSpec<IntOffset> = spring( stiffness = Spring.StiffnessMediumLow, visibilityThreshold = IntOffset.VisibilityThreshold, )`	the animation used for the slide-out, `spring` by default.
`targetOffset: (fullSize: IntSize) -> IntOffset`	a lambda that takes the full size of the content and returns the target offset for the slide-out

Parameters
`animationSpec: FiniteAnimationSpec<IntOffset> = spring( stiffness = Spring.StiffnessMediumLow, visibilityThreshold = IntOffset.VisibilityThreshold, )`	the animation used for the slide-out, `spring` by default.
`targetOffsetX: (fullWidth: Int) -> Int = { -it / 2 }`	a lambda that takes the full width of the content and returns the initial offset for the slide-in, by default it returns `fullWidth/2`

Parameters
`animationSpec: FiniteAnimationSpec<IntOffset> = spring( stiffness = Spring.StiffnessMediumLow, visibilityThreshold = IntOffset.VisibilityThreshold, )`	the animation used for the slide-out, `spring` by default.
`targetOffsetY: (fullHeight: Int) -> Int = { -it / 2 }`	a lambda that takes the full Height of the content and returns the target offset for the slide-out, by default it returns `fullHeight/2`

Parameters
`visible: (T) -> Boolean`	defines whether the content should be visible based on transition state T
`modifier: Modifier = Modifier`	modifier for the `Layout` created to contain the `content`
`enter: EnterTransition = fadeIn() + expandIn()`	EnterTransition(s) used for the appearing animation, fading in while expanding vertically by default
`exit: ExitTransition = shrinkOut() + fadeOut()`	ExitTransition(s) used for the disappearing animation, fading out while shrinking vertically by default
`content: @Composable AnimatedVisibilityScope.() -> Unit`	Content to appear or disappear based on the visibility derived from the `Transition.targetState` and the provided `visible` lambda

Parameters
`lookaheadScope: LookaheadScope`	The scope from which this `animateBounds` will calculate its animations from. This implies that as long as you're expecting an animation the reference of the given `LookaheadScope` shouldn't change, otherwise you may get unexpected behavior.
`modifier: Modifier = Modifier`	Optional intermediate Modifier, may be used in cases where otherwise immediate layout changes are perceived as gradual by both the parent and child Layout.
`boundsTransform: BoundsTransform = DefaultBoundsTransform`	Produce a customized `FiniteAnimationSpec` based on the initial and target bounds, called when an animation is triggered.
`animateMotionFrameOfReference: Boolean = false`	When `true`, changes under `LayoutCoordinates.introducesMotionFrameOfReference` (for continuous positional changes, such as Scroll Offset) are included when calculating an animation. `false` by default, where the changes are instead applied directly into the layout without triggering an animation.

Parameters
`animationSpec: FiniteAnimationSpec<IntSize> = spring( stiffness = Spring.StiffnessMediumLow, visibilityThreshold = IntSize.VisibilityThreshold, )`	a finite animation that will be used to animate size change, `spring` by default
`finishedListener: ((initialValue: IntSize, targetValue: IntSize) -> Unit)? = null`	an optional listener to be called when the content change animation is completed.