diff --git a/buildSrc/src/main/kotlin/androidx/build/LibraryVersions.kt b/buildSrc/src/main/kotlin/androidx/build/LibraryVersions.kt
index a8354a8..937d8f7 100644
--- a/buildSrc/src/main/kotlin/androidx/build/LibraryVersions.kt
+++ b/buildSrc/src/main/kotlin/androidx/build/LibraryVersions.kt
@@ -56,7 +56,7 @@
     val CORE_ROLE = Version("1.1.0-alpha02")
     val CURSORADAPTER = Version("1.1.0-alpha01")
     val CUSTOMVIEW = Version("1.2.0-alpha01")
-    val DATASTORE = Version("1.0.0-alpha08")
+    val DATASTORE = Version("1.0.0-beta01")
     val DOCUMENTFILE = Version("1.1.0-alpha01")
     val DRAWERLAYOUT = Version("1.2.0-alpha01")
     val DYNAMICANIMATION = Version("1.1.0-alpha04")
diff --git a/datastore/datastore-core/api/1.0.0-beta01.txt b/datastore/datastore-core/api/1.0.0-beta01.txt
new file mode 100644
index 0000000..abfdd9c
--- /dev/null
+++ b/datastore/datastore-core/api/1.0.0-beta01.txt
@@ -0,0 +1,45 @@
+// Signature format: 4.0
+package androidx.datastore.core {
+
+  public final class CorruptionException extends java.io.IOException {
+    ctor public CorruptionException(String message, optional Throwable? cause);
+  }
+
+  public interface DataMigration<T> {
+    method public suspend Object? cleanUp(kotlin.coroutines.Continuation<? super kotlin.Unit> p);
+    method public suspend Object? migrate(T? currentData, kotlin.coroutines.Continuation<? super T> p);
+    method public suspend Object? shouldMigrate(T? currentData, kotlin.coroutines.Continuation<? super java.lang.Boolean> p);
+  }
+
+  public interface DataStore<T> {
+    method public kotlinx.coroutines.flow.Flow<T> getData();
+    method public suspend Object? updateData(kotlin.jvm.functions.Function2<? super T,? super kotlin.coroutines.Continuation<? super T>,?> transform, kotlin.coroutines.Continuation<? super T> p);
+    property public abstract kotlinx.coroutines.flow.Flow<T> data;
+  }
+
+  public final class DataStoreFactory {
+    method public <T> androidx.datastore.core.DataStore<T> create(androidx.datastore.core.Serializer<T> serializer, optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<T>? corruptionHandler, optional java.util.List<? extends androidx.datastore.core.DataMigration<T>> migrations, optional kotlinx.coroutines.CoroutineScope scope, kotlin.jvm.functions.Function0<? extends java.io.File> produceFile);
+    method public <T> androidx.datastore.core.DataStore<T> create(androidx.datastore.core.Serializer<T> serializer, optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<T>? corruptionHandler, optional java.util.List<? extends androidx.datastore.core.DataMigration<T>> migrations, kotlin.jvm.functions.Function0<? extends java.io.File> produceFile);
+    method public <T> androidx.datastore.core.DataStore<T> create(androidx.datastore.core.Serializer<T> serializer, optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<T>? corruptionHandler, kotlin.jvm.functions.Function0<? extends java.io.File> produceFile);
+    method public <T> androidx.datastore.core.DataStore<T> create(androidx.datastore.core.Serializer<T> serializer, kotlin.jvm.functions.Function0<? extends java.io.File> produceFile);
+    field public static final androidx.datastore.core.DataStoreFactory INSTANCE;
+  }
+
+  public interface Serializer<T> {
+    method public T! getDefaultValue();
+    method public suspend Object? readFrom(java.io.InputStream input, kotlin.coroutines.Continuation<? super T> p);
+    method public suspend Object? writeTo(T? t, java.io.OutputStream output, kotlin.coroutines.Continuation<? super kotlin.Unit> p);
+    property public abstract T! defaultValue;
+  }
+
+}
+
+package androidx.datastore.core.handlers {
+
+  public final class ReplaceFileCorruptionHandler<T> {
+    ctor public ReplaceFileCorruptionHandler(kotlin.jvm.functions.Function1<? super androidx.datastore.core.CorruptionException,? extends T> produceNewData);
+    method @kotlin.jvm.Throws(exceptionClasses=IOException::class) public suspend Object? handleCorruption(androidx.datastore.core.CorruptionException ex, kotlin.coroutines.Continuation<? super T> p) throws java.io.IOException;
+  }
+
+}
+
diff --git a/datastore/datastore-core/api/public_plus_experimental_1.0.0-beta01.txt b/datastore/datastore-core/api/public_plus_experimental_1.0.0-beta01.txt
new file mode 100644
index 0000000..abfdd9c
--- /dev/null
+++ b/datastore/datastore-core/api/public_plus_experimental_1.0.0-beta01.txt
@@ -0,0 +1,45 @@
+// Signature format: 4.0
+package androidx.datastore.core {
+
+  public final class CorruptionException extends java.io.IOException {
+    ctor public CorruptionException(String message, optional Throwable? cause);
+  }
+
+  public interface DataMigration<T> {
+    method public suspend Object? cleanUp(kotlin.coroutines.Continuation<? super kotlin.Unit> p);
+    method public suspend Object? migrate(T? currentData, kotlin.coroutines.Continuation<? super T> p);
+    method public suspend Object? shouldMigrate(T? currentData, kotlin.coroutines.Continuation<? super java.lang.Boolean> p);
+  }
+
+  public interface DataStore<T> {
+    method public kotlinx.coroutines.flow.Flow<T> getData();
+    method public suspend Object? updateData(kotlin.jvm.functions.Function2<? super T,? super kotlin.coroutines.Continuation<? super T>,?> transform, kotlin.coroutines.Continuation<? super T> p);
+    property public abstract kotlinx.coroutines.flow.Flow<T> data;
+  }
+
+  public final class DataStoreFactory {
+    method public <T> androidx.datastore.core.DataStore<T> create(androidx.datastore.core.Serializer<T> serializer, optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<T>? corruptionHandler, optional java.util.List<? extends androidx.datastore.core.DataMigration<T>> migrations, optional kotlinx.coroutines.CoroutineScope scope, kotlin.jvm.functions.Function0<? extends java.io.File> produceFile);
+    method public <T> androidx.datastore.core.DataStore<T> create(androidx.datastore.core.Serializer<T> serializer, optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<T>? corruptionHandler, optional java.util.List<? extends androidx.datastore.core.DataMigration<T>> migrations, kotlin.jvm.functions.Function0<? extends java.io.File> produceFile);
+    method public <T> androidx.datastore.core.DataStore<T> create(androidx.datastore.core.Serializer<T> serializer, optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<T>? corruptionHandler, kotlin.jvm.functions.Function0<? extends java.io.File> produceFile);
+    method public <T> androidx.datastore.core.DataStore<T> create(androidx.datastore.core.Serializer<T> serializer, kotlin.jvm.functions.Function0<? extends java.io.File> produceFile);
+    field public static final androidx.datastore.core.DataStoreFactory INSTANCE;
+  }
+
+  public interface Serializer<T> {
+    method public T! getDefaultValue();
+    method public suspend Object? readFrom(java.io.InputStream input, kotlin.coroutines.Continuation<? super T> p);
+    method public suspend Object? writeTo(T? t, java.io.OutputStream output, kotlin.coroutines.Continuation<? super kotlin.Unit> p);
+    property public abstract T! defaultValue;
+  }
+
+}
+
+package androidx.datastore.core.handlers {
+
+  public final class ReplaceFileCorruptionHandler<T> {
+    ctor public ReplaceFileCorruptionHandler(kotlin.jvm.functions.Function1<? super androidx.datastore.core.CorruptionException,? extends T> produceNewData);
+    method @kotlin.jvm.Throws(exceptionClasses=IOException::class) public suspend Object? handleCorruption(androidx.datastore.core.CorruptionException ex, kotlin.coroutines.Continuation<? super T> p) throws java.io.IOException;
+  }
+
+}
+
diff --git a/datastore/datastore-core/api/restricted_1.0.0-beta01.txt b/datastore/datastore-core/api/restricted_1.0.0-beta01.txt
new file mode 100644
index 0000000..abfdd9c
--- /dev/null
+++ b/datastore/datastore-core/api/restricted_1.0.0-beta01.txt
@@ -0,0 +1,45 @@
+// Signature format: 4.0
+package androidx.datastore.core {
+
+  public final class CorruptionException extends java.io.IOException {
+    ctor public CorruptionException(String message, optional Throwable? cause);
+  }
+
+  public interface DataMigration<T> {
+    method public suspend Object? cleanUp(kotlin.coroutines.Continuation<? super kotlin.Unit> p);
+    method public suspend Object? migrate(T? currentData, kotlin.coroutines.Continuation<? super T> p);
+    method public suspend Object? shouldMigrate(T? currentData, kotlin.coroutines.Continuation<? super java.lang.Boolean> p);
+  }
+
+  public interface DataStore<T> {
+    method public kotlinx.coroutines.flow.Flow<T> getData();
+    method public suspend Object? updateData(kotlin.jvm.functions.Function2<? super T,? super kotlin.coroutines.Continuation<? super T>,?> transform, kotlin.coroutines.Continuation<? super T> p);
+    property public abstract kotlinx.coroutines.flow.Flow<T> data;
+  }
+
+  public final class DataStoreFactory {
+    method public <T> androidx.datastore.core.DataStore<T> create(androidx.datastore.core.Serializer<T> serializer, optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<T>? corruptionHandler, optional java.util.List<? extends androidx.datastore.core.DataMigration<T>> migrations, optional kotlinx.coroutines.CoroutineScope scope, kotlin.jvm.functions.Function0<? extends java.io.File> produceFile);
+    method public <T> androidx.datastore.core.DataStore<T> create(androidx.datastore.core.Serializer<T> serializer, optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<T>? corruptionHandler, optional java.util.List<? extends androidx.datastore.core.DataMigration<T>> migrations, kotlin.jvm.functions.Function0<? extends java.io.File> produceFile);
+    method public <T> androidx.datastore.core.DataStore<T> create(androidx.datastore.core.Serializer<T> serializer, optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<T>? corruptionHandler, kotlin.jvm.functions.Function0<? extends java.io.File> produceFile);
+    method public <T> androidx.datastore.core.DataStore<T> create(androidx.datastore.core.Serializer<T> serializer, kotlin.jvm.functions.Function0<? extends java.io.File> produceFile);
+    field public static final androidx.datastore.core.DataStoreFactory INSTANCE;
+  }
+
+  public interface Serializer<T> {
+    method public T! getDefaultValue();
+    method public suspend Object? readFrom(java.io.InputStream input, kotlin.coroutines.Continuation<? super T> p);
+    method public suspend Object? writeTo(T? t, java.io.OutputStream output, kotlin.coroutines.Continuation<? super kotlin.Unit> p);
+    property public abstract T! defaultValue;
+  }
+
+}
+
+package androidx.datastore.core.handlers {
+
+  public final class ReplaceFileCorruptionHandler<T> {
+    ctor public ReplaceFileCorruptionHandler(kotlin.jvm.functions.Function1<? super androidx.datastore.core.CorruptionException,? extends T> produceNewData);
+    method @kotlin.jvm.Throws(exceptionClasses=IOException::class) public suspend Object? handleCorruption(androidx.datastore.core.CorruptionException ex, kotlin.coroutines.Continuation<? super T> p) throws java.io.IOException;
+  }
+
+}
+
diff --git a/datastore/datastore-preferences-core/api/1.0.0-beta01.txt b/datastore/datastore-preferences-core/api/1.0.0-beta01.txt
new file mode 100644
index 0000000..1b3e2d0
--- /dev/null
+++ b/datastore/datastore-preferences-core/api/1.0.0-beta01.txt
@@ -0,0 +1,63 @@
+// Signature format: 4.0
+package androidx.datastore.preferences.core {
+
+  public final class MutablePreferences extends androidx.datastore.preferences.core.Preferences {
+    method public java.util.Map<androidx.datastore.preferences.core.Preferences.Key<?>,java.lang.Object> asMap();
+    method public void clear();
+    method public operator <T> boolean contains(androidx.datastore.preferences.core.Preferences.Key<T> key);
+    method public operator <T> T? get(androidx.datastore.preferences.core.Preferences.Key<T> key);
+    method public operator void minusAssign(androidx.datastore.preferences.core.Preferences.Key<?> key);
+    method public operator void plusAssign(androidx.datastore.preferences.core.Preferences prefs);
+    method public operator void plusAssign(androidx.datastore.preferences.core.Preferences.Pair<?> pair);
+    method public void putAll(androidx.datastore.preferences.core.Preferences.Pair<?>... pairs);
+    method public <T> T! remove(androidx.datastore.preferences.core.Preferences.Key<T> key);
+    method public operator <T> void set(androidx.datastore.preferences.core.Preferences.Key<T> key, T? value);
+  }
+
+  public final class PreferenceDataStoreFactory {
+    method public androidx.datastore.core.DataStore<androidx.datastore.preferences.core.Preferences> create(optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<androidx.datastore.preferences.core.Preferences>? corruptionHandler, optional java.util.List<? extends androidx.datastore.core.DataMigration<androidx.datastore.preferences.core.Preferences>> migrations, optional kotlinx.coroutines.CoroutineScope scope, kotlin.jvm.functions.Function0<? extends java.io.File> produceFile);
+    method public androidx.datastore.core.DataStore<androidx.datastore.preferences.core.Preferences> create(optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<androidx.datastore.preferences.core.Preferences>? corruptionHandler, optional java.util.List<? extends androidx.datastore.core.DataMigration<androidx.datastore.preferences.core.Preferences>> migrations, kotlin.jvm.functions.Function0<? extends java.io.File> produceFile);
+    method public androidx.datastore.core.DataStore<androidx.datastore.preferences.core.Preferences> create(optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<androidx.datastore.preferences.core.Preferences>? corruptionHandler, kotlin.jvm.functions.Function0<? extends java.io.File> produceFile);
+    method public androidx.datastore.core.DataStore<androidx.datastore.preferences.core.Preferences> create(kotlin.jvm.functions.Function0<? extends java.io.File> produceFile);
+    field public static final androidx.datastore.preferences.core.PreferenceDataStoreFactory INSTANCE;
+  }
+
+  public abstract class Preferences {
+    method public abstract java.util.Map<androidx.datastore.preferences.core.Preferences.Key<?>,java.lang.Object> asMap();
+    method public abstract operator <T> boolean contains(androidx.datastore.preferences.core.Preferences.Key<T> key);
+    method public abstract operator <T> T? get(androidx.datastore.preferences.core.Preferences.Key<T> key);
+    method public final androidx.datastore.preferences.core.MutablePreferences toMutablePreferences();
+    method public final androidx.datastore.preferences.core.Preferences toPreferences();
+  }
+
+  public static final class Preferences.Key<T> {
+    method public String getName();
+    method public infix androidx.datastore.preferences.core.Preferences.Pair<T> to(T? value);
+    property public final String name;
+  }
+
+  public static final class Preferences.Pair<T> {
+  }
+
+  public final class PreferencesFactory {
+    method public static androidx.datastore.preferences.core.Preferences create(androidx.datastore.preferences.core.Preferences.Pair<?>... pairs);
+    method public static androidx.datastore.preferences.core.Preferences createEmpty();
+    method public static androidx.datastore.preferences.core.MutablePreferences createMutable(androidx.datastore.preferences.core.Preferences.Pair<?>... pairs);
+  }
+
+  public final class PreferencesKeys {
+    method public static androidx.datastore.preferences.core.Preferences.Key<java.lang.Boolean> booleanKey(String name);
+    method public static androidx.datastore.preferences.core.Preferences.Key<java.lang.Double> doubleKey(String name);
+    method public static androidx.datastore.preferences.core.Preferences.Key<java.lang.Float> floatKey(String name);
+    method public static androidx.datastore.preferences.core.Preferences.Key<java.lang.Integer> intKey(String name);
+    method public static androidx.datastore.preferences.core.Preferences.Key<java.lang.Long> longKey(String name);
+    method public static androidx.datastore.preferences.core.Preferences.Key<java.lang.String> stringKey(String name);
+    method public static androidx.datastore.preferences.core.Preferences.Key<java.util.Set<java.lang.String>> stringSetKey(String name);
+  }
+
+  public final class PreferencesKt {
+    method public static suspend Object? edit(androidx.datastore.core.DataStore<androidx.datastore.preferences.core.Preferences>, kotlin.jvm.functions.Function2<? super androidx.datastore.preferences.core.MutablePreferences,? super kotlin.coroutines.Continuation<? super kotlin.Unit>,?> transform, kotlin.coroutines.Continuation<? super androidx.datastore.preferences.core.Preferences> p);
+  }
+
+}
+
diff --git a/datastore/datastore-preferences-core/api/public_plus_experimental_1.0.0-beta01.txt b/datastore/datastore-preferences-core/api/public_plus_experimental_1.0.0-beta01.txt
new file mode 100644
index 0000000..1b3e2d0
--- /dev/null
+++ b/datastore/datastore-preferences-core/api/public_plus_experimental_1.0.0-beta01.txt
@@ -0,0 +1,63 @@
+// Signature format: 4.0
+package androidx.datastore.preferences.core {
+
+  public final class MutablePreferences extends androidx.datastore.preferences.core.Preferences {
+    method public java.util.Map<androidx.datastore.preferences.core.Preferences.Key<?>,java.lang.Object> asMap();
+    method public void clear();
+    method public operator <T> boolean contains(androidx.datastore.preferences.core.Preferences.Key<T> key);
+    method public operator <T> T? get(androidx.datastore.preferences.core.Preferences.Key<T> key);
+    method public operator void minusAssign(androidx.datastore.preferences.core.Preferences.Key<?> key);
+    method public operator void plusAssign(androidx.datastore.preferences.core.Preferences prefs);
+    method public operator void plusAssign(androidx.datastore.preferences.core.Preferences.Pair<?> pair);
+    method public void putAll(androidx.datastore.preferences.core.Preferences.Pair<?>... pairs);
+    method public <T> T! remove(androidx.datastore.preferences.core.Preferences.Key<T> key);
+    method public operator <T> void set(androidx.datastore.preferences.core.Preferences.Key<T> key, T? value);
+  }
+
+  public final class PreferenceDataStoreFactory {
+    method public androidx.datastore.core.DataStore<androidx.datastore.preferences.core.Preferences> create(optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<androidx.datastore.preferences.core.Preferences>? corruptionHandler, optional java.util.List<? extends androidx.datastore.core.DataMigration<androidx.datastore.preferences.core.Preferences>> migrations, optional kotlinx.coroutines.CoroutineScope scope, kotlin.jvm.functions.Function0<? extends java.io.File> produceFile);
+    method public androidx.datastore.core.DataStore<androidx.datastore.preferences.core.Preferences> create(optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<androidx.datastore.preferences.core.Preferences>? corruptionHandler, optional java.util.List<? extends androidx.datastore.core.DataMigration<androidx.datastore.preferences.core.Preferences>> migrations, kotlin.jvm.functions.Function0<? extends java.io.File> produceFile);
+    method public androidx.datastore.core.DataStore<androidx.datastore.preferences.core.Preferences> create(optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<androidx.datastore.preferences.core.Preferences>? corruptionHandler, kotlin.jvm.functions.Function0<? extends java.io.File> produceFile);
+    method public androidx.datastore.core.DataStore<androidx.datastore.preferences.core.Preferences> create(kotlin.jvm.functions.Function0<? extends java.io.File> produceFile);
+    field public static final androidx.datastore.preferences.core.PreferenceDataStoreFactory INSTANCE;
+  }
+
+  public abstract class Preferences {
+    method public abstract java.util.Map<androidx.datastore.preferences.core.Preferences.Key<?>,java.lang.Object> asMap();
+    method public abstract operator <T> boolean contains(androidx.datastore.preferences.core.Preferences.Key<T> key);
+    method public abstract operator <T> T? get(androidx.datastore.preferences.core.Preferences.Key<T> key);
+    method public final androidx.datastore.preferences.core.MutablePreferences toMutablePreferences();
+    method public final androidx.datastore.preferences.core.Preferences toPreferences();
+  }
+
+  public static final class Preferences.Key<T> {
+    method public String getName();
+    method public infix androidx.datastore.preferences.core.Preferences.Pair<T> to(T? value);
+    property public final String name;
+  }
+
+  public static final class Preferences.Pair<T> {
+  }
+
+  public final class PreferencesFactory {
+    method public static androidx.datastore.preferences.core.Preferences create(androidx.datastore.preferences.core.Preferences.Pair<?>... pairs);
+    method public static androidx.datastore.preferences.core.Preferences createEmpty();
+    method public static androidx.datastore.preferences.core.MutablePreferences createMutable(androidx.datastore.preferences.core.Preferences.Pair<?>... pairs);
+  }
+
+  public final class PreferencesKeys {
+    method public static androidx.datastore.preferences.core.Preferences.Key<java.lang.Boolean> booleanKey(String name);
+    method public static androidx.datastore.preferences.core.Preferences.Key<java.lang.Double> doubleKey(String name);
+    method public static androidx.datastore.preferences.core.Preferences.Key<java.lang.Float> floatKey(String name);
+    method public static androidx.datastore.preferences.core.Preferences.Key<java.lang.Integer> intKey(String name);
+    method public static androidx.datastore.preferences.core.Preferences.Key<java.lang.Long> longKey(String name);
+    method public static androidx.datastore.preferences.core.Preferences.Key<java.lang.String> stringKey(String name);
+    method public static androidx.datastore.preferences.core.Preferences.Key<java.util.Set<java.lang.String>> stringSetKey(String name);
+  }
+
+  public final class PreferencesKt {
+    method public static suspend Object? edit(androidx.datastore.core.DataStore<androidx.datastore.preferences.core.Preferences>, kotlin.jvm.functions.Function2<? super androidx.datastore.preferences.core.MutablePreferences,? super kotlin.coroutines.Continuation<? super kotlin.Unit>,?> transform, kotlin.coroutines.Continuation<? super androidx.datastore.preferences.core.Preferences> p);
+  }
+
+}
+
diff --git a/datastore/datastore-preferences-core/api/restricted_1.0.0-beta01.txt b/datastore/datastore-preferences-core/api/restricted_1.0.0-beta01.txt
new file mode 100644
index 0000000..1b3e2d0
--- /dev/null
+++ b/datastore/datastore-preferences-core/api/restricted_1.0.0-beta01.txt
@@ -0,0 +1,63 @@
+// Signature format: 4.0
+package androidx.datastore.preferences.core {
+
+  public final class MutablePreferences extends androidx.datastore.preferences.core.Preferences {
+    method public java.util.Map<androidx.datastore.preferences.core.Preferences.Key<?>,java.lang.Object> asMap();
+    method public void clear();
+    method public operator <T> boolean contains(androidx.datastore.preferences.core.Preferences.Key<T> key);
+    method public operator <T> T? get(androidx.datastore.preferences.core.Preferences.Key<T> key);
+    method public operator void minusAssign(androidx.datastore.preferences.core.Preferences.Key<?> key);
+    method public operator void plusAssign(androidx.datastore.preferences.core.Preferences prefs);
+    method public operator void plusAssign(androidx.datastore.preferences.core.Preferences.Pair<?> pair);
+    method public void putAll(androidx.datastore.preferences.core.Preferences.Pair<?>... pairs);
+    method public <T> T! remove(androidx.datastore.preferences.core.Preferences.Key<T> key);
+    method public operator <T> void set(androidx.datastore.preferences.core.Preferences.Key<T> key, T? value);
+  }
+
+  public final class PreferenceDataStoreFactory {
+    method public androidx.datastore.core.DataStore<androidx.datastore.preferences.core.Preferences> create(optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<androidx.datastore.preferences.core.Preferences>? corruptionHandler, optional java.util.List<? extends androidx.datastore.core.DataMigration<androidx.datastore.preferences.core.Preferences>> migrations, optional kotlinx.coroutines.CoroutineScope scope, kotlin.jvm.functions.Function0<? extends java.io.File> produceFile);
+    method public androidx.datastore.core.DataStore<androidx.datastore.preferences.core.Preferences> create(optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<androidx.datastore.preferences.core.Preferences>? corruptionHandler, optional java.util.List<? extends androidx.datastore.core.DataMigration<androidx.datastore.preferences.core.Preferences>> migrations, kotlin.jvm.functions.Function0<? extends java.io.File> produceFile);
+    method public androidx.datastore.core.DataStore<androidx.datastore.preferences.core.Preferences> create(optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<androidx.datastore.preferences.core.Preferences>? corruptionHandler, kotlin.jvm.functions.Function0<? extends java.io.File> produceFile);
+    method public androidx.datastore.core.DataStore<androidx.datastore.preferences.core.Preferences> create(kotlin.jvm.functions.Function0<? extends java.io.File> produceFile);
+    field public static final androidx.datastore.preferences.core.PreferenceDataStoreFactory INSTANCE;
+  }
+
+  public abstract class Preferences {
+    method public abstract java.util.Map<androidx.datastore.preferences.core.Preferences.Key<?>,java.lang.Object> asMap();
+    method public abstract operator <T> boolean contains(androidx.datastore.preferences.core.Preferences.Key<T> key);
+    method public abstract operator <T> T? get(androidx.datastore.preferences.core.Preferences.Key<T> key);
+    method public final androidx.datastore.preferences.core.MutablePreferences toMutablePreferences();
+    method public final androidx.datastore.preferences.core.Preferences toPreferences();
+  }
+
+  public static final class Preferences.Key<T> {
+    method public String getName();
+    method public infix androidx.datastore.preferences.core.Preferences.Pair<T> to(T? value);
+    property public final String name;
+  }
+
+  public static final class Preferences.Pair<T> {
+  }
+
+  public final class PreferencesFactory {
+    method public static androidx.datastore.preferences.core.Preferences create(androidx.datastore.preferences.core.Preferences.Pair<?>... pairs);
+    method public static androidx.datastore.preferences.core.Preferences createEmpty();
+    method public static androidx.datastore.preferences.core.MutablePreferences createMutable(androidx.datastore.preferences.core.Preferences.Pair<?>... pairs);
+  }
+
+  public final class PreferencesKeys {
+    method public static androidx.datastore.preferences.core.Preferences.Key<java.lang.Boolean> booleanKey(String name);
+    method public static androidx.datastore.preferences.core.Preferences.Key<java.lang.Double> doubleKey(String name);
+    method public static androidx.datastore.preferences.core.Preferences.Key<java.lang.Float> floatKey(String name);
+    method public static androidx.datastore.preferences.core.Preferences.Key<java.lang.Integer> intKey(String name);
+    method public static androidx.datastore.preferences.core.Preferences.Key<java.lang.Long> longKey(String name);
+    method public static androidx.datastore.preferences.core.Preferences.Key<java.lang.String> stringKey(String name);
+    method public static androidx.datastore.preferences.core.Preferences.Key<java.util.Set<java.lang.String>> stringSetKey(String name);
+  }
+
+  public final class PreferencesKt {
+    method public static suspend Object? edit(androidx.datastore.core.DataStore<androidx.datastore.preferences.core.Preferences>, kotlin.jvm.functions.Function2<? super androidx.datastore.preferences.core.MutablePreferences,? super kotlin.coroutines.Continuation<? super kotlin.Unit>,?> transform, kotlin.coroutines.Continuation<? super androidx.datastore.preferences.core.Preferences> p);
+  }
+
+}
+
diff --git a/datastore/datastore-preferences-rxjava2/api/1.0.0-beta01.txt b/datastore/datastore-preferences-rxjava2/api/1.0.0-beta01.txt
new file mode 100644
index 0000000..66b2ceb
--- /dev/null
+++ b/datastore/datastore-preferences-rxjava2/api/1.0.0-beta01.txt
@@ -0,0 +1,19 @@
+// Signature format: 4.0
+package androidx.datastore.preferences.rxjava2 {
+
+  public final class RxPreferenceDataStoreBuilder {
+    ctor public RxPreferenceDataStoreBuilder(java.util.concurrent.Callable<java.io.File> produceFile);
+    ctor public RxPreferenceDataStoreBuilder(android.content.Context context, String name);
+    method public androidx.datastore.preferences.rxjava2.RxPreferenceDataStoreBuilder addDataMigration(androidx.datastore.core.DataMigration<androidx.datastore.preferences.core.Preferences> dataMigration);
+    method public androidx.datastore.preferences.rxjava2.RxPreferenceDataStoreBuilder addRxDataMigration(androidx.datastore.rxjava2.RxDataMigration<androidx.datastore.preferences.core.Preferences> rxDataMigration);
+    method public androidx.datastore.rxjava2.RxDataStore<androidx.datastore.preferences.core.Preferences> build();
+    method public androidx.datastore.preferences.rxjava2.RxPreferenceDataStoreBuilder setCorruptionHandler(androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<androidx.datastore.preferences.core.Preferences> corruptionHandler);
+    method public androidx.datastore.preferences.rxjava2.RxPreferenceDataStoreBuilder setIoScheduler(io.reactivex.Scheduler ioScheduler);
+  }
+
+  public final class RxPreferenceDataStoreDelegateKt {
+    method public static kotlin.properties.ReadOnlyProperty<android.content.Context,androidx.datastore.rxjava2.RxDataStore<androidx.datastore.preferences.core.Preferences>> rxPreferencesDataStore(String name, optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<androidx.datastore.preferences.core.Preferences>? corruptionHandler, optional kotlin.jvm.functions.Function1<? super android.content.Context,? extends java.util.List<? extends androidx.datastore.core.DataMigration<androidx.datastore.preferences.core.Preferences>>> produceMigrations, optional io.reactivex.Scheduler scheduler);
+  }
+
+}
+
diff --git a/datastore/datastore-preferences-rxjava2/api/public_plus_experimental_1.0.0-beta01.txt b/datastore/datastore-preferences-rxjava2/api/public_plus_experimental_1.0.0-beta01.txt
new file mode 100644
index 0000000..66b2ceb
--- /dev/null
+++ b/datastore/datastore-preferences-rxjava2/api/public_plus_experimental_1.0.0-beta01.txt
@@ -0,0 +1,19 @@
+// Signature format: 4.0
+package androidx.datastore.preferences.rxjava2 {
+
+  public final class RxPreferenceDataStoreBuilder {
+    ctor public RxPreferenceDataStoreBuilder(java.util.concurrent.Callable<java.io.File> produceFile);
+    ctor public RxPreferenceDataStoreBuilder(android.content.Context context, String name);
+    method public androidx.datastore.preferences.rxjava2.RxPreferenceDataStoreBuilder addDataMigration(androidx.datastore.core.DataMigration<androidx.datastore.preferences.core.Preferences> dataMigration);
+    method public androidx.datastore.preferences.rxjava2.RxPreferenceDataStoreBuilder addRxDataMigration(androidx.datastore.rxjava2.RxDataMigration<androidx.datastore.preferences.core.Preferences> rxDataMigration);
+    method public androidx.datastore.rxjava2.RxDataStore<androidx.datastore.preferences.core.Preferences> build();
+    method public androidx.datastore.preferences.rxjava2.RxPreferenceDataStoreBuilder setCorruptionHandler(androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<androidx.datastore.preferences.core.Preferences> corruptionHandler);
+    method public androidx.datastore.preferences.rxjava2.RxPreferenceDataStoreBuilder setIoScheduler(io.reactivex.Scheduler ioScheduler);
+  }
+
+  public final class RxPreferenceDataStoreDelegateKt {
+    method public static kotlin.properties.ReadOnlyProperty<android.content.Context,androidx.datastore.rxjava2.RxDataStore<androidx.datastore.preferences.core.Preferences>> rxPreferencesDataStore(String name, optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<androidx.datastore.preferences.core.Preferences>? corruptionHandler, optional kotlin.jvm.functions.Function1<? super android.content.Context,? extends java.util.List<? extends androidx.datastore.core.DataMigration<androidx.datastore.preferences.core.Preferences>>> produceMigrations, optional io.reactivex.Scheduler scheduler);
+  }
+
+}
+
diff --git a/datastore/datastore-preferences-rxjava2/api/res-1.0.0-beta01.txt b/datastore/datastore-preferences-rxjava2/api/res-1.0.0-beta01.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/datastore/datastore-preferences-rxjava2/api/res-1.0.0-beta01.txt
diff --git a/datastore/datastore-preferences-rxjava2/api/restricted_1.0.0-beta01.txt b/datastore/datastore-preferences-rxjava2/api/restricted_1.0.0-beta01.txt
new file mode 100644
index 0000000..66b2ceb
--- /dev/null
+++ b/datastore/datastore-preferences-rxjava2/api/restricted_1.0.0-beta01.txt
@@ -0,0 +1,19 @@
+// Signature format: 4.0
+package androidx.datastore.preferences.rxjava2 {
+
+  public final class RxPreferenceDataStoreBuilder {
+    ctor public RxPreferenceDataStoreBuilder(java.util.concurrent.Callable<java.io.File> produceFile);
+    ctor public RxPreferenceDataStoreBuilder(android.content.Context context, String name);
+    method public androidx.datastore.preferences.rxjava2.RxPreferenceDataStoreBuilder addDataMigration(androidx.datastore.core.DataMigration<androidx.datastore.preferences.core.Preferences> dataMigration);
+    method public androidx.datastore.preferences.rxjava2.RxPreferenceDataStoreBuilder addRxDataMigration(androidx.datastore.rxjava2.RxDataMigration<androidx.datastore.preferences.core.Preferences> rxDataMigration);
+    method public androidx.datastore.rxjava2.RxDataStore<androidx.datastore.preferences.core.Preferences> build();
+    method public androidx.datastore.preferences.rxjava2.RxPreferenceDataStoreBuilder setCorruptionHandler(androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<androidx.datastore.preferences.core.Preferences> corruptionHandler);
+    method public androidx.datastore.preferences.rxjava2.RxPreferenceDataStoreBuilder setIoScheduler(io.reactivex.Scheduler ioScheduler);
+  }
+
+  public final class RxPreferenceDataStoreDelegateKt {
+    method public static kotlin.properties.ReadOnlyProperty<android.content.Context,androidx.datastore.rxjava2.RxDataStore<androidx.datastore.preferences.core.Preferences>> rxPreferencesDataStore(String name, optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<androidx.datastore.preferences.core.Preferences>? corruptionHandler, optional kotlin.jvm.functions.Function1<? super android.content.Context,? extends java.util.List<? extends androidx.datastore.core.DataMigration<androidx.datastore.preferences.core.Preferences>>> produceMigrations, optional io.reactivex.Scheduler scheduler);
+  }
+
+}
+
diff --git a/datastore/datastore-preferences-rxjava3/api/1.0.0-beta01.txt b/datastore/datastore-preferences-rxjava3/api/1.0.0-beta01.txt
new file mode 100644
index 0000000..4e0b0bf
--- /dev/null
+++ b/datastore/datastore-preferences-rxjava3/api/1.0.0-beta01.txt
@@ -0,0 +1,19 @@
+// Signature format: 4.0
+package androidx.datastore.preferences.rxjava3 {
+
+  public final class RxPreferenceDataStoreBuilder {
+    ctor public RxPreferenceDataStoreBuilder(java.util.concurrent.Callable<java.io.File> produceFile);
+    ctor public RxPreferenceDataStoreBuilder(android.content.Context context, String name);
+    method public androidx.datastore.preferences.rxjava3.RxPreferenceDataStoreBuilder addDataMigration(androidx.datastore.core.DataMigration<androidx.datastore.preferences.core.Preferences> dataMigration);
+    method public androidx.datastore.preferences.rxjava3.RxPreferenceDataStoreBuilder addRxDataMigration(androidx.datastore.rxjava3.RxDataMigration<androidx.datastore.preferences.core.Preferences> rxDataMigration);
+    method public androidx.datastore.rxjava3.RxDataStore<androidx.datastore.preferences.core.Preferences> build();
+    method public androidx.datastore.preferences.rxjava3.RxPreferenceDataStoreBuilder setCorruptionHandler(androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<androidx.datastore.preferences.core.Preferences> corruptionHandler);
+    method public androidx.datastore.preferences.rxjava3.RxPreferenceDataStoreBuilder setIoScheduler(io.reactivex.rxjava3.core.Scheduler ioScheduler);
+  }
+
+  public final class RxPreferenceDataStoreDelegateKt {
+    method public static kotlin.properties.ReadOnlyProperty<android.content.Context,androidx.datastore.rxjava3.RxDataStore<androidx.datastore.preferences.core.Preferences>> rxPreferencesDataStore(String name, optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<androidx.datastore.preferences.core.Preferences>? corruptionHandler, optional kotlin.jvm.functions.Function1<? super android.content.Context,? extends java.util.List<? extends androidx.datastore.core.DataMigration<androidx.datastore.preferences.core.Preferences>>> produceMigrations, optional io.reactivex.rxjava3.core.Scheduler scheduler);
+  }
+
+}
+
diff --git a/datastore/datastore-preferences-rxjava3/api/public_plus_experimental_1.0.0-beta01.txt b/datastore/datastore-preferences-rxjava3/api/public_plus_experimental_1.0.0-beta01.txt
new file mode 100644
index 0000000..4e0b0bf
--- /dev/null
+++ b/datastore/datastore-preferences-rxjava3/api/public_plus_experimental_1.0.0-beta01.txt
@@ -0,0 +1,19 @@
+// Signature format: 4.0
+package androidx.datastore.preferences.rxjava3 {
+
+  public final class RxPreferenceDataStoreBuilder {
+    ctor public RxPreferenceDataStoreBuilder(java.util.concurrent.Callable<java.io.File> produceFile);
+    ctor public RxPreferenceDataStoreBuilder(android.content.Context context, String name);
+    method public androidx.datastore.preferences.rxjava3.RxPreferenceDataStoreBuilder addDataMigration(androidx.datastore.core.DataMigration<androidx.datastore.preferences.core.Preferences> dataMigration);
+    method public androidx.datastore.preferences.rxjava3.RxPreferenceDataStoreBuilder addRxDataMigration(androidx.datastore.rxjava3.RxDataMigration<androidx.datastore.preferences.core.Preferences> rxDataMigration);
+    method public androidx.datastore.rxjava3.RxDataStore<androidx.datastore.preferences.core.Preferences> build();
+    method public androidx.datastore.preferences.rxjava3.RxPreferenceDataStoreBuilder setCorruptionHandler(androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<androidx.datastore.preferences.core.Preferences> corruptionHandler);
+    method public androidx.datastore.preferences.rxjava3.RxPreferenceDataStoreBuilder setIoScheduler(io.reactivex.rxjava3.core.Scheduler ioScheduler);
+  }
+
+  public final class RxPreferenceDataStoreDelegateKt {
+    method public static kotlin.properties.ReadOnlyProperty<android.content.Context,androidx.datastore.rxjava3.RxDataStore<androidx.datastore.preferences.core.Preferences>> rxPreferencesDataStore(String name, optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<androidx.datastore.preferences.core.Preferences>? corruptionHandler, optional kotlin.jvm.functions.Function1<? super android.content.Context,? extends java.util.List<? extends androidx.datastore.core.DataMigration<androidx.datastore.preferences.core.Preferences>>> produceMigrations, optional io.reactivex.rxjava3.core.Scheduler scheduler);
+  }
+
+}
+
diff --git a/datastore/datastore-preferences-rxjava3/api/res-1.0.0-beta01.txt b/datastore/datastore-preferences-rxjava3/api/res-1.0.0-beta01.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/datastore/datastore-preferences-rxjava3/api/res-1.0.0-beta01.txt
diff --git a/datastore/datastore-preferences-rxjava3/api/restricted_1.0.0-beta01.txt b/datastore/datastore-preferences-rxjava3/api/restricted_1.0.0-beta01.txt
new file mode 100644
index 0000000..4e0b0bf
--- /dev/null
+++ b/datastore/datastore-preferences-rxjava3/api/restricted_1.0.0-beta01.txt
@@ -0,0 +1,19 @@
+// Signature format: 4.0
+package androidx.datastore.preferences.rxjava3 {
+
+  public final class RxPreferenceDataStoreBuilder {
+    ctor public RxPreferenceDataStoreBuilder(java.util.concurrent.Callable<java.io.File> produceFile);
+    ctor public RxPreferenceDataStoreBuilder(android.content.Context context, String name);
+    method public androidx.datastore.preferences.rxjava3.RxPreferenceDataStoreBuilder addDataMigration(androidx.datastore.core.DataMigration<androidx.datastore.preferences.core.Preferences> dataMigration);
+    method public androidx.datastore.preferences.rxjava3.RxPreferenceDataStoreBuilder addRxDataMigration(androidx.datastore.rxjava3.RxDataMigration<androidx.datastore.preferences.core.Preferences> rxDataMigration);
+    method public androidx.datastore.rxjava3.RxDataStore<androidx.datastore.preferences.core.Preferences> build();
+    method public androidx.datastore.preferences.rxjava3.RxPreferenceDataStoreBuilder setCorruptionHandler(androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<androidx.datastore.preferences.core.Preferences> corruptionHandler);
+    method public androidx.datastore.preferences.rxjava3.RxPreferenceDataStoreBuilder setIoScheduler(io.reactivex.rxjava3.core.Scheduler ioScheduler);
+  }
+
+  public final class RxPreferenceDataStoreDelegateKt {
+    method public static kotlin.properties.ReadOnlyProperty<android.content.Context,androidx.datastore.rxjava3.RxDataStore<androidx.datastore.preferences.core.Preferences>> rxPreferencesDataStore(String name, optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<androidx.datastore.preferences.core.Preferences>? corruptionHandler, optional kotlin.jvm.functions.Function1<? super android.content.Context,? extends java.util.List<? extends androidx.datastore.core.DataMigration<androidx.datastore.preferences.core.Preferences>>> produceMigrations, optional io.reactivex.rxjava3.core.Scheduler scheduler);
+  }
+
+}
+
diff --git a/datastore/datastore-preferences/api/1.0.0-beta01.txt b/datastore/datastore-preferences/api/1.0.0-beta01.txt
new file mode 100644
index 0000000..722515f
--- /dev/null
+++ b/datastore/datastore-preferences/api/1.0.0-beta01.txt
@@ -0,0 +1,20 @@
+// Signature format: 4.0
+package androidx.datastore.preferences {
+
+  public final class PreferenceDataStoreDelegateKt {
+    method public static kotlin.properties.ReadOnlyProperty<android.content.Context,androidx.datastore.core.DataStore<androidx.datastore.preferences.core.Preferences>> preferencesDataStore(String name, optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<androidx.datastore.preferences.core.Preferences>? corruptionHandler, optional kotlin.jvm.functions.Function1<? super android.content.Context,? extends java.util.List<? extends androidx.datastore.core.DataMigration<androidx.datastore.preferences.core.Preferences>>> produceMigrations, optional kotlinx.coroutines.CoroutineScope scope);
+  }
+
+  public final class PreferenceDataStoreFile {
+    method public static java.io.File preferencesDataStoreFile(android.content.Context, String name);
+  }
+
+  public final class SharedPreferencesMigrationKt {
+    method public static androidx.datastore.migrations.SharedPreferencesMigration<androidx.datastore.preferences.core.Preferences> SharedPreferencesMigration(kotlin.jvm.functions.Function0<? extends android.content.SharedPreferences> produceSharedPreferences, optional java.util.Set<java.lang.String> keysToMigrate);
+    method public static androidx.datastore.migrations.SharedPreferencesMigration<androidx.datastore.preferences.core.Preferences> SharedPreferencesMigration(kotlin.jvm.functions.Function0<? extends android.content.SharedPreferences> produceSharedPreferences);
+    method public static androidx.datastore.migrations.SharedPreferencesMigration<androidx.datastore.preferences.core.Preferences> SharedPreferencesMigration(android.content.Context context, String sharedPreferencesName, optional java.util.Set<java.lang.String> keysToMigrate);
+    method public static androidx.datastore.migrations.SharedPreferencesMigration<androidx.datastore.preferences.core.Preferences> SharedPreferencesMigration(android.content.Context context, String sharedPreferencesName);
+  }
+
+}
+
diff --git a/datastore/datastore-preferences/api/public_plus_experimental_1.0.0-beta01.txt b/datastore/datastore-preferences/api/public_plus_experimental_1.0.0-beta01.txt
new file mode 100644
index 0000000..722515f
--- /dev/null
+++ b/datastore/datastore-preferences/api/public_plus_experimental_1.0.0-beta01.txt
@@ -0,0 +1,20 @@
+// Signature format: 4.0
+package androidx.datastore.preferences {
+
+  public final class PreferenceDataStoreDelegateKt {
+    method public static kotlin.properties.ReadOnlyProperty<android.content.Context,androidx.datastore.core.DataStore<androidx.datastore.preferences.core.Preferences>> preferencesDataStore(String name, optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<androidx.datastore.preferences.core.Preferences>? corruptionHandler, optional kotlin.jvm.functions.Function1<? super android.content.Context,? extends java.util.List<? extends androidx.datastore.core.DataMigration<androidx.datastore.preferences.core.Preferences>>> produceMigrations, optional kotlinx.coroutines.CoroutineScope scope);
+  }
+
+  public final class PreferenceDataStoreFile {
+    method public static java.io.File preferencesDataStoreFile(android.content.Context, String name);
+  }
+
+  public final class SharedPreferencesMigrationKt {
+    method public static androidx.datastore.migrations.SharedPreferencesMigration<androidx.datastore.preferences.core.Preferences> SharedPreferencesMigration(kotlin.jvm.functions.Function0<? extends android.content.SharedPreferences> produceSharedPreferences, optional java.util.Set<java.lang.String> keysToMigrate);
+    method public static androidx.datastore.migrations.SharedPreferencesMigration<androidx.datastore.preferences.core.Preferences> SharedPreferencesMigration(kotlin.jvm.functions.Function0<? extends android.content.SharedPreferences> produceSharedPreferences);
+    method public static androidx.datastore.migrations.SharedPreferencesMigration<androidx.datastore.preferences.core.Preferences> SharedPreferencesMigration(android.content.Context context, String sharedPreferencesName, optional java.util.Set<java.lang.String> keysToMigrate);
+    method public static androidx.datastore.migrations.SharedPreferencesMigration<androidx.datastore.preferences.core.Preferences> SharedPreferencesMigration(android.content.Context context, String sharedPreferencesName);
+  }
+
+}
+
diff --git a/datastore/datastore-preferences/api/res-1.0.0-beta01.txt b/datastore/datastore-preferences/api/res-1.0.0-beta01.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/datastore/datastore-preferences/api/res-1.0.0-beta01.txt
diff --git a/datastore/datastore-preferences/api/restricted_1.0.0-beta01.txt b/datastore/datastore-preferences/api/restricted_1.0.0-beta01.txt
new file mode 100644
index 0000000..722515f
--- /dev/null
+++ b/datastore/datastore-preferences/api/restricted_1.0.0-beta01.txt
@@ -0,0 +1,20 @@
+// Signature format: 4.0
+package androidx.datastore.preferences {
+
+  public final class PreferenceDataStoreDelegateKt {
+    method public static kotlin.properties.ReadOnlyProperty<android.content.Context,androidx.datastore.core.DataStore<androidx.datastore.preferences.core.Preferences>> preferencesDataStore(String name, optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<androidx.datastore.preferences.core.Preferences>? corruptionHandler, optional kotlin.jvm.functions.Function1<? super android.content.Context,? extends java.util.List<? extends androidx.datastore.core.DataMigration<androidx.datastore.preferences.core.Preferences>>> produceMigrations, optional kotlinx.coroutines.CoroutineScope scope);
+  }
+
+  public final class PreferenceDataStoreFile {
+    method public static java.io.File preferencesDataStoreFile(android.content.Context, String name);
+  }
+
+  public final class SharedPreferencesMigrationKt {
+    method public static androidx.datastore.migrations.SharedPreferencesMigration<androidx.datastore.preferences.core.Preferences> SharedPreferencesMigration(kotlin.jvm.functions.Function0<? extends android.content.SharedPreferences> produceSharedPreferences, optional java.util.Set<java.lang.String> keysToMigrate);
+    method public static androidx.datastore.migrations.SharedPreferencesMigration<androidx.datastore.preferences.core.Preferences> SharedPreferencesMigration(kotlin.jvm.functions.Function0<? extends android.content.SharedPreferences> produceSharedPreferences);
+    method public static androidx.datastore.migrations.SharedPreferencesMigration<androidx.datastore.preferences.core.Preferences> SharedPreferencesMigration(android.content.Context context, String sharedPreferencesName, optional java.util.Set<java.lang.String> keysToMigrate);
+    method public static androidx.datastore.migrations.SharedPreferencesMigration<androidx.datastore.preferences.core.Preferences> SharedPreferencesMigration(android.content.Context context, String sharedPreferencesName);
+  }
+
+}
+
diff --git a/datastore/datastore-proto/build.gradle b/datastore/datastore-proto/build.gradle
index fd54e14..3e9a985 100644
--- a/datastore/datastore-proto/build.gradle
+++ b/datastore/datastore-proto/build.gradle
@@ -60,9 +60,9 @@
 
 androidx {
     name = "Android Proto DataStore"
-    publish = Publish.SNAPSHOT_ONLY
+    publish = Publish.NONE
     mavenGroup = LibraryGroups.DATASTORE
     inceptionYear = "2020"
     description = "Android Proto DataStore"
-    runApiTasks = new RunApiTasks.Yes()
+    runApiTasks = new RunApiTasks.No("Unreleased library.")
 }
diff --git a/datastore/datastore-rxjava2/api/1.0.0-beta01.txt b/datastore/datastore-rxjava2/api/1.0.0-beta01.txt
new file mode 100644
index 0000000..433238b
--- /dev/null
+++ b/datastore/datastore-rxjava2/api/1.0.0-beta01.txt
@@ -0,0 +1,42 @@
+// Signature format: 4.0
+package androidx.datastore.rxjava2 {
+
+  public interface RxDataMigration<T> {
+    method public io.reactivex.Completable cleanUp();
+    method public io.reactivex.Single<T!> migrate(T?);
+    method public io.reactivex.Single<java.lang.Boolean!> shouldMigrate(T?);
+  }
+
+  public final class RxDataStore<T> implements io.reactivex.disposables.Disposable {
+    method public void dispose();
+    method public boolean isDisposed();
+    method public io.reactivex.Completable shutdownComplete();
+  }
+
+  public final class RxDataStoreBuilder<T> {
+    ctor public RxDataStoreBuilder(java.util.concurrent.Callable<java.io.File> produceFile, androidx.datastore.core.Serializer<T> serializer);
+    ctor public RxDataStoreBuilder(android.content.Context context, String fileName, androidx.datastore.core.Serializer<T> serializer);
+    method public androidx.datastore.rxjava2.RxDataStoreBuilder<T> addDataMigration(androidx.datastore.core.DataMigration<T> dataMigration);
+    method public androidx.datastore.rxjava2.RxDataStoreBuilder<T> addRxDataMigration(androidx.datastore.rxjava2.RxDataMigration<T> rxDataMigration);
+    method public androidx.datastore.rxjava2.RxDataStore<T> build();
+    method public androidx.datastore.rxjava2.RxDataStoreBuilder<T> setCorruptionHandler(androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<T> corruptionHandler);
+    method public androidx.datastore.rxjava2.RxDataStoreBuilder<T> setIoScheduler(io.reactivex.Scheduler ioScheduler);
+  }
+
+  public final class RxDataStoreDelegateKt {
+    method public static <T> kotlin.properties.ReadOnlyProperty<android.content.Context,androidx.datastore.rxjava2.RxDataStore<T>> rxDataStore(String fileName, androidx.datastore.core.Serializer<T> serializer, optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<T>? corruptionHandler, optional kotlin.jvm.functions.Function1<? super android.content.Context,? extends java.util.List<? extends androidx.datastore.core.DataMigration<T>>> produceMigrations, optional io.reactivex.Scheduler scheduler);
+  }
+
+  public interface RxSharedPreferencesMigration<T> {
+    method public io.reactivex.Single<T> migrate(androidx.datastore.migrations.SharedPreferencesView sharedPreferencesView, T? currentData);
+    method public default io.reactivex.Single<java.lang.Boolean> shouldMigrate(T? currentData);
+  }
+
+  public final class RxSharedPreferencesMigrationBuilder<T> {
+    ctor public RxSharedPreferencesMigrationBuilder(android.content.Context context, String sharedPreferencesName, androidx.datastore.rxjava2.RxSharedPreferencesMigration<T> rxSharedPreferencesMigration);
+    method public androidx.datastore.core.DataMigration<T> build();
+    method public androidx.datastore.rxjava2.RxSharedPreferencesMigrationBuilder<T> setKeysToMigrate(java.lang.String... keys);
+  }
+
+}
+
diff --git a/datastore/datastore-rxjava2/api/public_plus_experimental_1.0.0-beta01.txt b/datastore/datastore-rxjava2/api/public_plus_experimental_1.0.0-beta01.txt
new file mode 100644
index 0000000..e662ed7
--- /dev/null
+++ b/datastore/datastore-rxjava2/api/public_plus_experimental_1.0.0-beta01.txt
@@ -0,0 +1,44 @@
+// Signature format: 4.0
+package androidx.datastore.rxjava2 {
+
+  public interface RxDataMigration<T> {
+    method public io.reactivex.Completable cleanUp();
+    method public io.reactivex.Single<T!> migrate(T?);
+    method public io.reactivex.Single<java.lang.Boolean!> shouldMigrate(T?);
+  }
+
+  public final class RxDataStore<T> implements io.reactivex.disposables.Disposable {
+    method @kotlinx.coroutines.ExperimentalCoroutinesApi public io.reactivex.Flowable<T> data();
+    method public void dispose();
+    method public boolean isDisposed();
+    method public io.reactivex.Completable shutdownComplete();
+    method @kotlinx.coroutines.ExperimentalCoroutinesApi public io.reactivex.Single<T> updateDataAsync(io.reactivex.functions.Function<T,io.reactivex.Single<T>> transform);
+  }
+
+  public final class RxDataStoreBuilder<T> {
+    ctor public RxDataStoreBuilder(java.util.concurrent.Callable<java.io.File> produceFile, androidx.datastore.core.Serializer<T> serializer);
+    ctor public RxDataStoreBuilder(android.content.Context context, String fileName, androidx.datastore.core.Serializer<T> serializer);
+    method public androidx.datastore.rxjava2.RxDataStoreBuilder<T> addDataMigration(androidx.datastore.core.DataMigration<T> dataMigration);
+    method public androidx.datastore.rxjava2.RxDataStoreBuilder<T> addRxDataMigration(androidx.datastore.rxjava2.RxDataMigration<T> rxDataMigration);
+    method public androidx.datastore.rxjava2.RxDataStore<T> build();
+    method public androidx.datastore.rxjava2.RxDataStoreBuilder<T> setCorruptionHandler(androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<T> corruptionHandler);
+    method public androidx.datastore.rxjava2.RxDataStoreBuilder<T> setIoScheduler(io.reactivex.Scheduler ioScheduler);
+  }
+
+  public final class RxDataStoreDelegateKt {
+    method public static <T> kotlin.properties.ReadOnlyProperty<android.content.Context,androidx.datastore.rxjava2.RxDataStore<T>> rxDataStore(String fileName, androidx.datastore.core.Serializer<T> serializer, optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<T>? corruptionHandler, optional kotlin.jvm.functions.Function1<? super android.content.Context,? extends java.util.List<? extends androidx.datastore.core.DataMigration<T>>> produceMigrations, optional io.reactivex.Scheduler scheduler);
+  }
+
+  public interface RxSharedPreferencesMigration<T> {
+    method public io.reactivex.Single<T> migrate(androidx.datastore.migrations.SharedPreferencesView sharedPreferencesView, T? currentData);
+    method public default io.reactivex.Single<java.lang.Boolean> shouldMigrate(T? currentData);
+  }
+
+  public final class RxSharedPreferencesMigrationBuilder<T> {
+    ctor public RxSharedPreferencesMigrationBuilder(android.content.Context context, String sharedPreferencesName, androidx.datastore.rxjava2.RxSharedPreferencesMigration<T> rxSharedPreferencesMigration);
+    method public androidx.datastore.core.DataMigration<T> build();
+    method public androidx.datastore.rxjava2.RxSharedPreferencesMigrationBuilder<T> setKeysToMigrate(java.lang.String... keys);
+  }
+
+}
+
diff --git a/datastore/datastore-rxjava2/api/res-1.0.0-beta01.txt b/datastore/datastore-rxjava2/api/res-1.0.0-beta01.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/datastore/datastore-rxjava2/api/res-1.0.0-beta01.txt
diff --git a/datastore/datastore-rxjava2/api/restricted_1.0.0-beta01.txt b/datastore/datastore-rxjava2/api/restricted_1.0.0-beta01.txt
new file mode 100644
index 0000000..433238b
--- /dev/null
+++ b/datastore/datastore-rxjava2/api/restricted_1.0.0-beta01.txt
@@ -0,0 +1,42 @@
+// Signature format: 4.0
+package androidx.datastore.rxjava2 {
+
+  public interface RxDataMigration<T> {
+    method public io.reactivex.Completable cleanUp();
+    method public io.reactivex.Single<T!> migrate(T?);
+    method public io.reactivex.Single<java.lang.Boolean!> shouldMigrate(T?);
+  }
+
+  public final class RxDataStore<T> implements io.reactivex.disposables.Disposable {
+    method public void dispose();
+    method public boolean isDisposed();
+    method public io.reactivex.Completable shutdownComplete();
+  }
+
+  public final class RxDataStoreBuilder<T> {
+    ctor public RxDataStoreBuilder(java.util.concurrent.Callable<java.io.File> produceFile, androidx.datastore.core.Serializer<T> serializer);
+    ctor public RxDataStoreBuilder(android.content.Context context, String fileName, androidx.datastore.core.Serializer<T> serializer);
+    method public androidx.datastore.rxjava2.RxDataStoreBuilder<T> addDataMigration(androidx.datastore.core.DataMigration<T> dataMigration);
+    method public androidx.datastore.rxjava2.RxDataStoreBuilder<T> addRxDataMigration(androidx.datastore.rxjava2.RxDataMigration<T> rxDataMigration);
+    method public androidx.datastore.rxjava2.RxDataStore<T> build();
+    method public androidx.datastore.rxjava2.RxDataStoreBuilder<T> setCorruptionHandler(androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<T> corruptionHandler);
+    method public androidx.datastore.rxjava2.RxDataStoreBuilder<T> setIoScheduler(io.reactivex.Scheduler ioScheduler);
+  }
+
+  public final class RxDataStoreDelegateKt {
+    method public static <T> kotlin.properties.ReadOnlyProperty<android.content.Context,androidx.datastore.rxjava2.RxDataStore<T>> rxDataStore(String fileName, androidx.datastore.core.Serializer<T> serializer, optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<T>? corruptionHandler, optional kotlin.jvm.functions.Function1<? super android.content.Context,? extends java.util.List<? extends androidx.datastore.core.DataMigration<T>>> produceMigrations, optional io.reactivex.Scheduler scheduler);
+  }
+
+  public interface RxSharedPreferencesMigration<T> {
+    method public io.reactivex.Single<T> migrate(androidx.datastore.migrations.SharedPreferencesView sharedPreferencesView, T? currentData);
+    method public default io.reactivex.Single<java.lang.Boolean> shouldMigrate(T? currentData);
+  }
+
+  public final class RxSharedPreferencesMigrationBuilder<T> {
+    ctor public RxSharedPreferencesMigrationBuilder(android.content.Context context, String sharedPreferencesName, androidx.datastore.rxjava2.RxSharedPreferencesMigration<T> rxSharedPreferencesMigration);
+    method public androidx.datastore.core.DataMigration<T> build();
+    method public androidx.datastore.rxjava2.RxSharedPreferencesMigrationBuilder<T> setKeysToMigrate(java.lang.String... keys);
+  }
+
+}
+
diff --git a/datastore/datastore-rxjava3/api/1.0.0-beta01.txt b/datastore/datastore-rxjava3/api/1.0.0-beta01.txt
new file mode 100644
index 0000000..1033671
--- /dev/null
+++ b/datastore/datastore-rxjava3/api/1.0.0-beta01.txt
@@ -0,0 +1,42 @@
+// Signature format: 4.0
+package androidx.datastore.rxjava3 {
+
+  public interface RxDataMigration<T> {
+    method public io.reactivex.rxjava3.core.Completable cleanUp();
+    method public io.reactivex.rxjava3.core.Single<T!> migrate(T?);
+    method public io.reactivex.rxjava3.core.Single<java.lang.Boolean!> shouldMigrate(T?);
+  }
+
+  public final class RxDataStore<T> implements io.reactivex.rxjava3.disposables.Disposable {
+    method public void dispose();
+    method public boolean isDisposed();
+    method public io.reactivex.rxjava3.core.Completable shutdownComplete();
+  }
+
+  public final class RxDataStoreBuilder<T> {
+    ctor public RxDataStoreBuilder(java.util.concurrent.Callable<java.io.File> produceFile, androidx.datastore.core.Serializer<T> serializer);
+    ctor public RxDataStoreBuilder(android.content.Context context, String fileName, androidx.datastore.core.Serializer<T> serializer);
+    method public androidx.datastore.rxjava3.RxDataStoreBuilder<T> addDataMigration(androidx.datastore.core.DataMigration<T> dataMigration);
+    method public androidx.datastore.rxjava3.RxDataStoreBuilder<T> addRxDataMigration(androidx.datastore.rxjava3.RxDataMigration<T> rxDataMigration);
+    method public androidx.datastore.rxjava3.RxDataStore<T> build();
+    method public androidx.datastore.rxjava3.RxDataStoreBuilder<T> setCorruptionHandler(androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<T> corruptionHandler);
+    method public androidx.datastore.rxjava3.RxDataStoreBuilder<T> setIoScheduler(io.reactivex.rxjava3.core.Scheduler ioScheduler);
+  }
+
+  public final class RxDataStoreDelegateKt {
+    method public static <T> kotlin.properties.ReadOnlyProperty<android.content.Context,androidx.datastore.rxjava3.RxDataStore<T>> rxDataStore(String fileName, androidx.datastore.core.Serializer<T> serializer, optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<T>? corruptionHandler, optional kotlin.jvm.functions.Function1<? super android.content.Context,? extends java.util.List<? extends androidx.datastore.core.DataMigration<T>>> produceMigrations, optional io.reactivex.rxjava3.core.Scheduler scheduler);
+  }
+
+  public interface RxSharedPreferencesMigration<T> {
+    method public io.reactivex.rxjava3.core.Single<T> migrate(androidx.datastore.migrations.SharedPreferencesView sharedPreferencesView, T? currentData);
+    method public default io.reactivex.rxjava3.core.Single<java.lang.Boolean> shouldMigrate(T? currentData);
+  }
+
+  public final class RxSharedPreferencesMigrationBuilder<T> {
+    ctor public RxSharedPreferencesMigrationBuilder(android.content.Context context, String sharedPreferencesName, androidx.datastore.rxjava3.RxSharedPreferencesMigration<T> rxSharedPreferencesMigration);
+    method public androidx.datastore.core.DataMigration<T> build();
+    method public androidx.datastore.rxjava3.RxSharedPreferencesMigrationBuilder<T> setKeysToMigrate(java.lang.String... keys);
+  }
+
+}
+
diff --git a/datastore/datastore-rxjava3/api/public_plus_experimental_1.0.0-beta01.txt b/datastore/datastore-rxjava3/api/public_plus_experimental_1.0.0-beta01.txt
new file mode 100644
index 0000000..05fa237
--- /dev/null
+++ b/datastore/datastore-rxjava3/api/public_plus_experimental_1.0.0-beta01.txt
@@ -0,0 +1,44 @@
+// Signature format: 4.0
+package androidx.datastore.rxjava3 {
+
+  public interface RxDataMigration<T> {
+    method public io.reactivex.rxjava3.core.Completable cleanUp();
+    method public io.reactivex.rxjava3.core.Single<T!> migrate(T?);
+    method public io.reactivex.rxjava3.core.Single<java.lang.Boolean!> shouldMigrate(T?);
+  }
+
+  public final class RxDataStore<T> implements io.reactivex.rxjava3.disposables.Disposable {
+    method @kotlinx.coroutines.ExperimentalCoroutinesApi public io.reactivex.rxjava3.core.Flowable<T> data();
+    method public void dispose();
+    method public boolean isDisposed();
+    method public io.reactivex.rxjava3.core.Completable shutdownComplete();
+    method @kotlinx.coroutines.ExperimentalCoroutinesApi public io.reactivex.rxjava3.core.Single<T> updateDataAsync(io.reactivex.rxjava3.functions.Function<T,io.reactivex.rxjava3.core.Single<T>> transform);
+  }
+
+  public final class RxDataStoreBuilder<T> {
+    ctor public RxDataStoreBuilder(java.util.concurrent.Callable<java.io.File> produceFile, androidx.datastore.core.Serializer<T> serializer);
+    ctor public RxDataStoreBuilder(android.content.Context context, String fileName, androidx.datastore.core.Serializer<T> serializer);
+    method public androidx.datastore.rxjava3.RxDataStoreBuilder<T> addDataMigration(androidx.datastore.core.DataMigration<T> dataMigration);
+    method public androidx.datastore.rxjava3.RxDataStoreBuilder<T> addRxDataMigration(androidx.datastore.rxjava3.RxDataMigration<T> rxDataMigration);
+    method public androidx.datastore.rxjava3.RxDataStore<T> build();
+    method public androidx.datastore.rxjava3.RxDataStoreBuilder<T> setCorruptionHandler(androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<T> corruptionHandler);
+    method public androidx.datastore.rxjava3.RxDataStoreBuilder<T> setIoScheduler(io.reactivex.rxjava3.core.Scheduler ioScheduler);
+  }
+
+  public final class RxDataStoreDelegateKt {
+    method public static <T> kotlin.properties.ReadOnlyProperty<android.content.Context,androidx.datastore.rxjava3.RxDataStore<T>> rxDataStore(String fileName, androidx.datastore.core.Serializer<T> serializer, optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<T>? corruptionHandler, optional kotlin.jvm.functions.Function1<? super android.content.Context,? extends java.util.List<? extends androidx.datastore.core.DataMigration<T>>> produceMigrations, optional io.reactivex.rxjava3.core.Scheduler scheduler);
+  }
+
+  public interface RxSharedPreferencesMigration<T> {
+    method public io.reactivex.rxjava3.core.Single<T> migrate(androidx.datastore.migrations.SharedPreferencesView sharedPreferencesView, T? currentData);
+    method public default io.reactivex.rxjava3.core.Single<java.lang.Boolean> shouldMigrate(T? currentData);
+  }
+
+  public final class RxSharedPreferencesMigrationBuilder<T> {
+    ctor public RxSharedPreferencesMigrationBuilder(android.content.Context context, String sharedPreferencesName, androidx.datastore.rxjava3.RxSharedPreferencesMigration<T> rxSharedPreferencesMigration);
+    method public androidx.datastore.core.DataMigration<T> build();
+    method public androidx.datastore.rxjava3.RxSharedPreferencesMigrationBuilder<T> setKeysToMigrate(java.lang.String... keys);
+  }
+
+}
+
diff --git a/datastore/datastore-rxjava3/api/res-1.0.0-beta01.txt b/datastore/datastore-rxjava3/api/res-1.0.0-beta01.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/datastore/datastore-rxjava3/api/res-1.0.0-beta01.txt
diff --git a/datastore/datastore-rxjava3/api/restricted_1.0.0-beta01.txt b/datastore/datastore-rxjava3/api/restricted_1.0.0-beta01.txt
new file mode 100644
index 0000000..1033671
--- /dev/null
+++ b/datastore/datastore-rxjava3/api/restricted_1.0.0-beta01.txt
@@ -0,0 +1,42 @@
+// Signature format: 4.0
+package androidx.datastore.rxjava3 {
+
+  public interface RxDataMigration<T> {
+    method public io.reactivex.rxjava3.core.Completable cleanUp();
+    method public io.reactivex.rxjava3.core.Single<T!> migrate(T?);
+    method public io.reactivex.rxjava3.core.Single<java.lang.Boolean!> shouldMigrate(T?);
+  }
+
+  public final class RxDataStore<T> implements io.reactivex.rxjava3.disposables.Disposable {
+    method public void dispose();
+    method public boolean isDisposed();
+    method public io.reactivex.rxjava3.core.Completable shutdownComplete();
+  }
+
+  public final class RxDataStoreBuilder<T> {
+    ctor public RxDataStoreBuilder(java.util.concurrent.Callable<java.io.File> produceFile, androidx.datastore.core.Serializer<T> serializer);
+    ctor public RxDataStoreBuilder(android.content.Context context, String fileName, androidx.datastore.core.Serializer<T> serializer);
+    method public androidx.datastore.rxjava3.RxDataStoreBuilder<T> addDataMigration(androidx.datastore.core.DataMigration<T> dataMigration);
+    method public androidx.datastore.rxjava3.RxDataStoreBuilder<T> addRxDataMigration(androidx.datastore.rxjava3.RxDataMigration<T> rxDataMigration);
+    method public androidx.datastore.rxjava3.RxDataStore<T> build();
+    method public androidx.datastore.rxjava3.RxDataStoreBuilder<T> setCorruptionHandler(androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<T> corruptionHandler);
+    method public androidx.datastore.rxjava3.RxDataStoreBuilder<T> setIoScheduler(io.reactivex.rxjava3.core.Scheduler ioScheduler);
+  }
+
+  public final class RxDataStoreDelegateKt {
+    method public static <T> kotlin.properties.ReadOnlyProperty<android.content.Context,androidx.datastore.rxjava3.RxDataStore<T>> rxDataStore(String fileName, androidx.datastore.core.Serializer<T> serializer, optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<T>? corruptionHandler, optional kotlin.jvm.functions.Function1<? super android.content.Context,? extends java.util.List<? extends androidx.datastore.core.DataMigration<T>>> produceMigrations, optional io.reactivex.rxjava3.core.Scheduler scheduler);
+  }
+
+  public interface RxSharedPreferencesMigration<T> {
+    method public io.reactivex.rxjava3.core.Single<T> migrate(androidx.datastore.migrations.SharedPreferencesView sharedPreferencesView, T? currentData);
+    method public default io.reactivex.rxjava3.core.Single<java.lang.Boolean> shouldMigrate(T? currentData);
+  }
+
+  public final class RxSharedPreferencesMigrationBuilder<T> {
+    ctor public RxSharedPreferencesMigrationBuilder(android.content.Context context, String sharedPreferencesName, androidx.datastore.rxjava3.RxSharedPreferencesMigration<T> rxSharedPreferencesMigration);
+    method public androidx.datastore.core.DataMigration<T> build();
+    method public androidx.datastore.rxjava3.RxSharedPreferencesMigrationBuilder<T> setKeysToMigrate(java.lang.String... keys);
+  }
+
+}
+
diff --git a/datastore/datastore/api/1.0.0-beta01.txt b/datastore/datastore/api/1.0.0-beta01.txt
new file mode 100644
index 0000000..46a48c7
--- /dev/null
+++ b/datastore/datastore/api/1.0.0-beta01.txt
@@ -0,0 +1,43 @@
+// Signature format: 4.0
+package androidx.datastore {
+
+  public final class DataStoreDelegateKt {
+    method public static <T> kotlin.properties.ReadOnlyProperty<android.content.Context,androidx.datastore.core.DataStore<T>> dataStore(String fileName, androidx.datastore.core.Serializer<T> serializer, optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<T>? corruptionHandler, optional kotlin.jvm.functions.Function1<? super android.content.Context,? extends java.util.List<? extends androidx.datastore.core.DataMigration<T>>> produceMigrations, optional kotlinx.coroutines.CoroutineScope scope);
+  }
+
+  public final class DataStoreFile {
+    method public static java.io.File dataStoreFile(android.content.Context, String fileName);
+  }
+
+}
+
+package androidx.datastore.migrations {
+
+  public final class SharedPreferencesMigration<T> implements androidx.datastore.core.DataMigration<T> {
+    ctor public SharedPreferencesMigration(kotlin.jvm.functions.Function0<? extends android.content.SharedPreferences> produceSharedPreferences, optional java.util.Set<java.lang.String> keysToMigrate, optional kotlin.jvm.functions.Function2<? super T,? super kotlin.coroutines.Continuation<? super java.lang.Boolean>,?> shouldRunMigration, kotlin.jvm.functions.Function3<? super androidx.datastore.migrations.SharedPreferencesView,? super T,? super kotlin.coroutines.Continuation<? super T>,?> migrate);
+    ctor public SharedPreferencesMigration(kotlin.jvm.functions.Function0<? extends android.content.SharedPreferences> produceSharedPreferences, optional java.util.Set<java.lang.String> keysToMigrate, kotlin.jvm.functions.Function3<? super androidx.datastore.migrations.SharedPreferencesView,? super T,? super kotlin.coroutines.Continuation<? super T>,?> migrate);
+    ctor public SharedPreferencesMigration(kotlin.jvm.functions.Function0<? extends android.content.SharedPreferences> produceSharedPreferences, kotlin.jvm.functions.Function3<? super androidx.datastore.migrations.SharedPreferencesView,? super T,? super kotlin.coroutines.Continuation<? super T>,?> migrate);
+    ctor public SharedPreferencesMigration(android.content.Context context, String sharedPreferencesName, optional java.util.Set<java.lang.String> keysToMigrate, optional kotlin.jvm.functions.Function2<? super T,? super kotlin.coroutines.Continuation<? super java.lang.Boolean>,?> shouldRunMigration, kotlin.jvm.functions.Function3<? super androidx.datastore.migrations.SharedPreferencesView,? super T,? super kotlin.coroutines.Continuation<? super T>,?> migrate);
+    ctor public SharedPreferencesMigration(android.content.Context context, String sharedPreferencesName, optional java.util.Set<java.lang.String> keysToMigrate, kotlin.jvm.functions.Function3<? super androidx.datastore.migrations.SharedPreferencesView,? super T,? super kotlin.coroutines.Continuation<? super T>,?> migrate);
+    ctor public SharedPreferencesMigration(android.content.Context context, String sharedPreferencesName, kotlin.jvm.functions.Function3<? super androidx.datastore.migrations.SharedPreferencesView,? super T,? super kotlin.coroutines.Continuation<? super T>,?> migrate);
+    method @kotlin.jvm.Throws(exceptionClasses=IOException::class) public suspend Object? cleanUp(kotlin.coroutines.Continuation<? super kotlin.Unit> p) throws java.io.IOException;
+    method public suspend Object? migrate(T? currentData, kotlin.coroutines.Continuation<? super T> p);
+    method public suspend Object? shouldMigrate(T? currentData, kotlin.coroutines.Continuation<? super java.lang.Boolean> p);
+  }
+
+  public final class SharedPreferencesMigrationKt {
+  }
+
+  public final class SharedPreferencesView {
+    method public operator boolean contains(String key);
+    method public java.util.Map<java.lang.String,java.lang.Object> getAll();
+    method public boolean getBoolean(String key, boolean defValue);
+    method public float getFloat(String key, float defValue);
+    method public int getInt(String key, int defValue);
+    method public long getLong(String key, long defValue);
+    method public String? getString(String key, optional String? defValue);
+    method public java.util.Set<java.lang.String>? getStringSet(String key, optional java.util.Set<java.lang.String>? defValues);
+  }
+
+}
+
diff --git a/datastore/datastore/api/public_plus_experimental_1.0.0-beta01.txt b/datastore/datastore/api/public_plus_experimental_1.0.0-beta01.txt
new file mode 100644
index 0000000..46a48c7
--- /dev/null
+++ b/datastore/datastore/api/public_plus_experimental_1.0.0-beta01.txt
@@ -0,0 +1,43 @@
+// Signature format: 4.0
+package androidx.datastore {
+
+  public final class DataStoreDelegateKt {
+    method public static <T> kotlin.properties.ReadOnlyProperty<android.content.Context,androidx.datastore.core.DataStore<T>> dataStore(String fileName, androidx.datastore.core.Serializer<T> serializer, optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<T>? corruptionHandler, optional kotlin.jvm.functions.Function1<? super android.content.Context,? extends java.util.List<? extends androidx.datastore.core.DataMigration<T>>> produceMigrations, optional kotlinx.coroutines.CoroutineScope scope);
+  }
+
+  public final class DataStoreFile {
+    method public static java.io.File dataStoreFile(android.content.Context, String fileName);
+  }
+
+}
+
+package androidx.datastore.migrations {
+
+  public final class SharedPreferencesMigration<T> implements androidx.datastore.core.DataMigration<T> {
+    ctor public SharedPreferencesMigration(kotlin.jvm.functions.Function0<? extends android.content.SharedPreferences> produceSharedPreferences, optional java.util.Set<java.lang.String> keysToMigrate, optional kotlin.jvm.functions.Function2<? super T,? super kotlin.coroutines.Continuation<? super java.lang.Boolean>,?> shouldRunMigration, kotlin.jvm.functions.Function3<? super androidx.datastore.migrations.SharedPreferencesView,? super T,? super kotlin.coroutines.Continuation<? super T>,?> migrate);
+    ctor public SharedPreferencesMigration(kotlin.jvm.functions.Function0<? extends android.content.SharedPreferences> produceSharedPreferences, optional java.util.Set<java.lang.String> keysToMigrate, kotlin.jvm.functions.Function3<? super androidx.datastore.migrations.SharedPreferencesView,? super T,? super kotlin.coroutines.Continuation<? super T>,?> migrate);
+    ctor public SharedPreferencesMigration(kotlin.jvm.functions.Function0<? extends android.content.SharedPreferences> produceSharedPreferences, kotlin.jvm.functions.Function3<? super androidx.datastore.migrations.SharedPreferencesView,? super T,? super kotlin.coroutines.Continuation<? super T>,?> migrate);
+    ctor public SharedPreferencesMigration(android.content.Context context, String sharedPreferencesName, optional java.util.Set<java.lang.String> keysToMigrate, optional kotlin.jvm.functions.Function2<? super T,? super kotlin.coroutines.Continuation<? super java.lang.Boolean>,?> shouldRunMigration, kotlin.jvm.functions.Function3<? super androidx.datastore.migrations.SharedPreferencesView,? super T,? super kotlin.coroutines.Continuation<? super T>,?> migrate);
+    ctor public SharedPreferencesMigration(android.content.Context context, String sharedPreferencesName, optional java.util.Set<java.lang.String> keysToMigrate, kotlin.jvm.functions.Function3<? super androidx.datastore.migrations.SharedPreferencesView,? super T,? super kotlin.coroutines.Continuation<? super T>,?> migrate);
+    ctor public SharedPreferencesMigration(android.content.Context context, String sharedPreferencesName, kotlin.jvm.functions.Function3<? super androidx.datastore.migrations.SharedPreferencesView,? super T,? super kotlin.coroutines.Continuation<? super T>,?> migrate);
+    method @kotlin.jvm.Throws(exceptionClasses=IOException::class) public suspend Object? cleanUp(kotlin.coroutines.Continuation<? super kotlin.Unit> p) throws java.io.IOException;
+    method public suspend Object? migrate(T? currentData, kotlin.coroutines.Continuation<? super T> p);
+    method public suspend Object? shouldMigrate(T? currentData, kotlin.coroutines.Continuation<? super java.lang.Boolean> p);
+  }
+
+  public final class SharedPreferencesMigrationKt {
+  }
+
+  public final class SharedPreferencesView {
+    method public operator boolean contains(String key);
+    method public java.util.Map<java.lang.String,java.lang.Object> getAll();
+    method public boolean getBoolean(String key, boolean defValue);
+    method public float getFloat(String key, float defValue);
+    method public int getInt(String key, int defValue);
+    method public long getLong(String key, long defValue);
+    method public String? getString(String key, optional String? defValue);
+    method public java.util.Set<java.lang.String>? getStringSet(String key, optional java.util.Set<java.lang.String>? defValues);
+  }
+
+}
+
diff --git a/datastore/datastore/api/res-1.0.0-beta01.txt b/datastore/datastore/api/res-1.0.0-beta01.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/datastore/datastore/api/res-1.0.0-beta01.txt
diff --git a/datastore/datastore/api/restricted_1.0.0-beta01.txt b/datastore/datastore/api/restricted_1.0.0-beta01.txt
new file mode 100644
index 0000000..46a48c7
--- /dev/null
+++ b/datastore/datastore/api/restricted_1.0.0-beta01.txt
@@ -0,0 +1,43 @@
+// Signature format: 4.0
+package androidx.datastore {
+
+  public final class DataStoreDelegateKt {
+    method public static <T> kotlin.properties.ReadOnlyProperty<android.content.Context,androidx.datastore.core.DataStore<T>> dataStore(String fileName, androidx.datastore.core.Serializer<T> serializer, optional androidx.datastore.core.handlers.ReplaceFileCorruptionHandler<T>? corruptionHandler, optional kotlin.jvm.functions.Function1<? super android.content.Context,? extends java.util.List<? extends androidx.datastore.core.DataMigration<T>>> produceMigrations, optional kotlinx.coroutines.CoroutineScope scope);
+  }
+
+  public final class DataStoreFile {
+    method public static java.io.File dataStoreFile(android.content.Context, String fileName);
+  }
+
+}
+
+package androidx.datastore.migrations {
+
+  public final class SharedPreferencesMigration<T> implements androidx.datastore.core.DataMigration<T> {
+    ctor public SharedPreferencesMigration(kotlin.jvm.functions.Function0<? extends android.content.SharedPreferences> produceSharedPreferences, optional java.util.Set<java.lang.String> keysToMigrate, optional kotlin.jvm.functions.Function2<? super T,? super kotlin.coroutines.Continuation<? super java.lang.Boolean>,?> shouldRunMigration, kotlin.jvm.functions.Function3<? super androidx.datastore.migrations.SharedPreferencesView,? super T,? super kotlin.coroutines.Continuation<? super T>,?> migrate);
+    ctor public SharedPreferencesMigration(kotlin.jvm.functions.Function0<? extends android.content.SharedPreferences> produceSharedPreferences, optional java.util.Set<java.lang.String> keysToMigrate, kotlin.jvm.functions.Function3<? super androidx.datastore.migrations.SharedPreferencesView,? super T,? super kotlin.coroutines.Continuation<? super T>,?> migrate);
+    ctor public SharedPreferencesMigration(kotlin.jvm.functions.Function0<? extends android.content.SharedPreferences> produceSharedPreferences, kotlin.jvm.functions.Function3<? super androidx.datastore.migrations.SharedPreferencesView,? super T,? super kotlin.coroutines.Continuation<? super T>,?> migrate);
+    ctor public SharedPreferencesMigration(android.content.Context context, String sharedPreferencesName, optional java.util.Set<java.lang.String> keysToMigrate, optional kotlin.jvm.functions.Function2<? super T,? super kotlin.coroutines.Continuation<? super java.lang.Boolean>,?> shouldRunMigration, kotlin.jvm.functions.Function3<? super androidx.datastore.migrations.SharedPreferencesView,? super T,? super kotlin.coroutines.Continuation<? super T>,?> migrate);
+    ctor public SharedPreferencesMigration(android.content.Context context, String sharedPreferencesName, optional java.util.Set<java.lang.String> keysToMigrate, kotlin.jvm.functions.Function3<? super androidx.datastore.migrations.SharedPreferencesView,? super T,? super kotlin.coroutines.Continuation<? super T>,?> migrate);
+    ctor public SharedPreferencesMigration(android.content.Context context, String sharedPreferencesName, kotlin.jvm.functions.Function3<? super androidx.datastore.migrations.SharedPreferencesView,? super T,? super kotlin.coroutines.Continuation<? super T>,?> migrate);
+    method @kotlin.jvm.Throws(exceptionClasses=IOException::class) public suspend Object? cleanUp(kotlin.coroutines.Continuation<? super kotlin.Unit> p) throws java.io.IOException;
+    method public suspend Object? migrate(T? currentData, kotlin.coroutines.Continuation<? super T> p);
+    method public suspend Object? shouldMigrate(T? currentData, kotlin.coroutines.Continuation<? super java.lang.Boolean> p);
+  }
+
+  public final class SharedPreferencesMigrationKt {
+  }
+
+  public final class SharedPreferencesView {
+    method public operator boolean contains(String key);
+    method public java.util.Map<java.lang.String,java.lang.Object> getAll();
+    method public boolean getBoolean(String key, boolean defValue);
+    method public float getFloat(String key, float defValue);
+    method public int getInt(String key, int defValue);
+    method public long getLong(String key, long defValue);
+    method public String? getString(String key, optional String? defValue);
+    method public java.util.Set<java.lang.String>? getStringSet(String key, optional java.util.Set<java.lang.String>? defValues);
+  }
+
+}
+
