// Signature format: 4.0
package androidx.lifecycle {

  public abstract class AbstractSavedStateViewModelFactory implements androidx.lifecycle.ViewModelProvider.Factory {
    ctor public AbstractSavedStateViewModelFactory(androidx.savedstate.SavedStateRegistryOwner, android.os.Bundle?);
    method public final <T extends androidx.lifecycle.ViewModel> T create(Class<T!>);
    method protected abstract <T extends androidx.lifecycle.ViewModel> T create(String, Class<T!>, androidx.lifecycle.SavedStateHandle);
  }

  public final class SavedStateHandle {
    ctor public SavedStateHandle(java.util.Map<java.lang.String!,java.lang.Object!>);
    ctor public SavedStateHandle();
    method @MainThread public void clearSavedStateProvider(String);
    method @MainThread public boolean contains(String);
    method @MainThread public <T> T? get(String);
    method @MainThread public <T> androidx.lifecycle.MutableLiveData<T!> getLiveData(String);
    method @MainThread public <T> androidx.lifecycle.MutableLiveData<T!> getLiveData(String, T!);
    method @MainThread public java.util.Set<java.lang.String!> keys();
    method @MainThread public <T> T? remove(String);
    method @MainThread public <T> void set(String, T?);
    method @MainThread public void setSavedStateProvider(String, androidx.savedstate.SavedStateRegistry.SavedStateProvider);
  }

  public final class SavedStateViewModelFactory implements androidx.lifecycle.ViewModelProvider.Factory {
    ctor public SavedStateViewModelFactory(android.app.Application?, androidx.savedstate.SavedStateRegistryOwner);
    ctor public SavedStateViewModelFactory(android.app.Application?, androidx.savedstate.SavedStateRegistryOwner, android.os.Bundle?);
    method public <T extends androidx.lifecycle.ViewModel> T create(String, Class<T!>);
    method public <T extends androidx.lifecycle.ViewModel> T create(Class<T!>);
  }

}

