react-native-onyx 2.0.27 → 2.0.29

package/dist/Onyx.js

@@ -89,7 +89,8 @@ function init({ keys = {}, initialKeyStates = {}, safeEvictionKeys = [], maxCach
  * Note that it will not cause the component to have the loading prop set to true.
  * @returns an ID to use when calling disconnect
  */
-function connect(mapping) {
+function connect(connectOptions) {
+    const mapping = connectOptions;
     const connectionID = lastConnectionID++;
     const callbackToStateMapping = OnyxUtils_1.default.getCallbackToStateMapping();
     callbackToStateMapping[connectionID] = mapping;
@@ -149,7 +150,7 @@ function connect(mapping) {
         }
         // If we have a withOnyxInstance that means a React component has subscribed via the withOnyx() HOC and we need to
         // group collection key member data into an object.
-        if (mapping.withOnyxInstance) {
+        if ('withOnyxInstance' in mapping && mapping.withOnyxInstance) {
             if (OnyxUtils_1.default.isCollectionKey(mapping.key)) {
                 OnyxUtils_1.default.getCollectionDataAndSendAsObject(matchingKeys, mapping);
                 return;
@@ -192,22 +193,23 @@ function disconnect(connectionID, keyToRemoveFromEvictionBlocklist) {
 function set(key, value) {
     // If the value is null, we remove the key from storage
     const { value: valueAfterRemoving, wasRemoved } = OnyxUtils_1.default.removeNullValues(key, value);
+    const valueWithoutNullValues = valueAfterRemoving;
     if (OnyxUtils_1.default.hasPendingMergeForKey(key)) {
         delete OnyxUtils_1.default.getMergeQueue()[key];
     }
-    const hasChanged = OnyxCache_1.default.hasValueChanged(key, valueAfterRemoving);
+    const hasChanged = OnyxCache_1.default.hasValueChanged(key, valueWithoutNullValues);
     // Logging properties only since values could be sensitive things we don't want to log
     Logger.logInfo(`set called for key: ${key}${underscore_1.default.isObject(value) ? ` properties: ${underscore_1.default.keys(value).join(',')}` : ''} hasChanged: ${hasChanged}`);
     // This approach prioritizes fast UI changes without waiting for data to be stored in device storage.
-    const updatePromise = OnyxUtils_1.default.broadcastUpdate(key, valueAfterRemoving, hasChanged, wasRemoved);
+    const updatePromise = OnyxUtils_1.default.broadcastUpdate(key, valueWithoutNullValues, hasChanged, wasRemoved);
     // If the value has not changed or the key got removed, calling Storage.setItem() would be redundant and a waste of performance, so return early instead.
     if (!hasChanged || wasRemoved) {
         return updatePromise;
     }
-    return storage_1.default.setItem(key, valueAfterRemoving)
-        .catch((error) => OnyxUtils_1.default.evictStorageAndRetry(error, set, key, valueAfterRemoving))
+    return storage_1.default.setItem(key, valueWithoutNullValues)
+        .catch((error) => OnyxUtils_1.default.evictStorageAndRetry(error, set, key, valueWithoutNullValues))
         .then(() => {
-        OnyxUtils_1.default.sendActionToDevTools(OnyxUtils_1.default.METHOD.SET, key, valueAfterRemoving);
+        OnyxUtils_1.default.sendActionToDevTools(OnyxUtils_1.default.METHOD.SET, key, valueWithoutNullValues);
         return updatePromise;
     });
 }
@@ -231,7 +233,8 @@ function multiSet(data) {
         .then(() => {
         OnyxUtils_1.default.sendActionToDevTools(OnyxUtils_1.default.METHOD.MULTI_SET, undefined, data);
         return Promise.all(updatePromises);
-    });
+    })
+        .then(() => undefined);
 }
 /**
  * Merge a new value into an existing value at a key.
@@ -344,7 +347,8 @@ function mergeCollection(collectionKey, collection) {
     if (hasCollectionKeyCheckFailed) {
         return Promise.resolve();
     }
-    return OnyxUtils_1.default.getAllKeys().then((persistedKeys) => {
+    return OnyxUtils_1.default.getAllKeys()
+        .then((persistedKeys) => {
         // Split to keys that exist in storage and keys that don't
         const keys = Object.keys(mergedCollection).filter((key) => {
             if (mergedCollection[key] === null) {
@@ -388,7 +392,8 @@ function mergeCollection(collectionKey, collection) {
             OnyxUtils_1.default.sendActionToDevTools(OnyxUtils_1.default.METHOD.MERGE_COLLECTION, undefined, mergedCollection);
             return promiseUpdate;
         });
-    });
+    })
+        .then(() => undefined);
 }
 /**
  * Clear out all the data in the store
@@ -412,7 +417,8 @@ function mergeCollection(collectionKey, collection) {
  * @param keysToPreserve is a list of ONYXKEYS that should not be cleared with the rest of the data
  */
 function clear(keysToPreserve = []) {
-    return OnyxUtils_1.default.getAllKeys().then((keys) => {
+    return OnyxUtils_1.default.getAllKeys()
+        .then((keys) => {
         const keysToBeClearedFromStorage = [];
         const keyValuesToResetAsCollection = {};
         const keyValuesToResetIndividually = {};
@@ -477,12 +483,13 @@ function clear(keysToPreserve = []) {
             DevTools_1.default.clearState(keysToPreserve);
             return Promise.all(updatePromises);
         });
-    });
+    })
+        .then(() => undefined);
 }
 /**
  * Insert API responses and lifecycle data into Onyx
  *
- * @param data An array of objects with shape {onyxMethod: oneOf('set', 'merge', 'mergeCollection', 'multiSet', 'clear'), key: string, value: *}
+ * @param data An array of objects with update expressions
  * @returns resolves when all operations are complete
  */
 function update(data) {
@@ -525,7 +532,7 @@ function update(data) {
                 break;
         }
     });
-    return clearPromise.then(() => Promise.all(promises.map((p) => p())));
+    return clearPromise.then(() => Promise.all(promises.map((p) => p()))).then(() => undefined);
 }
 const Onyx = {
     METHOD: OnyxUtils_1.default.METHOD,

package/dist/OnyxUtils.d.ts

@@ -1,56 +1,30 @@
-import {Component} from 'react';
-import * as Logger from './Logger';
-import {CollectionKey, CollectionKeyBase, DeepRecord, KeyValueMapping, NullishDeep, OnyxCollection, OnyxEntry, OnyxKey, Selector} from './types';
-
+import type { ValueOf } from 'type-fest';
+import type { DeepRecord, Mapping, CollectionKey, CollectionKeyBase, NullableKeyValueMapping, OnyxKey, OnyxValue, OnyxCollection, WithOnyxConnectOptions, OnyxEntry, KeyValueMapping } from './types';
+import type Onyx from './Onyx';
 declare const METHOD: {
-    readonly SET: 'set';
-    readonly MERGE: 'merge';
-    readonly MERGE_COLLECTION: 'mergecollection';
-    readonly MULTI_SET: 'multiset';
-    readonly CLEAR: 'clear';
+    readonly SET: "set";
+    readonly MERGE: "merge";
+    readonly MERGE_COLLECTION: "mergecollection";
+    readonly MULTI_SET: "multiset";
+    readonly CLEAR: "clear";
 };
-
 type OnyxMethod = ValueOf<typeof METHOD>;
-
-// Key/value store of Onyx key and arrays of values to merge
-declare const mergeQueue: Record<OnyxKey, OnyxValue<OnyxKey>[]>;
-declare const mergeQueuePromise: Record<OnyxKey, Promise<void | void[]>>;
-
-// Holds a mapping of all the react components that want their state subscribed to a store key
-declare const callbackToStateMapping: Record<string, Mapping<OnyxKey>>;
-
-// Keeps a copy of the values of the onyx collection keys as a map for faster lookups
-declare let onyxCollectionKeyMap: Map<OnyxKey, OnyxValue<OnyxKey>>;
-
-// Holds a list of keys that have been directly subscribed to or recently modified from least to most recent
-declare let recentlyAccessedKeys: OnyxKey[];
-
-// Holds a list of keys that are safe to remove when we reach max storage. If a key does not match with
-// whatever appears in this list it will NEVER be a candidate for eviction.
-declare let evictionAllowList: OnyxKey[];
-
-// Holds a map of keys and connectionID arrays whose keys will never be automatically evicted as
-// long as we have at least one subscriber that returns false for the canEvict property.
-declare const evictionBlocklist: Record<OnyxKey, number[]>;
-
-// Optional user-provided key value states set when Onyx initializes or clears
-declare let defaultKeyStates: Record<OnyxKey, OnyxValue<OnyxKey>>;
-
-declare let batchUpdatesPromise: Promise<void> | null;
-declare let batchUpdatesQueue: Array<() => void>;
-
-/** Getter - returns the merge queue. */
-declare function getMergeQueue(): Record<string, OnyxValue<string>[]>;
-
-/** Getter - returns the merge queue promise. */
-declare function getMergeQueuePromise(): Record<string, Promise<void | void[]>>;
-
-/** Getter - returns the callback to state mapping. */
-declare function getCallbackToStateMapping(): Record<string, Mapping<string>>;
-
-/** Getter - returns the default key states. */
-declare function getDefaultKeyStates(): Record<string, OnyxValue<string>>;
-
+/**
+ * Getter - returns the merge queue.
+ */
+declare function getMergeQueue(): Record<OnyxKey, Array<OnyxValue<OnyxKey>>>;
+/**
+ * Getter - returns the merge queue promise.
+ */
+declare function getMergeQueuePromise(): Record<OnyxKey, Promise<void>>;
+/**
+ * Getter - returns the callback to state mapping.
+ */
+declare function getCallbackToStateMapping(): Record<string, Mapping<OnyxKey>>;
+/**
+ * Getter - returns the default key states.
+ */
+declare function getDefaultKeyStates(): Record<OnyxKey, OnyxValue<OnyxKey>>;
 /**
  * Sets the initial values for the Onyx store
  *
@@ -59,7 +33,6 @@ declare function getDefaultKeyStates(): Record<string, OnyxValue<string>>;
  * @param safeEvictionKeys - This is an array of keys (individual or collection patterns) that when provided to Onyx are flagged as "safe" for removal.
  */
 declare function initStoreValues(keys: DeepRecord<string, OnyxKey>, initialKeyStates: Partial<NullableKeyValueMapping>, safeEvictionKeys: OnyxKey[]): void;
-
 /**
  * Sends an action to DevTools extension
  *
@@ -68,9 +41,8 @@ declare function initStoreValues(keys: DeepRecord<string, OnyxKey>, initialKeySt
  * @param value - contains the change that was made by the method
  * @param mergedValue - (optional) value that was written in the storage after a merge method was executed.
  */
-declare function sendActionToDevTools(method: OnyxMethod, key: undefined, value: Record<OnyxKey, OnyxValue<OnyxKey>>, mergedValue?: OnyxValue<OnyxKey>): void;
-declare function sendActionToDevTools(method: OnyxMethod, key: OnyxKey, value: OnyxValue<OnyxKey>, mergedValue?: OnyxValue<OnyxKey>): void;
-
+declare function sendActionToDevTools(method: typeof METHOD.MERGE_COLLECTION | typeof METHOD.MULTI_SET, key: undefined, value: OnyxCollection<KeyValueMapping[OnyxKey]>, mergedValue?: undefined): void;
+declare function sendActionToDevTools(method: Exclude<OnyxMethod, typeof METHOD.MERGE_COLLECTION | typeof METHOD.MULTI_SET>, key: OnyxKey, value: OnyxEntry<KeyValueMapping[OnyxKey]>, mergedValue?: OnyxEntry<KeyValueMapping[OnyxKey]>): void;
 /**
  * We are batching together onyx updates. This helps with use cases where we schedule onyx updates after each other.
  * This happens for example in the Onyx.update function, where we process API responses that might contain a lot of
@@ -78,190 +50,132 @@ declare function sendActionToDevTools(method: OnyxMethod, key: OnyxKey, value: O
  * cause react to schedule the updates at once instead of after each other. This is mainly a performance optimization.
  */
 declare function maybeFlushBatchUpdates(): Promise<void>;
-
 declare function batchUpdates(updates: () => void): Promise<void>;
-
 /** Get some data from the store */
 declare function get(key: OnyxKey): Promise<OnyxValue<OnyxKey>>;
-
-/**
- * Returns current key names stored in persisted storage
- */
-declare function getAllKeys(): Promise<Set<string>>;
-
+/** Returns current key names stored in persisted storage */
+declare function getAllKeys(): Promise<Set<OnyxKey>>;
 /**
  * Checks to see if the a subscriber's supplied key
  * is associated with a collection of keys.
  */
 declare function isCollectionKey(key: OnyxKey): key is CollectionKeyBase;
-
 declare function isCollectionMemberKey<TCollectionKey extends CollectionKeyBase>(collectionKey: TCollectionKey, key: string): key is `${TCollectionKey}${string}`;
-
 /**
  * Splits a collection member key into the collection key part and the ID part.
  * @param key - The collection member key to split.
  * @returns A tuple where the first element is the collection part and the second element is the ID part.
  */
 declare function splitCollectionMemberKey<TKey extends CollectionKey>(key: TKey): [TKey extends `${infer Prefix}_${string}` ? `${Prefix}_` : never, string];
-
 /**
  * Checks to see if a provided key is the exact configured key of our connected subscriber
  * or if the provided key is a collection member key (in case our configured key is a "collection key")
  */
 declare function isKeyMatch(configKey: OnyxKey, key: OnyxKey): boolean;
-
-/**
- * Checks to see if this key has been flagged as
- * safe for removal.
- */
+/** Checks to see if this key has been flagged as safe for removal. */
 declare function isSafeEvictionKey(testKey: OnyxKey): boolean;
-
 /**
  * Tries to get a value from the cache. If the value is not present in cache it will return the default value or undefined.
  * If the requested key is a collection, it will return an object with all the collection members.
  */
-declare function tryGetCachedValue<TKey extends OnyxKey>(key: TKey, mapping: Mapping<TKey>): OnyxValue<OnyxKey>;
-
-/** Remove a key from the recently accessed key list. */
+declare function tryGetCachedValue<TKey extends OnyxKey>(key: TKey, mapping?: Partial<WithOnyxConnectOptions<TKey>>): OnyxValue<OnyxKey>;
+/**
+ * Remove a key from the recently accessed key list.
+ */
 declare function removeLastAccessedKey(key: OnyxKey): void;
-
 /**
- * Add a key to the list of recently accessed keys.
- * The least recently accessed key should be at the head and the most recently accessed key at the tail.
+ * Add a key to the list of recently accessed keys. The least
+ * recently accessed key should be at the head and the most
+ * recently accessed key at the tail.
  */
 declare function addLastAccessedKey(key: OnyxKey): void;
-
 /**
  * Removes a key previously added to this list
  * which will enable it to be deleted again.
  */
 declare function removeFromEvictionBlockList(key: OnyxKey, connectionID: number): void;
-
-/**
- * Keys added to this list can never be deleted.
- */
+/** Keys added to this list can never be deleted. */
 declare function addToEvictionBlockList(key: OnyxKey, connectionID: number): void;
-
 /**
  * Take all the keys that are safe to evict and add them to
  * the recently accessed list when initializing the app. This
- * enables keys that have not recently been accessed to be removed.
+ * enables keys that have not recently been accessed to be
+ * removed.
  */
 declare function addAllSafeEvictionKeysToRecentlyAccessedList(): Promise<void>;
-
-declare function getCachedCollection<TKey extends CollectionKeyBase>(collectionKey: TKey): Record<OnyxKey, OnyxValue<OnyxKey>>;
-
-/** When a collection of keys change, search for any callbacks matching the collection key and trigger those callbacks */
-declare function keysChanged<TKey extends CollectionKeyBase>(
-    collectionKey: TKey,
-    partialCollection: OnyxCollection<OnyxValue<OnyxKey>>,
-    notifyRegularSubscibers?: boolean,
-    notifyWithOnyxSubscibers?: boolean,
-): void;
+declare function getCachedCollection<TKey extends CollectionKeyBase>(collectionKey: TKey): NonNullable<OnyxCollection<KeyValueMapping[TKey]>>;
+/**
+ * When a collection of keys change, search for any callbacks matching the collection key and trigger those callbacks
+ */
+declare function keysChanged<TKey extends CollectionKeyBase>(collectionKey: TKey, partialCollection: OnyxCollection<KeyValueMapping[TKey]>, notifyRegularSubscibers?: boolean, notifyWithOnyxSubscibers?: boolean): void;
 /**
  * When a key change happens, search for any callbacks matching the key or collection key and trigger those callbacks
  *
  * @example
  * keyChanged(key, value, subscriber => subscriber.initWithStoredValues === false)
- *
- * @param [canUpdateSubscriber] only subscribers that pass this truth test will be updated
  */
-declare function keyChanged(
-    key: OnyxKey,
-    data: OnyxValue<OnyxKey>,
-    prevData: OnyxValue<OnyxKey>,
-    canUpdateSubscriber?: (_subscriber: Mapping<OnyxKey>) => boolean,
-    notifyRegularSubscibers?: boolean,
-    notifyWithOnyxSubscibers?: boolean,
-): void;
-
+declare function keyChanged<TKey extends OnyxKey>(key: TKey, data: OnyxValue<TKey>, prevData: OnyxValue<TKey>, canUpdateSubscriber?: (subscriber?: Mapping<OnyxKey>) => boolean, notifyRegularSubscibers?: boolean, notifyWithOnyxSubscibers?: boolean): void;
 /**
  * Sends the data obtained from the keys to the connection. It either:
  *     - sets state on the withOnyxInstances
  *     - triggers the callback function
  */
-declare function sendDataToConnection<TKey extends OnyxKey>(
-    mapping: Mapping<TKey>,
-    val: OnyxValue<OnyxKey> | Record<OnyxKey, OnyxValue<OnyxKey>>,
-    matchedKey: TKey | undefined,
-    isBatched: boolean,
-): void;
-
+declare function sendDataToConnection<TKey extends OnyxKey>(mapping: Mapping<TKey>, val: OnyxValue<TKey>, matchedKey: TKey | undefined, isBatched: boolean): void;
 /**
  * We check to see if this key is flagged as safe for eviction and add it to the recentlyAccessedKeys list so that when we
  * run out of storage the least recently accessed key can be removed.
  */
 declare function addKeyToRecentlyAccessedIfNeeded<TKey extends OnyxKey>(mapping: Mapping<TKey>): void;
-
 /**
  * Gets the data for a given an array of matching keys, combines them into an object, and sends the result back to the subscriber.
  */
 declare function getCollectionDataAndSendAsObject<TKey extends OnyxKey>(matchingKeys: CollectionKeyBase[], mapping: Mapping<TKey>): void;
-
 /**
  * Schedules an update that will be appended to the macro task queue (so it doesn't update the subscribers immediately).
  *
  * @example
  * scheduleSubscriberUpdate(key, value, subscriber => subscriber.initWithStoredValues === false)
  */
-declare function scheduleSubscriberUpdate<TKey extends OnyxKey>(
-    key: TKey,
-    value: KeyValueMapping[TKey],
-    prevValue: KeyValueMapping[TKey],
-    canUpdateSubscriber?: (_subscriber: Mapping<OnyxKey>) => boolean,
-): Promise<void>;
-
+declare function scheduleSubscriberUpdate<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>, prevValue: OnyxValue<TKey>, canUpdateSubscriber?: (subscriber?: Mapping<OnyxKey>) => boolean): Promise<void>;
 /**
  * This method is similar to notifySubscribersOnNextTick but it is built for working specifically with collections
  * so that keysChanged() is triggered for the collection and not keyChanged(). If this was not done, then the
  * subscriber callbacks receive the data in a different format than they normally expect and it breaks code.
  */
-declare function scheduleNotifyCollectionSubscribers(key: OnyxKey, value: OnyxCollection<OnyxValue<OnyxKey>>): Promise<void>;
-
+declare function scheduleNotifyCollectionSubscribers<TKey extends OnyxKey>(key: TKey, value: OnyxCollection<KeyValueMapping[TKey]>): Promise<void>;
 /**
  * Remove a key from Onyx and update the subscribers
  */
 declare function remove<TKey extends OnyxKey>(key: TKey): Promise<void>;
-
 declare function reportStorageQuota(): Promise<void>;
-
 /**
  * If we fail to set or merge we must handle this by
  * evicting some data from Onyx and then retrying to do
  * whatever it is we attempted to do.
  */
-declare function evictStorageAndRetry<TMethod extends typeof Onyx.set | typeof Onyx.multiSet | typeof Onyx.mergeCollection>(
-    error: Error,
-    onyxMethod: TMethod,
-    ...args: Parameters<TMethod>
-): Promise<void>;
-
-/** Notifies subscribers and writes current value to cache */
-declare function broadcastUpdate<TKey extends OnyxKey>(key: TKey, value: KeyValueMapping[TKey], hasChanged: boolean, wasRemoved?: boolean): Promise<void[]>;
-
+declare function evictStorageAndRetry<TMethod extends typeof Onyx.set | typeof Onyx.multiSet | typeof Onyx.mergeCollection>(error: Error, onyxMethod: TMethod, ...args: Parameters<TMethod>): Promise<void>;
 /**
- * @private
+ * Notifies subscribers and writes current value to cache
  */
+declare function broadcastUpdate<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>, hasChanged?: boolean, wasRemoved?: boolean): Promise<void>;
 declare function hasPendingMergeForKey(key: OnyxKey): boolean;
-
+type RemoveNullValuesOutput = {
+    value: Record<string, unknown> | unknown[] | null;
+    wasRemoved: boolean;
+};
 /**
  * Removes a key from storage if the value is null.
  * Otherwise removes all nested null values in objects and returns the object
+ *
  * @returns The value without null values and a boolean "wasRemoved", which indicates if the key got removed completely
  */
-declare function removeNullValues<TKey extends OnyxKey>(
-    key: TKey,
-    value: OnyxValue<TKey>,
-): {
-    value: OnyxValue<TKey>;
-    wasRemoved: boolean;
-};
+declare function removeNullValues(key: OnyxKey, value: OnyxValue<OnyxKey>): RemoveNullValuesOutput;
 /**
  * Storage expects array like: [["@MyApp_user", value_1], ["@MyApp_key", value_2]]
  * This method transforms an object like {'@MyApp_user': myUserValue, '@MyApp_key': myKeyValue}
  * to an array of key-value pairs in the above format and removes key-value pairs that are being set to null
- *
- * @return an array of key - value pairs <[key, value]>
+
+* @return an array of key - value pairs <[key, value]>
  */
 declare function prepareKeyValuePairsForStorage(data: Record<OnyxKey, OnyxValue<OnyxKey>>): Array<[OnyxKey, OnyxValue<OnyxKey>]>;
 /**
@@ -269,52 +183,56 @@ declare function prepareKeyValuePairsForStorage(data: Record<OnyxKey, OnyxValue<
  *
  * @param changes Array of changes that should be applied to the existing value
  */
-declare function applyMerge(existingValue: OnyxValue<OnyxKey>, changes: Array<OnyxValue<OnyxKey>>, shouldRemoveNullObjectValues: boolean): any;
+declare function applyMerge(existingValue: OnyxValue<OnyxKey>, changes: Array<OnyxValue<OnyxKey>>, shouldRemoveNullObjectValues: boolean): OnyxValue<OnyxKey>;
 /**
  * Merge user provided default key value pairs.
  */
 declare function initializeWithDefaultKeyStates(): Promise<void>;
-
-const OnyxUtils = {
-    METHOD,
-    getMergeQueue,
-    getMergeQueuePromise,
-    getCallbackToStateMapping,
-    getDefaultKeyStates,
-    initStoreValues,
-    sendActionToDevTools,
-    maybeFlushBatchUpdates,
-    batchUpdates,
-    get,
-    getAllKeys,
-    isCollectionKey,
-    isCollectionMemberKey,
-    splitCollectionMemberKey,
-    isKeyMatch,
-    isSafeEvictionKey,
-    tryGetCachedValue,
-    removeLastAccessedKey,
-    addLastAccessedKey,
-    removeFromEvictionBlockList,
-    addToEvictionBlockList,
-    addAllSafeEvictionKeysToRecentlyAccessedList,
-    getCachedCollection,
-    keysChanged,
-    keyChanged,
-    sendDataToConnection,
-    addKeyToRecentlyAccessedIfNeeded,
-    getCollectionDataAndSendAsObject,
-    scheduleSubscriberUpdate,
-    scheduleNotifyCollectionSubscribers,
-    remove,
-    reportStorageQuota,
-    evictStorageAndRetry,
-    broadcastUpdate,
-    hasPendingMergeForKey,
-    removeNullValues,
-    prepareKeyValuePairsForStorage,
-    applyMerge,
-    initializeWithDefaultKeyStates,
-} as const;
-
+declare const OnyxUtils: {
+    METHOD: {
+        readonly SET: "set";
+        readonly MERGE: "merge";
+        readonly MERGE_COLLECTION: "mergecollection";
+        readonly MULTI_SET: "multiset";
+        readonly CLEAR: "clear";
+    };
+    getMergeQueue: typeof getMergeQueue;
+    getMergeQueuePromise: typeof getMergeQueuePromise;
+    getCallbackToStateMapping: typeof getCallbackToStateMapping;
+    getDefaultKeyStates: typeof getDefaultKeyStates;
+    initStoreValues: typeof initStoreValues;
+    sendActionToDevTools: typeof sendActionToDevTools;
+    maybeFlushBatchUpdates: typeof maybeFlushBatchUpdates;
+    batchUpdates: typeof batchUpdates;
+    get: typeof get;
+    getAllKeys: typeof getAllKeys;
+    isCollectionKey: typeof isCollectionKey;
+    isCollectionMemberKey: typeof isCollectionMemberKey;
+    splitCollectionMemberKey: typeof splitCollectionMemberKey;
+    isKeyMatch: typeof isKeyMatch;
+    isSafeEvictionKey: typeof isSafeEvictionKey;
+    tryGetCachedValue: typeof tryGetCachedValue;
+    removeLastAccessedKey: typeof removeLastAccessedKey;
+    addLastAccessedKey: typeof addLastAccessedKey;
+    removeFromEvictionBlockList: typeof removeFromEvictionBlockList;
+    addToEvictionBlockList: typeof addToEvictionBlockList;
+    addAllSafeEvictionKeysToRecentlyAccessedList: typeof addAllSafeEvictionKeysToRecentlyAccessedList;
+    getCachedCollection: typeof getCachedCollection;
+    keysChanged: typeof keysChanged;
+    keyChanged: typeof keyChanged;
+    sendDataToConnection: typeof sendDataToConnection;
+    addKeyToRecentlyAccessedIfNeeded: typeof addKeyToRecentlyAccessedIfNeeded;
+    getCollectionDataAndSendAsObject: typeof getCollectionDataAndSendAsObject;
+    scheduleSubscriberUpdate: typeof scheduleSubscriberUpdate;
+    scheduleNotifyCollectionSubscribers: typeof scheduleNotifyCollectionSubscribers;
+    remove: typeof remove;
+    reportStorageQuota: typeof reportStorageQuota;
+    evictStorageAndRetry: typeof evictStorageAndRetry;
+    broadcastUpdate: typeof broadcastUpdate;
+    hasPendingMergeForKey: typeof hasPendingMergeForKey;
+    removeNullValues: typeof removeNullValues;
+    prepareKeyValuePairsForStorage: typeof prepareKeyValuePairsForStorage;
+    applyMerge: typeof applyMerge;
+    initializeWithDefaultKeyStates: typeof initializeWithDefaultKeyStates;
+};
 export default OnyxUtils;