androidx.navigation3.runtime

@Composable
fun <T : Any> DecorateNavEntry(
    entry: NavEntry<T>,
    entryDecorators: List<NavEntryDecorator<*>>
): Unit

Wraps a NavEntry with the list of NavEntryDecorator in the order that the decorators were added to the list and invokes the content of the wrapped entry.

@Composable
fun <T : Any> DecoratedNavEntryProvider(
    backStack: List<T>,
    entryProvider: (key) -> NavEntry<T>,
    entryDecorators: List<NavEntryDecorator<*>> = listOf(rememberSavedStateNavEntryDecorator()),
    content: @Composable (List<NavEntry<T>>) -> Unit
): Unit

Function that provides all of the NavEntrys wrapped with the given NavEntryDecorators. It is responsible for executing the functions provided by each NavEntryDecorator appropriately.

Note: the order in which the NavEntryDecorators are added to the list determines their scope, i.e. a NavEntryDecorator added earlier in a list has its data available to those added later.

inline fun <T : Any> NavBackStackSerializer(
    configuration: SavedStateConfiguration = SavedStateConfiguration.DEFAULT
): <Error class: unknown class><SnapshotStateList<T>>

Creates a KSerializer for a SnapshotStateList of T representing a back stack.

This factory configures element serialization for open or closed polymorphic stacks, returning a serializer suitable for saving/restoring a back stack with kotlinx.serialization.

Use this serializer when wiring a back stack (SnapshotStateList of T) into saved state (e.g., with rememberSerializable or any API that accepts a KSerializer).

Important: If T is polymorphic (e.g., a interface hierarchy), the encoder/decoder must be created with the same SerializersModule you used to obtain the serializer. The module lives on the Encoder/Decoder, not inside the KSerializer instance. That means:

• When you pass a custom SavedStateConfiguration, you must also pass that configuration (or at least its SerializersModule) to your Encoder/Decoder calls. Otherwise, polymorphic dispatch will fail at runtime with "Serializer for subclass ... is not found".

• The Android DEFAULT path uses a reflective serializer that is self-contained and does not require a module on the Encoder/Decoder.

Platform behavior:

• Android:

• With SavedStateConfiguration.DEFAULT, uses a reflective element serializer that works for any @Serializable subtype of T.

• With a custom SavedStateConfiguration, resolves the element serializer from the provided serializersModule (supporting open or closed polymorphism as configured).

• Limitation: reflective lookup does not preserve generic type parameters. For example, List<Foo> and List<Bar> are both treated as List<*>. If you need generic type support, supply an explicit SavedStateConfiguration with a registered SerializersModule.

• Non-Android:

• Always resolves the element serializer from the provided SavedStateConfiguration.serializersModule.

• You must register the hierarchy for T (e.g., polymorphic base + subclasses) in that module and also pass the same module to the Encoder/Decoder.

Closed vs. open polymorphism:

• Closed hierarchies (sealed classes) have all subtypes known at compile time, so serializers can be generated without a module.

• Open hierarchies (interfaces, non-sealed classes) require a SerializersModule to register subtypes for polymorphic dispatch.

Example

interface Screen
@Serializable data class Home(val id: String) : Screen
@Serializable data class Details(val itemId: Long) : Screen

val module = SerializersModule {
  polymorphic(Screen::class) {
    subclass(Home::class, Home.serializer())
    subclass(Details::class, Details.serializer())
  }
}
val configuration = SavedStateConfiguration(serializersModule = module)

val serializer = NavBackStackSerializer<Screen>(configuration)

// Pass the same configuration (or at least its serializersModule) to encode/decode:
val encoded = encodeToSavedState(configuration, serializer, backStack)
val decoded = decodeFromSavedState(configuration, serializer, encoded)

fun SavedStateNavEntryDecorator(saveableStateHolder: SaveableStateHolder): NavEntryDecorator<Any>

Wraps the content of a NavEntry with a SaveableStateHolder.SaveableStateProvider to ensure that calls to rememberSaveable within the content work properly and that state can be saved. Also provides the content of a NavEntry with a SavedStateRegistryOwner which can be accessed in the content with LocalSavedStateRegistryOwner.

This NavEntryDecorator is the only one that is required as saving state is considered a non-optional feature.

inline fun <T : Any> entryProvider(
    noinline fallback: (unknownScreen) -> NavEntry<T> = {
        throw IllegalStateException("Unknown screen $it")
    },
    builder: EntryProviderBuilder<T>.() -> Unit
): (T) -> NavEntry<T>

Creates an EntryProviderBuilder with the entry providers provided in the builder.

fun <T : Any> navEntryDecorator(
    onPop: (contentKey: Any) -> Unit = {},
    decorator: @Composable (entry: NavEntry<T>) -> Unit
): NavEntryDecorator<T>

Function to decorate the NavEntry that are integrated with a DecoratedNavEntryProvider.

Primary usages include but are not limited to:

1. provide information to entries with androidx.compose.runtime.CompositionLocal, i.e.

val decorator = navEntryDecorator<Any> { entry ->
   ...
   CompositionLocalProvider(LocalMyStateProvider provides myState) {
       entry.content.invoke(entry.key)
   }
}

1. Wrap entry content with other composable content

val decorator = navEntryDecorator<Any> { entry ->
   ...
   MyComposableFunction {
       entry.content.invoke(entry.key)
   }
}

@Composable
inline fun <T : NavKey> rememberNavBackStack(
    vararg elements: T,
    configuration: SavedStateConfiguration = SavedStateConfiguration.DEFAULT
): SnapshotStateList<NavKey>

Provides a NavBackStack that is automatically remembered in the Compose hierarchy across process death and configuration changes.

This function uses NavBackStackSerializer under the hood to save and restore the back stack via rememberSerializable.

Serialization requirements

• Each element placed in the NavBackStack must be @Serializable.

• For closed polymorphism (sealed hierarchies), the compiler knows all subtypes and generates serializers automatically. No custom SavedStateConfiguration is required.

• For open polymorphism (interfaces or non-sealed hierarchies):

• On Android, SavedStateConfiguration.DEFAULT uses a reflective serializer that can handle subtypes without registration.

• On other platforms, or when you supply a custom configuration, you must register all subtypes of NavKey in a SerializersModule and pass that via configuration. You must also provide the same configuration to the encoder/decoder when saving/restoring state.

Example

@Serializable sealed interface Screen : NavKey
@Serializable data class Home(val id: String) : Screen
@Serializable data class Details(val itemId: Long) : Screen

// Closed polymorphism with sealed interface works out of the box on Android:
val backStack = rememberNavBackStack(Home("sta

rt"))// Open polymorphism requires registering subtypes (non
-Android):val module = Serialize
rsModule {  polymorphic(Screen
::class) {    subclass(Home::class, Home.ser
ializer())    subclass(Details::class, Details.ser
ial
i
zer())  }}val config = SavedStateConfiguration(serializersModule
 = module)val backStack = rememberNavBackStack(Home("start"), configuration = config)

@Composable
fun rememberSavedStateNavEntryDecorator(
    saveableStateHolder: SaveableStateHolder = rememberSaveableStateHolder()
): NavEntryDecorator<Any>

Returns a SavedStateNavEntryDecorator that is remembered across recompositions.

inline fun <T : Any> EntryProviderBuilder<*>.entry(
    noinline clazzContentKey: (key) -> Any = { defaultContentKey(it) },
    metadata: Map<String, Any> = emptyMap(),
    noinline content: @Composable (T) -> Unit
): Unit

Add an entry provider to the EntryProviderBuilder

fun <T : Any> EntryProviderBuilder<T>.entry(
    key: T,
    contentKey: Any = defaultContentKey(key),
    metadata: Map<String, Any> = emptyMap(),
    content: @Composable (T) -> Unit
): Unit

Add an entry provider to the EntryProviderBuilder