@salesforce/lds-worker-api 1.275.0 → 1.276.0

package/dist/standalone/umd/lds-worker-api.js

@@ -4034,7 +4034,7 @@
         }
         return resourceParams;
     }
-    // engine version: 0.154.11-e144742b
+    // engine version: 0.154.12-43ac02c6
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -4162,7 +4162,7 @@
         }
         callbacks.push(callback);
     }
-    // version: 1.275.0-c8b3e2f72
+    // version: 1.276.0-dcebc4076
 
     // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
     function instrumentAdapter$1(createFunction, _metadata) {
@@ -15670,7 +15670,7 @@
         }
         return superResult;
     }
-    // version: 1.275.0-c8b3e2f72
+    // version: 1.276.0-dcebc4076
 
     function unwrap(data) {
         // The lwc-luvio bindings import a function from lwc called "unwrap".
@@ -16595,7 +16595,7 @@
         const { apiFamily, name } = metadata;
         return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
     }
-    // version: 1.275.0-c8b3e2f72
+    // version: 1.276.0-dcebc4076
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -16694,7 +16694,7 @@
         TypeCheckShapes[TypeCheckShapes["Integer"] = 3] = "Integer";
         TypeCheckShapes[TypeCheckShapes["Unsupported"] = 4] = "Unsupported";
     })(TypeCheckShapes || (TypeCheckShapes = {}));
-    // engine version: 0.154.11-e144742b
+    // engine version: 0.154.12-43ac02c6
 
     const { keys: ObjectKeys$3, create: ObjectCreate$3 } = Object;
 
@@ -22259,6 +22259,461 @@
         };
     }
 
+    const VERSION$16$1 = "0b29241fd9ed04bb61fde26b3f558ac4";
+    const RepresentationType$R = 'ListInfoSummaryRepresentation';
+    function keyBuilder$1$(luvio, config) {
+        return keyPrefix$2 + '::' + RepresentationType$R + ':' + (config.id === null ? '' : config.id);
+    }
+    function keyBuilderFromType$z(luvio, object) {
+        const keyParams = {
+            id: object.id
+        };
+        return keyBuilder$1$(luvio, keyParams);
+    }
+    function normalize$K(input, existing, path, luvio, store, timestamp) {
+        return input;
+    }
+    const select$1L = function ListInfoSummaryRepresentationSelect() {
+        return {
+            kind: 'Fragment',
+            version: VERSION$16$1,
+            private: [],
+            selections: [
+                {
+                    name: 'apiName',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'id',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'label',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'url',
+                    kind: 'Scalar'
+                }
+            ]
+        };
+    };
+    function equals$Y(existing, incoming) {
+        const existing_apiName = existing.apiName;
+        const incoming_apiName = incoming.apiName;
+        if (!(existing_apiName === incoming_apiName)) {
+            return false;
+        }
+        const existing_label = existing.label;
+        const incoming_label = incoming.label;
+        if (!(existing_label === incoming_label)) {
+            return false;
+        }
+        const existing_url = existing.url;
+        const incoming_url = incoming.url;
+        if (!(existing_url === incoming_url)) {
+            return false;
+        }
+        const existing_id = existing.id;
+        const incoming_id = incoming.id;
+        if (!(existing_id === incoming_id)) {
+            return false;
+        }
+        return true;
+    }
+    const ingest$K$1 = function ListInfoSummaryRepresentationIngest(input, path, luvio, store, timestamp) {
+        const key = keyBuilderFromType$z(luvio, input);
+        const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
+        ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$K, "UiApi", VERSION$16$1, RepresentationType$R, equals$Y);
+        return createLink$3(key);
+    };
+    function getTypeCacheKeys$R$1(rootKeySet, luvio, input, fullPathFactory) {
+        // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+        const rootKey = keyBuilderFromType$z(luvio, input);
+        rootKeySet.set(rootKey, {
+            namespace: keyPrefix$2,
+            representationName: RepresentationType$R,
+            mergeable: false
+        });
+    }
+
+    const VERSION$15$1 = "d0cadb0927f908b5b64694e1cff0b2d7";
+    const RepresentationType$Q = 'ListInfoSummaryCollectionRepresentation';
+    function keyBuilder$1_(luvio, config) {
+        return keyPrefix$2 + '::' + RepresentationType$Q + ':' + config.objectApiName + ':' + (config.queryString === null ? '' : config.queryString) + ':' + config.recentListsOnly;
+    }
+    function keyBuilderFromType$y(luvio, object) {
+        const keyParams = {
+            objectApiName: object.objectApiName,
+            queryString: object.queryString,
+            recentListsOnly: object.recentListsOnly
+        };
+        return keyBuilder$1_(luvio, keyParams);
+    }
+    function normalize$J(input, existing, path, luvio, store, timestamp) {
+        const input_lists = input.lists;
+        const input_lists_id = path.fullPath + '__lists';
+        for (let i = 0; i < input_lists.length; i++) {
+            const input_lists_item = input_lists[i];
+            let input_lists_item_id = input_lists_id + '__' + i;
+            input_lists[i] = ingest$K$1(input_lists_item, {
+                fullPath: input_lists_item_id,
+                propertyName: i,
+                parent: {
+                    data: input,
+                    key: path.fullPath,
+                    existing: existing,
+                },
+                ttl: path.ttl
+            }, luvio, store, timestamp);
+        }
+        return input;
+    }
+    const select$1K = function ListInfoSummaryCollectionRepresentationSelect(paginationParams) {
+        return {
+            kind: 'Fragment',
+            reader: true,
+            synthetic: false,
+            version: VERSION$15$1,
+            read: (source, reader) => {
+                const sink = {};
+                if (paginationParams === undefined) {
+                    return sink;
+                }
+                const metadata = reader.resolveMetadata(source, PAGINATION_VERSION$1);
+                const currentPageMetadata = getPageMetadata$2(metadata, paginationParams);
+                const { startOffset, endOffset, metadataProperties } = currentPageMetadata;
+                if (metadata !== undefined && startOffset !== undefined && endOffset !== undefined) {
+                    const itemsProperty = 'lists';
+                    reader.enterPath(itemsProperty);
+                    const itemsSource = source[itemsProperty];
+                    const itemsSink = [];
+                    const allSink = [];
+                    for (let i = startOffset; i < endOffset; i++) {
+                        reader.enterPath(i);
+                        reader.readSingleLink(i, {
+                            name: 'lists',
+                            kind: 'Link',
+                            fragment: select$1L()
+                        }, itemsSource, allSink, i - startOffset);
+                        if (reader.getIsDataMissing() === false) {
+                            itemsSink[i - startOffset] = allSink[i - startOffset];
+                        }
+                        reader.exitPath();
+                    }
+                    reader.exitPath();
+                    reader.assignNonScalar(sink, itemsProperty, itemsSink);
+                }
+                reader.enterPath('currentPageToken');
+                reader.readScalar('currentPageToken', metadataProperties, sink);
+                reader.exitPath();
+                reader.enterPath('nextPageToken');
+                reader.readScalar('nextPageToken', metadataProperties, sink);
+                reader.exitPath();
+                reader.enterPath('previousPageToken');
+                reader.readScalar('previousPageToken', metadataProperties, sink);
+                reader.exitPath();
+                reader.enterPath('pageSize');
+                reader.readScalar('pageSize', metadataProperties, sink);
+                reader.exitPath();
+                reader.enterPath('count');
+                reader.readScalar('count', metadataProperties, sink);
+                reader.exitPath();
+                reader.enterPath('objectApiName');
+                reader.readScalar('objectApiName', source, sink);
+                reader.exitPath();
+                reader.enterPath('queryString');
+                reader.readScalar('queryString', source, sink);
+                reader.exitPath();
+                reader.enterPath('recentListsOnly');
+                reader.readScalar('recentListsOnly', source, sink);
+                reader.exitPath();
+                return sink;
+            },
+        };
+    };
+    function getPageMetadata$2(paginationMetadata, paginationParams) {
+        const metadataProperties = {};
+        const sink = {
+            metadataProperties
+        };
+        if (paginationMetadata === undefined) {
+            return sink;
+        }
+        const { token, pageSize } = paginationParams;
+        const pageTokenAndOffset = getPageTokenAndOffset$1(paginationMetadata, token);
+        if (pageTokenAndOffset === undefined) {
+            return sink;
+        }
+        const [pageToken, startOffset] = pageTokenAndOffset;
+        const endOffset = pageEndOffset$1(paginationMetadata, startOffset, pageSize);
+        sink.startOffset = startOffset;
+        sink.endOffset = endOffset;
+        metadataProperties.currentPageToken = pageToken;
+        const nextToken = getNextPageToken$1(paginationMetadata, endOffset);
+        if (nextToken !== undefined) {
+            metadataProperties.nextPageToken = nextToken;
+        }
+        const previousToken = getPreviousPageToken(paginationMetadata, startOffset, pageSize);
+        if (previousToken !== undefined) {
+            metadataProperties.previousPageToken = previousToken;
+        }
+        metadataProperties.pageSize = pageSize;
+        metadataProperties.count = endOffset - startOffset;
+        return sink;
+    }
+    function equals$X(existing, incoming) {
+        const existing_recentListsOnly = existing.recentListsOnly;
+        const incoming_recentListsOnly = incoming.recentListsOnly;
+        if (!(existing_recentListsOnly === incoming_recentListsOnly)) {
+            return false;
+        }
+        const existing_count = existing.count;
+        const incoming_count = incoming.count;
+        if (!(existing_count === incoming_count)) {
+            return false;
+        }
+        const existing_pageSize = existing.pageSize;
+        const incoming_pageSize = incoming.pageSize;
+        if (!(existing_pageSize === incoming_pageSize)) {
+            return false;
+        }
+        const existing_currentPageToken = existing.currentPageToken;
+        const incoming_currentPageToken = incoming.currentPageToken;
+        if (!(existing_currentPageToken === incoming_currentPageToken)) {
+            return false;
+        }
+        const existing_currentPageUrl = existing.currentPageUrl;
+        const incoming_currentPageUrl = incoming.currentPageUrl;
+        if (!(existing_currentPageUrl === incoming_currentPageUrl)) {
+            return false;
+        }
+        const existing_eTag = existing.eTag;
+        const incoming_eTag = incoming.eTag;
+        if (!(existing_eTag === incoming_eTag)) {
+            return false;
+        }
+        const existing_objectApiName = existing.objectApiName;
+        const incoming_objectApiName = incoming.objectApiName;
+        if (!(existing_objectApiName === incoming_objectApiName)) {
+            return false;
+        }
+        const existing_lists = existing.lists;
+        const incoming_lists = incoming.lists;
+        const equals_lists_items = equalsArray(existing_lists, incoming_lists, (existing_lists_item, incoming_lists_item) => {
+            if (!(existing_lists_item.__ref === incoming_lists_item.__ref)) {
+                return false;
+            }
+        });
+        if (equals_lists_items === false) {
+            return false;
+        }
+        const existing_nextPageToken = existing.nextPageToken;
+        const incoming_nextPageToken = incoming.nextPageToken;
+        if (!(existing_nextPageToken === incoming_nextPageToken)) {
+            return false;
+        }
+        const existing_nextPageUrl = existing.nextPageUrl;
+        const incoming_nextPageUrl = incoming.nextPageUrl;
+        if (!(existing_nextPageUrl === incoming_nextPageUrl)) {
+            return false;
+        }
+        const existing_previousPageToken = existing.previousPageToken;
+        const incoming_previousPageToken = incoming.previousPageToken;
+        if (!(existing_previousPageToken === incoming_previousPageToken)) {
+            return false;
+        }
+        const existing_previousPageUrl = existing.previousPageUrl;
+        const incoming_previousPageUrl = incoming.previousPageUrl;
+        if (!(existing_previousPageUrl === incoming_previousPageUrl)) {
+            return false;
+        }
+        const existing_queryString = existing.queryString;
+        const incoming_queryString = incoming.queryString;
+        if (!(existing_queryString === incoming_queryString)) {
+            return false;
+        }
+        return true;
+    }
+    const ingest$J$1 = function ListInfoSummaryCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
+        const key = keyBuilderFromType$y(luvio, input);
+        const existingRecord = store.readEntry(key);
+        const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
+        let incomingRecord = normalize$J(input, store.readEntry(key), {
+            fullPath: key,
+            parent: path.parent,
+            propertyName: path.propertyName,
+            ttl: ttlToUse
+        }, luvio, store, timestamp);
+        const paginationKey = key + '__pagination';
+        const existingPaginationMetadata = store.readEntry(paginationKey);
+        const { count: count, currentPageToken: token, nextPageToken: nextToken, pageSize: pageSize, previousPageToken: previousToken, lists: items } = input;
+        const startOffset = existingPaginationMetadata === undefined ? 0 : offsetFromToken$1(existingPaginationMetadata, token);
+        const incomingPaginationMetadata = {
+            [token]: startOffset,
+        };
+        const nextOffset = startOffset + items.length;
+        if (nextToken === null) {
+            incomingPaginationMetadata.__END__ = nextOffset;
+        }
+        else {
+            incomingPaginationMetadata[nextToken] = nextOffset;
+            if (existingPaginationMetadata !== undefined) {
+                const listEndOffset = existingPaginationMetadata.__END__;
+                if (listEndOffset !== undefined && nextOffset >= listEndOffset) {
+                    incomingPaginationMetadata.__END__ = undefined;
+                }
+            }
+        }
+        if (previousToken !== null) {
+            incomingPaginationMetadata[previousToken] = Math.max(startOffset - pageSize, 0);
+        }
+        const mergedPaginationMetadata = mergeMetadata$1(existingPaginationMetadata, incomingPaginationMetadata);
+        if (existingPaginationMetadata === undefined ||
+            equalsObject$1(existingPaginationMetadata, mergedPaginationMetadata, (existingProp, incomingProp) => {
+                return existingProp === incomingProp;
+            }) === false) {
+            luvio.storePublish(paginationKey, mergedPaginationMetadata);
+            luvio.publishStoreMetadata(paginationKey, paginationStoreMetadata$1);
+        }
+        assignMetadataLink$1(incomingRecord, paginationKey);
+        if (existingRecord !== undefined && existingRecord.lists !== undefined) {
+            incomingRecord.lists = [
+                ...existingRecord.lists.slice(0, startOffset),
+                ...incomingRecord.lists,
+                ...existingRecord.lists.slice(nextOffset),
+            ];
+        }
+        if (existingRecord === undefined || equals$X(existingRecord, incomingRecord) === false) {
+            luvio.storePublish(key, incomingRecord);
+        }
+        if (ttlToUse !== undefined) {
+            const storeMetadataParams = {
+                ttl: ttlToUse,
+                namespace: "UiApi",
+                version: VERSION$15$1,
+                representationName: RepresentationType$Q,
+                ingestionTimestamp: timestamp,
+            };
+            luvio.publishStoreMetadata(key, storeMetadataParams);
+        }
+        return createLink$3(key);
+    };
+    function getTypeCacheKeys$Q$1(rootKeySet, luvio, input, fullPathFactory) {
+        // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+        const rootKey = keyBuilderFromType$y(luvio, input);
+        rootKeySet.set(rootKey, {
+            namespace: keyPrefix$2,
+            representationName: RepresentationType$Q,
+            mergeable: true
+        });
+        rootKeySet.set(rootKey + '__pagination', {
+            namespace: keyPrefix$2,
+            representationName: RepresentationType$Q,
+            mergeable: true
+        });
+        const input_lists_length = input.lists.length;
+        for (let i = 0; i < input_lists_length; i++) {
+            getTypeCacheKeys$R$1(rootKeySet, luvio, input.lists[i]);
+        }
+    }
+    const notifyUpdateAvailableFactory$3 = (luvio) => {
+        return function notifyListInfoSummaryUpdateAvailable(configs) {
+            const keys = configs.map(c => keyBuilder$1_(luvio, c));
+            return luvio.notifyStoreUpdateAvailable(keys);
+        };
+    };
+
+    const LIST_RECORDS_PREFIX = keyPrefix$2 + '::' + RepresentationType$T;
+    const LIST_SUMMARY_PREFIX = keyPrefix$2 + '::' + RepresentationType$Q;
+    /**
+     * Watch a Luvio instance for ListRecordCollection and ListInfoSummaryCollection cache entries.
+     */
+    let listRecordCollectionCache = new Map();
+    let listSummaryCollectionCache = new Map();
+    function getListRecordCollectionKeys(objectApiName, listViewApiName) {
+        const cacheEntriesByObjectApiName = listRecordCollectionCache.get(objectApiName) || new Map();
+        const keys = cacheEntriesByObjectApiName.get(listViewApiName) || [];
+        return [...keys];
+    }
+    function getListSummaryCollectionKeys(objectApiName, recentLists = undefined) {
+        const cacheEntriesByObjectApiName = listSummaryCollectionCache.get(objectApiName) || new Map();
+        const keys = cacheEntriesByObjectApiName.get(recentLists ? 'true' : 'false') || [];
+        const allKeys = recentLists === undefined ? cacheEntriesByObjectApiName.get('true') || [] : [];
+        return [...keys, ...allKeys];
+    }
+    function addListRecordCollectionKey(objectApiName, listViewApiName, key) {
+        const cacheEntryByObjectName = listRecordCollectionCache.get(objectApiName) || new Map();
+        if (!cacheEntryByObjectName.size) {
+            listRecordCollectionCache.set(objectApiName, cacheEntryByObjectName);
+        }
+        const keys = cacheEntryByObjectName.get(listViewApiName) || new Set();
+        if (!keys.size) {
+            cacheEntryByObjectName.set(listViewApiName, keys);
+        }
+        keys.add(key);
+    }
+    function addListSummaryCollectionKey(objectApiName, recentLists, key) {
+        const cacheEntryByObjectName = listSummaryCollectionCache.get(objectApiName) || new Map();
+        if (!cacheEntryByObjectName.size) {
+            listSummaryCollectionCache.set(objectApiName, cacheEntryByObjectName);
+        }
+        const keys = cacheEntryByObjectName.get(recentLists) || new Set();
+        if (!keys.size) {
+            cacheEntryByObjectName.set(recentLists, keys);
+        }
+        keys.add(key);
+    }
+    function removeListRecordCollectionKeys(objectApiName, listViewApiName) {
+        const cacheEntriesByObjectApiName = listRecordCollectionCache.get(objectApiName) || new Map();
+        cacheEntriesByObjectApiName.delete(listViewApiName);
+    }
+    function removeListSummaryCollectionKeys(objectApiName, recentLists = undefined) {
+        const cacheEntriesByObjectApiName = listSummaryCollectionCache.get(objectApiName) || new Map();
+        cacheEntriesByObjectApiName.delete(recentLists ? 'true' : 'false');
+        if (recentLists === undefined) {
+            cacheEntriesByObjectApiName.delete('true');
+        }
+    }
+    function splitListRecordCollectionKey(key) {
+        const keyElements = key.split(':');
+        return {
+            objectApiName: keyElements[3],
+            listViewApiName: keyElements[7],
+        };
+    }
+    function splitListSummaryCollectionKey(key) {
+        const keyElements = key.split(':');
+        return {
+            objectApiName: keyElements[3],
+            recentLists: keyElements[5],
+        };
+    }
+    function setupListRecordCollectionStoreWatcher(luvio) {
+        luvio.storeWatch(LIST_RECORDS_PREFIX, (entries) => {
+            for (let i = 0, len = entries.length; i < len; i++) {
+                const entry = entries[i];
+                if (entry.id.endsWith('__pagination')) {
+                    continue;
+                }
+                const { objectApiName, listViewApiName } = splitListRecordCollectionKey(entry.id);
+                addListRecordCollectionKey(objectApiName, listViewApiName, entry.id);
+            }
+        });
+    }
+    function setupListSummaryCollectionStoreWatcher(luvio) {
+        luvio.storeWatch(LIST_SUMMARY_PREFIX, (entries) => {
+            for (let i = 0, len = entries.length; i < len; i++) {
+                const entry = entries[i];
+                if (entry.id.endsWith('__pagination')) {
+                    continue;
+                }
+                const { objectApiName, recentLists } = splitListSummaryCollectionKey(entry.id);
+                addListSummaryCollectionKey(objectApiName, recentLists, entry.id);
+            }
+        });
+    }
+
     function buildListRefByIdContextKey(listViewId) {
         return `listReferenceById::${listViewId}`;
     }
@@ -22487,12 +22942,26 @@
             },
         };
     }
+    function setupNotifyAllListRecordUpdateAvailable(luvio) {
+        return (notifyInput) => {
+            const keys = getListRecordCollectionKeys(notifyInput.objectApiName, notifyInput.listViewApiName);
+            removeListRecordCollectionKeys(notifyInput.objectApiName, notifyInput.listViewApiName);
+            return luvio.notifyStoreUpdateAvailable(keys);
+        };
+    }
+    function setupNotifyAllListInfoSummaryUpdateAvailable(luvio) {
+        return (notifyInput) => {
+            const keys = getListSummaryCollectionKeys(notifyInput.objectApiName, notifyInput.recentLists);
+            removeListSummaryCollectionKeys(notifyInput.objectApiName, notifyInput.recentLists);
+            return luvio.notifyStoreUpdateAvailable(keys);
+        };
+    }
 
     let context$1;
     function setContext$1(adapterContext) {
         context$1 = adapterContext;
     }
-    function keyBuilder$1$(luvio, params) {
+    function keyBuilder$1Z(luvio, params) {
         const query = {
             objectApiName: params.urlParams.objectApiName,
             listViewApiName: params.urlParams.listViewApiName,
@@ -22525,7 +22994,7 @@
         });
     }
 
-    function select$1L(luvio, params) {
+    function select$1J(luvio, params) {
         const { fields = [], optionalFields = [] } = params.queryParams;
         return dynamicSelect$7({
             records: {
@@ -22542,7 +23011,7 @@
     }
     function ingestSuccess$P(luvio, resourceParams, response, snapshotRefresh) {
         const { body } = response;
-        const key = keyBuilder$1$(luvio, resourceParams);
+        const key = keyBuilder$1Z(luvio, resourceParams);
         luvio.storeIngest(key, ingest$M$1, body);
         const optionalFields = resourceParams.queryParams.optionalFields;
         if (optionalFields && optionalFields.length > 0) {
@@ -22551,7 +23020,7 @@
         }
         const snapshot = luvio.storeLookup({
             recordId: key,
-            node: select$1L(luvio, resourceParams),
+            node: select$1J(luvio, resourceParams),
             variables: {},
         }, snapshotRefresh);
         return snapshot;
@@ -22579,7 +23048,7 @@
         getTypeCacheKeys$T$1(storeKeyMap, luvio, response);
     }
     function ingestError$I(luvio, params, error, snapshotRefresh) {
-        const key = keyBuilder$1$(luvio, params);
+        const key = keyBuilder$1Z(luvio, params);
         const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
         const storeMetadataParams = {
             ttl: TTL$x,
@@ -22657,24 +23126,24 @@
         return snapshot.state === 'Error';
     }
 
-    const VERSION$16$1 = "3529c5f7d0eb2206c90a52c6d9f721d4";
-    const RepresentationType$R = 'ListViewSummaryRepresentation';
-    function keyBuilder$1_(luvio, config) {
-        return keyPrefix$2 + '::' + RepresentationType$R + ':' + (config.id === null ? '' : config.id);
+    const VERSION$14$1 = "3529c5f7d0eb2206c90a52c6d9f721d4";
+    const RepresentationType$P = 'ListViewSummaryRepresentation';
+    function keyBuilder$1Y(luvio, config) {
+        return keyPrefix$2 + '::' + RepresentationType$P + ':' + (config.id === null ? '' : config.id);
     }
-    function keyBuilderFromType$z(luvio, object) {
+    function keyBuilderFromType$x(luvio, object) {
         const keyParams = {
             id: object.id
         };
-        return keyBuilder$1_(luvio, keyParams);
+        return keyBuilder$1Y(luvio, keyParams);
     }
-    function normalize$K(input, existing, path, luvio, store, timestamp) {
+    function normalize$I(input, existing, path, luvio, store, timestamp) {
         return input;
     }
-    const select$1K = function ListViewSummaryRepresentationSelect() {
+    const select$1I = function ListViewSummaryRepresentationSelect() {
         return {
             kind: 'Fragment',
-            version: VERSION$16$1,
+            version: VERSION$14$1,
             private: [],
             selections: [
                 {
@@ -22696,7 +23165,7 @@
             ]
         };
     };
-    function equals$Y(existing, incoming) {
+    function equals$W(existing, incoming) {
         const existing_apiName = existing.apiName;
         const incoming_apiName = incoming.apiName;
         if (!(existing_apiName === incoming_apiName)) {
@@ -22719,42 +23188,42 @@
         }
         return true;
     }
-    const ingest$K$1 = function ListViewSummaryRepresentationIngest(input, path, luvio, store, timestamp) {
-        const key = keyBuilderFromType$z(luvio, input);
+    const ingest$I$1 = function ListViewSummaryRepresentationIngest(input, path, luvio, store, timestamp) {
+        const key = keyBuilderFromType$x(luvio, input);
         const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
-        ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$K, "UiApi", VERSION$16$1, RepresentationType$R, equals$Y);
+        ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$I, "UiApi", VERSION$14$1, RepresentationType$P, equals$W);
         return createLink$3(key);
     };
-    function getTypeCacheKeys$R$1(rootKeySet, luvio, input, fullPathFactory) {
+    function getTypeCacheKeys$P$1(rootKeySet, luvio, input, fullPathFactory) {
         // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-        const rootKey = keyBuilderFromType$z(luvio, input);
+        const rootKey = keyBuilderFromType$x(luvio, input);
         rootKeySet.set(rootKey, {
             namespace: keyPrefix$2,
-            representationName: RepresentationType$R,
+            representationName: RepresentationType$P,
             mergeable: false
         });
     }
 
-    const VERSION$15$1 = "f4c79fe066da3558499d5ee88c72abcd";
-    const RepresentationType$Q = 'ListViewSummaryCollectionRepresentation';
-    function keyBuilder$1Z(luvio, config) {
-        return keyPrefix$2 + '::' + RepresentationType$Q + ':' + config.objectApiName + ':' + (config.queryString === null ? '' : config.queryString) + ':' + config.recentListsOnly;
+    const VERSION$13$1 = "f4c79fe066da3558499d5ee88c72abcd";
+    const RepresentationType$O = 'ListViewSummaryCollectionRepresentation';
+    function keyBuilder$1X(luvio, config) {
+        return keyPrefix$2 + '::' + RepresentationType$O + ':' + config.objectApiName + ':' + (config.queryString === null ? '' : config.queryString) + ':' + config.recentListsOnly;
     }
-    function keyBuilderFromType$y(luvio, object) {
+    function keyBuilderFromType$w(luvio, object) {
         const keyParams = {
             objectApiName: object.objectApiName,
             queryString: object.queryString,
             recentListsOnly: object.recentListsOnly
         };
-        return keyBuilder$1Z(luvio, keyParams);
+        return keyBuilder$1X(luvio, keyParams);
     }
-    function normalize$J(input, existing, path, luvio, store, timestamp) {
+    function normalize$H(input, existing, path, luvio, store, timestamp) {
         const input_lists = input.lists;
         const input_lists_id = path.fullPath + '__lists';
         for (let i = 0; i < input_lists.length; i++) {
             const input_lists_item = input_lists[i];
             let input_lists_item_id = input_lists_id + '__' + i;
-            input_lists[i] = ingest$K$1(input_lists_item, {
+            input_lists[i] = ingest$I$1(input_lists_item, {
                 fullPath: input_lists_item_id,
                 propertyName: i,
                 parent: {
@@ -22767,19 +23236,19 @@
         }
         return input;
     }
-    const select$1J = function ListViewSummaryCollectionRepresentationSelect(paginationParams) {
+    const select$1H = function ListViewSummaryCollectionRepresentationSelect(paginationParams) {
         return {
             kind: 'Fragment',
             reader: true,
             synthetic: false,
-            version: VERSION$15$1,
+            version: VERSION$13$1,
             read: (source, reader) => {
                 const sink = {};
                 if (paginationParams === undefined) {
                     return sink;
                 }
                 const metadata = reader.resolveMetadata(source, PAGINATION_VERSION$1);
-                const currentPageMetadata = getPageMetadata$2(metadata, paginationParams);
+                const currentPageMetadata = getPageMetadata$1(metadata, paginationParams);
                 const { startOffset, endOffset, metadataProperties } = currentPageMetadata;
                 if (metadata !== undefined && startOffset !== undefined && endOffset !== undefined) {
                     const itemsProperty = 'lists';
@@ -22792,7 +23261,7 @@
                         reader.readSingleLink(i, {
                             name: 'lists',
                             kind: 'Link',
-                            fragment: select$1K()
+                            fragment: select$1I()
                         }, itemsSource, allSink, i - startOffset);
                         if (reader.getIsDataMissing() === false) {
                             itemsSink[i - startOffset] = allSink[i - startOffset];
@@ -22830,7 +23299,7 @@
             },
         };
     };
-    function getPageMetadata$2(paginationMetadata, paginationParams) {
+    function getPageMetadata$1(paginationMetadata, paginationParams) {
         const metadataProperties = {};
         const sink = {
             metadataProperties
@@ -22860,7 +23329,7 @@
         metadataProperties.count = endOffset - startOffset;
         return sink;
     }
-    function equals$X(existing, incoming) {
+    function equals$V(existing, incoming) {
         const existing_recentListsOnly = existing.recentListsOnly;
         const incoming_recentListsOnly = incoming.recentListsOnly;
         if (!(existing_recentListsOnly === incoming_recentListsOnly)) {
@@ -22933,11 +23402,11 @@
         }
         return true;
     }
-    const ingest$J$1 = function ListViewSummaryCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
-        const key = keyBuilderFromType$y(luvio, input);
+    const ingest$H$1 = function ListViewSummaryCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
+        const key = keyBuilderFromType$w(luvio, input);
         const existingRecord = store.readEntry(key);
         const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
-        let incomingRecord = normalize$J(input, store.readEntry(key), {
+        let incomingRecord = normalize$H(input, store.readEntry(key), {
             fullPath: key,
             parent: path.parent,
             propertyName: path.propertyName,
@@ -22982,42 +23451,42 @@
                 ...existingRecord.lists.slice(nextOffset),
             ];
         }
-        if (existingRecord === undefined || equals$X(existingRecord, incomingRecord) === false) {
+        if (existingRecord === undefined || equals$V(existingRecord, incomingRecord) === false) {
             luvio.storePublish(key, incomingRecord);
         }
         if (ttlToUse !== undefined) {
             const storeMetadataParams = {
                 ttl: ttlToUse,
                 namespace: "UiApi",
-                version: VERSION$15$1,
-                representationName: RepresentationType$Q,
+                version: VERSION$13$1,
+                representationName: RepresentationType$O,
                 ingestionTimestamp: timestamp,
             };
             luvio.publishStoreMetadata(key, storeMetadataParams);
         }
         return createLink$3(key);
     };
-    function getTypeCacheKeys$Q$1(rootKeySet, luvio, input, fullPathFactory) {
+    function getTypeCacheKeys$O$1(rootKeySet, luvio, input, fullPathFactory) {
         // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-        const rootKey = keyBuilderFromType$y(luvio, input);
+        const rootKey = keyBuilderFromType$w(luvio, input);
         rootKeySet.set(rootKey, {
             namespace: keyPrefix$2,
-            representationName: RepresentationType$Q,
+            representationName: RepresentationType$O,
             mergeable: true
         });
         rootKeySet.set(rootKey + '__pagination', {
             namespace: keyPrefix$2,
-            representationName: RepresentationType$Q,
+            representationName: RepresentationType$O,
             mergeable: true
         });
         const input_lists_length = input.lists.length;
         for (let i = 0; i < input_lists_length; i++) {
-            getTypeCacheKeys$R$1(rootKeySet, luvio, input.lists[i]);
+            getTypeCacheKeys$P$1(rootKeySet, luvio, input.lists[i]);
         }
     }
-    const notifyUpdateAvailableFactory$3 = (luvio) => {
+    const notifyUpdateAvailableFactory$2 = (luvio) => {
         return function notifyListViewSummaryUpdateAvailable(configs) {
-            const keys = configs.map(c => keyBuilder$1Z(luvio, c));
+            const keys = configs.map(c => keyBuilder$1X(luvio, c));
             return luvio.notifyStoreUpdateAvailable(keys);
         };
     };
@@ -23029,34 +23498,34 @@
             pageSize: queryParams.pageSize === undefined ? 20 : queryParams.pageSize
         };
     }
-    function select$1I(luvio, params) {
+    function select$1G(luvio, params) {
         const paginationParams = createPaginationParams$3(params);
-        return select$1J(paginationParams);
+        return select$1H(paginationParams);
     }
-    function keyBuilder$1Y(luvio, params) {
-        return keyBuilder$1Z(luvio, {
+    function keyBuilder$1W(luvio, params) {
+        return keyBuilder$1X(luvio, {
             objectApiName: params.urlParams.objectApiName,
             queryString: params.queryParams.q || null,
             recentListsOnly: params.queryParams.recentListsOnly || false
         });
     }
     function getResponseCacheKeys$Z(storeKeyMap, luvio, resourceParams, response) {
-        getTypeCacheKeys$Q$1(storeKeyMap, luvio, response);
+        getTypeCacheKeys$O$1(storeKeyMap, luvio, response);
     }
     function ingestSuccess$O(luvio, resourceParams, response, snapshotRefresh) {
         const { body } = response;
-        const key = keyBuilder$1Y(luvio, resourceParams);
-        luvio.storeIngest(key, ingest$J$1, body);
+        const key = keyBuilder$1W(luvio, resourceParams);
+        luvio.storeIngest(key, ingest$H$1, body);
         const snapshot = luvio.storeLookup({
             recordId: key,
-            node: select$1I(luvio, resourceParams),
+            node: select$1G(luvio, resourceParams),
             variables: {},
         }, snapshotRefresh);
         deepFreeze(snapshot.data);
         return snapshot;
     }
     function ingestError$H(luvio, params, error, snapshotRefresh) {
-        const key = keyBuilder$1Y(luvio, params);
+        const key = keyBuilder$1W(luvio, params);
         const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
         luvio.storeIngestError(key, errorSnapshot);
         return errorSnapshot;
@@ -23085,9 +23554,9 @@
     ];
     const getListViewSummaryCollection_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig$2(adapterName$_$1, getListViewSummaryCollection_ConfigPropertyMetadata);
     const createResourceParams$Y = /*#__PURE__*/ createResourceParams$12(getListViewSummaryCollection_ConfigPropertyMetadata);
-    function keyBuilder$1X(luvio, config) {
+    function keyBuilder$1V(luvio, config) {
         const resourceParams = createResourceParams$Y(config);
-        return keyBuilder$1Y(luvio, resourceParams);
+        return keyBuilder$1W(luvio, resourceParams);
     }
     function typeCheckConfig$13(untrustedConfig) {
         const config = {};
@@ -23107,7 +23576,7 @@
     }
     function adapterFragment$G(luvio, config) {
         const resourceParams = createResourceParams$Y(config);
-        return select$1I(luvio, resourceParams);
+        return select$1G(luvio, resourceParams);
     }
     function onFetchResponseSuccess$K(luvio, config, resourceParams, response) {
         const snapshot = ingestSuccess$O(luvio, resourceParams, response, {
@@ -23170,12 +23639,12 @@
         return items.length;
     }
     function getPaginationMetadata$3(luvio, resourceParams) {
-        const key = keyBuilder$1Y(luvio, resourceParams);
+        const key = keyBuilder$1W(luvio, resourceParams);
         const selector = {
             recordId: key,
             node: {
                 kind: 'Fragment',
-                version: VERSION$15$1,
+                version: VERSION$13$1,
                 private: [],
                 selections: [
                     {
@@ -23218,7 +23687,7 @@
     function buildCachedSnapshotCachePolicy$N(context, storeLookup) {
         const { luvio, config } = context;
         const selector = {
-            recordId: keyBuilder$1X(luvio, config),
+            recordId: keyBuilder$1V(luvio, config),
             node: adapterFragment$G(luvio, config),
             variables: {},
         };
@@ -23248,7 +23717,7 @@
             pageSize: queryParams.pageSize === undefined ? 50 : queryParams.pageSize
         };
     }
-    function keyBuilder$1W(luvio, params) {
+    function keyBuilder$1U(luvio, params) {
         return keyBuilder$20(luvio, {
             listViewApiName: null,
             objectApiName: params.urlParams.objectApiName,
@@ -23409,7 +23878,7 @@
         const listFields_ = fields || listFields(luvio, config, listInfo);
         const resourceParams = createResourceParams$X(config);
         const selector = {
-            recordId: keyBuilder$1W(luvio, resourceParams),
+            recordId: keyBuilder$1U(luvio, resourceParams),
             node: buildListUiFragment$1(config, listFields_),
             variables: {},
         };
@@ -24070,24 +24539,24 @@
     };
 
     const TTL$w = 900000;
-    const VERSION$14$1 = "ec9370a0cd56f4769fe9ec5cd942ff30";
-    const RepresentationType$P = 'ObjectInfoRepresentation';
-    function keyBuilder$1V(luvio, config) {
-        return keyPrefix$2 + '::' + RepresentationType$P + ':' + config.apiName;
+    const VERSION$12$1 = "ec9370a0cd56f4769fe9ec5cd942ff30";
+    const RepresentationType$N = 'ObjectInfoRepresentation';
+    function keyBuilder$1T(luvio, config) {
+        return keyPrefix$2 + '::' + RepresentationType$N + ':' + config.apiName;
     }
-    function keyBuilderFromType$x(luvio, object) {
+    function keyBuilderFromType$v(luvio, object) {
         const keyParams = {
             apiName: object.apiName
         };
-        return keyBuilder$1V(luvio, keyParams);
+        return keyBuilder$1T(luvio, keyParams);
     }
-    function normalize$I(input, existing, path, luvio, store, timestamp) {
+    function normalize$G(input, existing, path, luvio, store, timestamp) {
         return input;
     }
-    const select$1H = function ObjectInfoRepresentationSelect() {
+    const select$1F = function ObjectInfoRepresentationSelect() {
         return {
             kind: 'Fragment',
-            version: VERSION$14$1,
+            version: VERSION$12$1,
             private: [
                 'eTag'
             ],
@@ -24189,59 +24658,59 @@
             ]
         };
     };
-    function equals$W(existing, incoming) {
+    function equals$U(existing, incoming) {
         if (existing.eTag !== incoming.eTag) {
             return false;
         }
         return true;
     }
-    const ingest$I$1 = function ObjectInfoRepresentationIngest(input, path, luvio, store, timestamp) {
-        const key = keyBuilderFromType$x(luvio, input);
+    const ingest$G$1 = function ObjectInfoRepresentationIngest(input, path, luvio, store, timestamp) {
+        const key = keyBuilderFromType$v(luvio, input);
         const ttlToUse = TTL$w;
-        ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$I, "UiApi", VERSION$14$1, RepresentationType$P, equals$W);
+        ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$G, "UiApi", VERSION$12$1, RepresentationType$N, equals$U);
         return createLink$3(key);
     };
-    function getTypeCacheKeys$P$1(rootKeySet, luvio, input, fullPathFactory) {
+    function getTypeCacheKeys$N$1(rootKeySet, luvio, input, fullPathFactory) {
         // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-        const rootKey = keyBuilderFromType$x(luvio, input);
+        const rootKey = keyBuilderFromType$v(luvio, input);
         rootKeySet.set(rootKey, {
             namespace: keyPrefix$2,
-            representationName: RepresentationType$P,
+            representationName: RepresentationType$N,
             mergeable: false
         });
     }
 
-    function select$1G(luvio, params) {
-        return select$1H();
+    function select$1E(luvio, params) {
+        return select$1F();
     }
-    function keyBuilder$1U(luvio, params) {
-        return keyBuilder$1V(luvio, {
+    function keyBuilder$1S(luvio, params) {
+        return keyBuilder$1T(luvio, {
             apiName: params.urlParams.objectApiName
         });
     }
     function getResponseCacheKeys$Y(storeKeyMap, luvio, resourceParams, response) {
-        getTypeCacheKeys$P$1(storeKeyMap, luvio, response);
+        getTypeCacheKeys$N$1(storeKeyMap, luvio, response);
     }
     function ingestSuccess$N(luvio, resourceParams, response, snapshotRefresh) {
         const { body } = response;
-        const key = keyBuilder$1U(luvio, resourceParams);
-        luvio.storeIngest(key, ingest$I$1, body);
+        const key = keyBuilder$1S(luvio, resourceParams);
+        luvio.storeIngest(key, ingest$G$1, body);
         const snapshot = luvio.storeLookup({
             recordId: key,
-            node: select$1G(),
+            node: select$1E(),
             variables: {},
         }, snapshotRefresh);
         deepFreeze(snapshot.data);
         return snapshot;
     }
     function ingestError$G(luvio, params, error, snapshotRefresh) {
-        const key = keyBuilder$1U(luvio, params);
+        const key = keyBuilder$1S(luvio, params);
         const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
         const storeMetadataParams = {
             ttl: TTL$w,
             namespace: keyPrefix$2,
-            version: VERSION$14$1,
-            representationName: RepresentationType$P
+            version: VERSION$12$1,
+            representationName: RepresentationType$N
         };
         luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
         return errorSnapshot;
@@ -24266,9 +24735,9 @@
     ];
     const getObjectInfo_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig$2(adapterName$Y, getObjectInfo_ConfigPropertyMetadata);
     const createResourceParams$W = /*#__PURE__*/ createResourceParams$12(getObjectInfo_ConfigPropertyMetadata);
-    function keyBuilder$1T(luvio, config) {
+    function keyBuilder$1R(luvio, config) {
         const resourceParams = createResourceParams$W(config);
-        return keyBuilder$1U(luvio, resourceParams);
+        return keyBuilder$1S(luvio, resourceParams);
     }
     function typeCheckConfig$11(untrustedConfig) {
         const config = {};
@@ -24288,7 +24757,7 @@
     }
     function adapterFragment$F(luvio, config) {
         createResourceParams$W(config);
-        return select$1G();
+        return select$1E();
     }
     function onFetchResponseSuccess$J(luvio, config, resourceParams, response) {
         const snapshot = ingestSuccess$N(luvio, resourceParams, response, {
@@ -24324,7 +24793,7 @@
     function buildCachedSnapshotCachePolicy$M(context, storeLookup) {
         const { luvio, config } = context;
         const selector = {
-            recordId: keyBuilder$1T(luvio, config),
+            recordId: keyBuilder$1R(luvio, config),
             node: adapterFragment$F(luvio, config),
             variables: {},
         };
@@ -24355,27 +24824,27 @@
     })(DiscriminatorValues$5$1 || (DiscriminatorValues$5$1 = {}));
 
     const TTL$v = 900000;
-    const VERSION$13$1 = "fb515e25a89ca1ec154dc865e72b913a";
-    const RepresentationType$O = 'RecordLayoutRepresentation';
-    function keyBuilder$1S(luvio, config) {
-        return keyPrefix$2 + '::' + RepresentationType$O + ':' + (config.recordTypeId === null ? '' : config.recordTypeId) + ':' + (config.objectApiName === null ? '' : config.objectApiName) + ':' + config.layoutType + ':' + config.mode;
+    const VERSION$11$1 = "fb515e25a89ca1ec154dc865e72b913a";
+    const RepresentationType$M = 'RecordLayoutRepresentation';
+    function keyBuilder$1Q(luvio, config) {
+        return keyPrefix$2 + '::' + RepresentationType$M + ':' + (config.recordTypeId === null ? '' : config.recordTypeId) + ':' + (config.objectApiName === null ? '' : config.objectApiName) + ':' + config.layoutType + ':' + config.mode;
     }
-    function keyBuilderFromType$w(luvio, object) {
+    function keyBuilderFromType$u(luvio, object) {
         const keyParams = {
             recordTypeId: object.recordTypeId,
             objectApiName: object.objectApiName,
             layoutType: object.layoutType,
             mode: object.mode
         };
-        return keyBuilder$1S(luvio, keyParams);
+        return keyBuilder$1Q(luvio, keyParams);
     }
-    function normalize$H(input, existing, path, luvio, store, timestamp) {
+    function normalize$F(input, existing, path, luvio, store, timestamp) {
         return input;
     }
-    const select$1F = function RecordLayoutRepresentationSelect() {
+    const select$1D = function RecordLayoutRepresentationSelect() {
         return {
             kind: 'Fragment',
-            version: VERSION$13$1,
+            version: VERSION$11$1,
             private: [
                 'eTag'
             ],
@@ -24413,24 +24882,24 @@
             ]
         };
     };
-    function equals$V(existing, incoming) {
+    function equals$T(existing, incoming) {
         if (existing.eTag !== incoming.eTag) {
             return false;
         }
         return true;
     }
-    const ingest$H$1 = function RecordLayoutRepresentationIngest(input, path, luvio, store, timestamp) {
-        const key = keyBuilderFromType$w(luvio, input);
+    const ingest$F$1 = function RecordLayoutRepresentationIngest(input, path, luvio, store, timestamp) {
+        const key = keyBuilderFromType$u(luvio, input);
         const ttlToUse = TTL$v;
-        ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$H, "UiApi", VERSION$13$1, RepresentationType$O, equals$V);
+        ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$F, "UiApi", VERSION$11$1, RepresentationType$M, equals$T);
         return createLink$3(key);
     };
-    function getTypeCacheKeys$O$1(rootKeySet, luvio, input, fullPathFactory) {
+    function getTypeCacheKeys$M$1(rootKeySet, luvio, input, fullPathFactory) {
         // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-        const rootKey = keyBuilderFromType$w(luvio, input);
+        const rootKey = keyBuilderFromType$u(luvio, input);
         rootKeySet.set(rootKey, {
             namespace: keyPrefix$2,
-            representationName: RepresentationType$O,
+            representationName: RepresentationType$M,
             mergeable: false
         });
     }
@@ -24458,27 +24927,27 @@
     }
 
     const TTL$u = 900000;
-    const VERSION$12$1 = "4ba42e1fa0fb00cf78fce86082da41c9";
-    const RepresentationType$N = 'RecordLayoutUserStateRepresentation';
-    function keyBuilder$1R(luvio, config) {
-        return keyPrefix$2 + '::' + RepresentationType$N + ':' + config.recordTypeId + ':' + config.apiName + ':' + config.layoutType + ':' + config.mode;
+    const VERSION$10$1 = "4ba42e1fa0fb00cf78fce86082da41c9";
+    const RepresentationType$L = 'RecordLayoutUserStateRepresentation';
+    function keyBuilder$1P(luvio, config) {
+        return keyPrefix$2 + '::' + RepresentationType$L + ':' + config.recordTypeId + ':' + config.apiName + ':' + config.layoutType + ':' + config.mode;
     }
-    function keyBuilderFromType$v(luvio, object) {
+    function keyBuilderFromType$t(luvio, object) {
         const keyParams = {
             recordTypeId: object.recordTypeId,
             apiName: object.apiName,
             layoutType: object.layoutType,
             mode: object.mode
         };
-        return keyBuilder$1R(luvio, keyParams);
+        return keyBuilder$1P(luvio, keyParams);
     }
-    function normalize$G(input, existing, path, luvio, store, timestamp) {
+    function normalize$E(input, existing, path, luvio, store, timestamp) {
         return input;
     }
-    const select$1E = function RecordLayoutUserStateRepresentationSelect() {
+    const select$1C = function RecordLayoutUserStateRepresentationSelect() {
         return {
             kind: 'Fragment',
-            version: VERSION$12$1,
+            version: VERSION$10$1,
             private: [
                 'apiName',
                 'recordTypeId',
@@ -24498,32 +24967,32 @@
             ]
         };
     };
-    function equals$U(existing, incoming) {
+    function equals$S(existing, incoming) {
         if (JSONStringify$2(incoming) !== JSONStringify$2(existing)) {
             return false;
         }
         return true;
     }
-    const ingest$G$1 = function RecordLayoutUserStateRepresentationIngest(input, path, luvio, store, timestamp) {
-        const key = keyBuilderFromType$v(luvio, input);
+    const ingest$E$1 = function RecordLayoutUserStateRepresentationIngest(input, path, luvio, store, timestamp) {
+        const key = keyBuilderFromType$t(luvio, input);
         const ttlToUse = TTL$u;
-        ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$G, "UiApi", VERSION$12$1, RepresentationType$N, equals$U);
+        ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$E, "UiApi", VERSION$10$1, RepresentationType$L, equals$S);
         return createLink$3(key);
     };
-    function getTypeCacheKeys$N$1(rootKeySet, luvio, input, fullPathFactory) {
+    function getTypeCacheKeys$L$1(rootKeySet, luvio, input, fullPathFactory) {
         // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-        const rootKey = keyBuilderFromType$v(luvio, input);
+        const rootKey = keyBuilderFromType$t(luvio, input);
         rootKeySet.set(rootKey, {
             namespace: keyPrefix$2,
-            representationName: RepresentationType$N,
+            representationName: RepresentationType$L,
             mergeable: false
         });
     }
 
     const TTL$t = 900000;
-    const VERSION$11$1 = "49cdd4bc235a6094c3559cc7735b3b6d";
-    const RepresentationType$M = 'RecordUiRepresentation';
-    function normalize$F(input, existing, path, luvio, store, timestamp) {
+    const VERSION$$$1 = "49cdd4bc235a6094c3559cc7735b3b6d";
+    const RepresentationType$K = 'RecordUiRepresentation';
+    function normalize$D(input, existing, path, luvio, store, timestamp) {
         const input_layoutUserStates = input.layoutUserStates;
         const input_layoutUserStates_id = path.fullPath + '__layoutUserStates';
         const input_layoutUserStates_keys = Object.keys(input_layoutUserStates);
@@ -24532,7 +25001,7 @@
             const key = input_layoutUserStates_keys[i];
             const input_layoutUserStates_prop = input_layoutUserStates[key];
             const input_layoutUserStates_prop_id = input_layoutUserStates_id + '__' + key;
-            input_layoutUserStates[key] = ingest$G$1(input_layoutUserStates_prop, {
+            input_layoutUserStates[key] = ingest$E$1(input_layoutUserStates_prop, {
                 fullPath: input_layoutUserStates_prop_id,
                 propertyName: key,
                 parent: {
@@ -24569,7 +25038,7 @@
                         const key = input_layouts_prop_prop_prop_keys[i];
                         const input_layouts_prop_prop_prop_prop = input_layouts_prop_prop_prop[key];
                         const input_layouts_prop_prop_prop_prop_id = input_layouts_prop_prop_prop_id + '__' + key;
-                        input_layouts_prop_prop_prop[key] = ingest$H$1(input_layouts_prop_prop_prop_prop, {
+                        input_layouts_prop_prop_prop[key] = ingest$F$1(input_layouts_prop_prop_prop_prop, {
                             fullPath: input_layouts_prop_prop_prop_prop_id,
                             propertyName: key,
                             parent: {
@@ -24591,7 +25060,7 @@
             const key = input_objectInfos_keys[i];
             const input_objectInfos_prop = input_objectInfos[key];
             const input_objectInfos_prop_id = input_objectInfos_id + '__' + key;
-            input_objectInfos[key] = ingest$I$1(input_objectInfos_prop, {
+            input_objectInfos[key] = ingest$G$1(input_objectInfos_prop, {
                 fullPath: input_objectInfos_prop_id,
                 propertyName: key,
                 parent: {
@@ -24623,7 +25092,7 @@
         }
         return input;
     }
-    function equals$T(existing, incoming) {
+    function equals$R(existing, incoming) {
         const existing_eTag = existing.eTag;
         const incoming_eTag = incoming.eTag;
         if (!(existing_eTag === incoming_eTag)) {
@@ -24686,10 +25155,10 @@
         }
         return true;
     }
-    const ingest$F$1 = function RecordUiRepresentationIngest(input, path, luvio, store, timestamp) {
+    const ingest$D$1 = function RecordUiRepresentationIngest(input, path, luvio, store, timestamp) {
         const key = path.fullPath;
         const ttlToUse = TTL$t;
-        ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$F, "UiApi", VERSION$11$1, RepresentationType$M, equals$T);
+        ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$D, "UiApi", VERSION$$$1, RepresentationType$K, equals$R);
         return createLink$3(key);
     };
 
@@ -24734,9 +25203,9 @@
         return config;
     }
 
-    const layoutSelections$2 = select$1F();
-    const objectInfoPathSelection = select$1H();
-    const layoutUserStatePathSelector = select$1E();
+    const layoutSelections$2 = select$1D();
+    const objectInfoPathSelection = select$1F();
+    const layoutUserStatePathSelector = select$1C();
     function buildRecordUiSelector(recordDefs, layoutTypes, modes, recordOptionalFields) {
         const layoutTypeSelections = [];
         for (let i = 0, len = layoutTypes.length; i < len; i += 1) {
@@ -24784,7 +25253,7 @@
         return {
             kind: 'Fragment',
             private: ['eTag'],
-            version: VERSION$11$1,
+            version: VERSION$$$1,
             selections: [
                 {
                     kind: 'Link',
@@ -24986,7 +25455,7 @@
         }
         return recordDefs;
     }
-    function keyBuilder$1Q(recordIds, layoutTypes, modes, optionalFields) {
+    function keyBuilder$1O(recordIds, layoutTypes, modes, optionalFields) {
         const joinedRecordIds = recordIds.sort().join(',');
         const joinedOptionalFields = optionalFields.sort().join(',');
         const joinedLayoutTypes = layoutTypes.sort().join(',');
@@ -25020,7 +25489,7 @@
     }
     function prepareRequest$5(luvio, config) {
         const { recordIds, layoutTypes, modes, optionalFields } = config;
-        const key = keyBuilder$1Q(recordIds, layoutTypes, modes, optionalFields);
+        const key = keyBuilder$1O(recordIds, layoutTypes, modes, optionalFields);
         const selectorKey = buildCachedSelectorKey(key);
         const resourceRequest = createResourceRequest$$({
             urlParams: {
@@ -25062,7 +25531,7 @@
             node: selPath,
             variables: {},
         };
-        luvio.storeIngest(key, ingest$F$1, responseBody);
+        luvio.storeIngest(key, ingest$D$1, responseBody);
         const snapshot = luvio.storeLookup(sel, buildSnapshotRefresh$4(luvio, config));
         if (snapshot.state === 'Error') {
             return new StoreKeyMap();
@@ -25107,7 +25576,7 @@
             variables: {},
         };
         luvio.storePublish(selectorKey, sel);
-        luvio.storeIngest(key, ingest$F$1, responseBody);
+        luvio.storeIngest(key, ingest$D$1, responseBody);
         // During ingestion, only valid records are stored.
         const recordNodes = [];
         const validRecordIds = [];
@@ -25184,7 +25653,7 @@
     function buildCachedSelectorSnapshot(context, storeLookup) {
         const { config } = context;
         const { recordIds, layoutTypes, modes, optionalFields } = config;
-        const key = keyBuilder$1Q(recordIds, layoutTypes, modes, optionalFields);
+        const key = keyBuilder$1O(recordIds, layoutTypes, modes, optionalFields);
         const cachedSelectorKey = buildCachedSelectorKey(key);
         return storeLookup({
             recordId: cachedSelectorKey,
@@ -25264,7 +25733,7 @@
     })(LayoutMode$2 || (LayoutMode$2 = {}));
 
     const DEFAULT_MODE = LayoutMode$2.View;
-    const layoutSelections$1 = select$1F();
+    const layoutSelections$1 = select$1D();
     function buildSnapshotRefresh$3(luvio, config) {
         return {
             config,
@@ -25272,7 +25741,7 @@
         };
     }
     function buildObjectInfoSelectorKey(luvio, objectInfo) {
-        const key = keyBuilderFromType$x(luvio, objectInfo);
+        const key = keyBuilderFromType$v(luvio, objectInfo);
         return `${key}__implicit__fields__selector`;
     }
     function refresh$1(luvio, config) {
@@ -25494,7 +25963,7 @@
     };
     const buildLayoutModeCacheSnapshot = (apiName, recordTypeId, layoutType, mode) => (context, storeLookup) => {
         const { luvio } = context;
-        const key = keyBuilder$1S(luvio, {
+        const key = keyBuilder$1Q(luvio, {
             objectApiName: apiName,
             recordTypeId,
             layoutType,
@@ -25803,371 +26272,6 @@
         }, { contextId: contextId$4 });
     };
 
-    const VERSION$10$1 = "0b29241fd9ed04bb61fde26b3f558ac4";
-    const RepresentationType$L = 'ListInfoSummaryRepresentation';
-    function keyBuilder$1P(luvio, config) {
-        return keyPrefix$2 + '::' + RepresentationType$L + ':' + (config.id === null ? '' : config.id);
-    }
-    function keyBuilderFromType$u(luvio, object) {
-        const keyParams = {
-            id: object.id
-        };
-        return keyBuilder$1P(luvio, keyParams);
-    }
-    function normalize$E(input, existing, path, luvio, store, timestamp) {
-        return input;
-    }
-    const select$1D = function ListInfoSummaryRepresentationSelect() {
-        return {
-            kind: 'Fragment',
-            version: VERSION$10$1,
-            private: [],
-            selections: [
-                {
-                    name: 'apiName',
-                    kind: 'Scalar'
-                },
-                {
-                    name: 'id',
-                    kind: 'Scalar'
-                },
-                {
-                    name: 'label',
-                    kind: 'Scalar'
-                },
-                {
-                    name: 'url',
-                    kind: 'Scalar'
-                }
-            ]
-        };
-    };
-    function equals$S(existing, incoming) {
-        const existing_apiName = existing.apiName;
-        const incoming_apiName = incoming.apiName;
-        if (!(existing_apiName === incoming_apiName)) {
-            return false;
-        }
-        const existing_label = existing.label;
-        const incoming_label = incoming.label;
-        if (!(existing_label === incoming_label)) {
-            return false;
-        }
-        const existing_url = existing.url;
-        const incoming_url = incoming.url;
-        if (!(existing_url === incoming_url)) {
-            return false;
-        }
-        const existing_id = existing.id;
-        const incoming_id = incoming.id;
-        if (!(existing_id === incoming_id)) {
-            return false;
-        }
-        return true;
-    }
-    const ingest$E$1 = function ListInfoSummaryRepresentationIngest(input, path, luvio, store, timestamp) {
-        const key = keyBuilderFromType$u(luvio, input);
-        const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
-        ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$E, "UiApi", VERSION$10$1, RepresentationType$L, equals$S);
-        return createLink$3(key);
-    };
-    function getTypeCacheKeys$M$1(rootKeySet, luvio, input, fullPathFactory) {
-        // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-        const rootKey = keyBuilderFromType$u(luvio, input);
-        rootKeySet.set(rootKey, {
-            namespace: keyPrefix$2,
-            representationName: RepresentationType$L,
-            mergeable: false
-        });
-    }
-
-    const VERSION$$$1 = "d0cadb0927f908b5b64694e1cff0b2d7";
-    const RepresentationType$K = 'ListInfoSummaryCollectionRepresentation';
-    function keyBuilder$1O(luvio, config) {
-        return keyPrefix$2 + '::' + RepresentationType$K + ':' + config.objectApiName + ':' + (config.queryString === null ? '' : config.queryString) + ':' + config.recentListsOnly;
-    }
-    function keyBuilderFromType$t(luvio, object) {
-        const keyParams = {
-            objectApiName: object.objectApiName,
-            queryString: object.queryString,
-            recentListsOnly: object.recentListsOnly
-        };
-        return keyBuilder$1O(luvio, keyParams);
-    }
-    function normalize$D(input, existing, path, luvio, store, timestamp) {
-        const input_lists = input.lists;
-        const input_lists_id = path.fullPath + '__lists';
-        for (let i = 0; i < input_lists.length; i++) {
-            const input_lists_item = input_lists[i];
-            let input_lists_item_id = input_lists_id + '__' + i;
-            input_lists[i] = ingest$E$1(input_lists_item, {
-                fullPath: input_lists_item_id,
-                propertyName: i,
-                parent: {
-                    data: input,
-                    key: path.fullPath,
-                    existing: existing,
-                },
-                ttl: path.ttl
-            }, luvio, store, timestamp);
-        }
-        return input;
-    }
-    const select$1C = function ListInfoSummaryCollectionRepresentationSelect(paginationParams) {
-        return {
-            kind: 'Fragment',
-            reader: true,
-            synthetic: false,
-            version: VERSION$$$1,
-            read: (source, reader) => {
-                const sink = {};
-                if (paginationParams === undefined) {
-                    return sink;
-                }
-                const metadata = reader.resolveMetadata(source, PAGINATION_VERSION$1);
-                const currentPageMetadata = getPageMetadata$1(metadata, paginationParams);
-                const { startOffset, endOffset, metadataProperties } = currentPageMetadata;
-                if (metadata !== undefined && startOffset !== undefined && endOffset !== undefined) {
-                    const itemsProperty = 'lists';
-                    reader.enterPath(itemsProperty);
-                    const itemsSource = source[itemsProperty];
-                    const itemsSink = [];
-                    const allSink = [];
-                    for (let i = startOffset; i < endOffset; i++) {
-                        reader.enterPath(i);
-                        reader.readSingleLink(i, {
-                            name: 'lists',
-                            kind: 'Link',
-                            fragment: select$1D()
-                        }, itemsSource, allSink, i - startOffset);
-                        if (reader.getIsDataMissing() === false) {
-                            itemsSink[i - startOffset] = allSink[i - startOffset];
-                        }
-                        reader.exitPath();
-                    }
-                    reader.exitPath();
-                    reader.assignNonScalar(sink, itemsProperty, itemsSink);
-                }
-                reader.enterPath('currentPageToken');
-                reader.readScalar('currentPageToken', metadataProperties, sink);
-                reader.exitPath();
-                reader.enterPath('nextPageToken');
-                reader.readScalar('nextPageToken', metadataProperties, sink);
-                reader.exitPath();
-                reader.enterPath('previousPageToken');
-                reader.readScalar('previousPageToken', metadataProperties, sink);
-                reader.exitPath();
-                reader.enterPath('pageSize');
-                reader.readScalar('pageSize', metadataProperties, sink);
-                reader.exitPath();
-                reader.enterPath('count');
-                reader.readScalar('count', metadataProperties, sink);
-                reader.exitPath();
-                reader.enterPath('objectApiName');
-                reader.readScalar('objectApiName', source, sink);
-                reader.exitPath();
-                reader.enterPath('queryString');
-                reader.readScalar('queryString', source, sink);
-                reader.exitPath();
-                reader.enterPath('recentListsOnly');
-                reader.readScalar('recentListsOnly', source, sink);
-                reader.exitPath();
-                return sink;
-            },
-        };
-    };
-    function getPageMetadata$1(paginationMetadata, paginationParams) {
-        const metadataProperties = {};
-        const sink = {
-            metadataProperties
-        };
-        if (paginationMetadata === undefined) {
-            return sink;
-        }
-        const { token, pageSize } = paginationParams;
-        const pageTokenAndOffset = getPageTokenAndOffset$1(paginationMetadata, token);
-        if (pageTokenAndOffset === undefined) {
-            return sink;
-        }
-        const [pageToken, startOffset] = pageTokenAndOffset;
-        const endOffset = pageEndOffset$1(paginationMetadata, startOffset, pageSize);
-        sink.startOffset = startOffset;
-        sink.endOffset = endOffset;
-        metadataProperties.currentPageToken = pageToken;
-        const nextToken = getNextPageToken$1(paginationMetadata, endOffset);
-        if (nextToken !== undefined) {
-            metadataProperties.nextPageToken = nextToken;
-        }
-        const previousToken = getPreviousPageToken(paginationMetadata, startOffset, pageSize);
-        if (previousToken !== undefined) {
-            metadataProperties.previousPageToken = previousToken;
-        }
-        metadataProperties.pageSize = pageSize;
-        metadataProperties.count = endOffset - startOffset;
-        return sink;
-    }
-    function equals$R(existing, incoming) {
-        const existing_recentListsOnly = existing.recentListsOnly;
-        const incoming_recentListsOnly = incoming.recentListsOnly;
-        if (!(existing_recentListsOnly === incoming_recentListsOnly)) {
-            return false;
-        }
-        const existing_count = existing.count;
-        const incoming_count = incoming.count;
-        if (!(existing_count === incoming_count)) {
-            return false;
-        }
-        const existing_pageSize = existing.pageSize;
-        const incoming_pageSize = incoming.pageSize;
-        if (!(existing_pageSize === incoming_pageSize)) {
-            return false;
-        }
-        const existing_currentPageToken = existing.currentPageToken;
-        const incoming_currentPageToken = incoming.currentPageToken;
-        if (!(existing_currentPageToken === incoming_currentPageToken)) {
-            return false;
-        }
-        const existing_currentPageUrl = existing.currentPageUrl;
-        const incoming_currentPageUrl = incoming.currentPageUrl;
-        if (!(existing_currentPageUrl === incoming_currentPageUrl)) {
-            return false;
-        }
-        const existing_eTag = existing.eTag;
-        const incoming_eTag = incoming.eTag;
-        if (!(existing_eTag === incoming_eTag)) {
-            return false;
-        }
-        const existing_objectApiName = existing.objectApiName;
-        const incoming_objectApiName = incoming.objectApiName;
-        if (!(existing_objectApiName === incoming_objectApiName)) {
-            return false;
-        }
-        const existing_lists = existing.lists;
-        const incoming_lists = incoming.lists;
-        const equals_lists_items = equalsArray(existing_lists, incoming_lists, (existing_lists_item, incoming_lists_item) => {
-            if (!(existing_lists_item.__ref === incoming_lists_item.__ref)) {
-                return false;
-            }
-        });
-        if (equals_lists_items === false) {
-            return false;
-        }
-        const existing_nextPageToken = existing.nextPageToken;
-        const incoming_nextPageToken = incoming.nextPageToken;
-        if (!(existing_nextPageToken === incoming_nextPageToken)) {
-            return false;
-        }
-        const existing_nextPageUrl = existing.nextPageUrl;
-        const incoming_nextPageUrl = incoming.nextPageUrl;
-        if (!(existing_nextPageUrl === incoming_nextPageUrl)) {
-            return false;
-        }
-        const existing_previousPageToken = existing.previousPageToken;
-        const incoming_previousPageToken = incoming.previousPageToken;
-        if (!(existing_previousPageToken === incoming_previousPageToken)) {
-            return false;
-        }
-        const existing_previousPageUrl = existing.previousPageUrl;
-        const incoming_previousPageUrl = incoming.previousPageUrl;
-        if (!(existing_previousPageUrl === incoming_previousPageUrl)) {
-            return false;
-        }
-        const existing_queryString = existing.queryString;
-        const incoming_queryString = incoming.queryString;
-        if (!(existing_queryString === incoming_queryString)) {
-            return false;
-        }
-        return true;
-    }
-    const ingest$D$1 = function ListInfoSummaryCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
-        const key = keyBuilderFromType$t(luvio, input);
-        const existingRecord = store.readEntry(key);
-        const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
-        let incomingRecord = normalize$D(input, store.readEntry(key), {
-            fullPath: key,
-            parent: path.parent,
-            propertyName: path.propertyName,
-            ttl: ttlToUse
-        }, luvio, store, timestamp);
-        const paginationKey = key + '__pagination';
-        const existingPaginationMetadata = store.readEntry(paginationKey);
-        const { count: count, currentPageToken: token, nextPageToken: nextToken, pageSize: pageSize, previousPageToken: previousToken, lists: items } = input;
-        const startOffset = existingPaginationMetadata === undefined ? 0 : offsetFromToken$1(existingPaginationMetadata, token);
-        const incomingPaginationMetadata = {
-            [token]: startOffset,
-        };
-        const nextOffset = startOffset + items.length;
-        if (nextToken === null) {
-            incomingPaginationMetadata.__END__ = nextOffset;
-        }
-        else {
-            incomingPaginationMetadata[nextToken] = nextOffset;
-            if (existingPaginationMetadata !== undefined) {
-                const listEndOffset = existingPaginationMetadata.__END__;
-                if (listEndOffset !== undefined && nextOffset >= listEndOffset) {
-                    incomingPaginationMetadata.__END__ = undefined;
-                }
-            }
-        }
-        if (previousToken !== null) {
-            incomingPaginationMetadata[previousToken] = Math.max(startOffset - pageSize, 0);
-        }
-        const mergedPaginationMetadata = mergeMetadata$1(existingPaginationMetadata, incomingPaginationMetadata);
-        if (existingPaginationMetadata === undefined ||
-            equalsObject$1(existingPaginationMetadata, mergedPaginationMetadata, (existingProp, incomingProp) => {
-                return existingProp === incomingProp;
-            }) === false) {
-            luvio.storePublish(paginationKey, mergedPaginationMetadata);
-            luvio.publishStoreMetadata(paginationKey, paginationStoreMetadata$1);
-        }
-        assignMetadataLink$1(incomingRecord, paginationKey);
-        if (existingRecord !== undefined && existingRecord.lists !== undefined) {
-            incomingRecord.lists = [
-                ...existingRecord.lists.slice(0, startOffset),
-                ...incomingRecord.lists,
-                ...existingRecord.lists.slice(nextOffset),
-            ];
-        }
-        if (existingRecord === undefined || equals$R(existingRecord, incomingRecord) === false) {
-            luvio.storePublish(key, incomingRecord);
-        }
-        if (ttlToUse !== undefined) {
-            const storeMetadataParams = {
-                ttl: ttlToUse,
-                namespace: "UiApi",
-                version: VERSION$$$1,
-                representationName: RepresentationType$K,
-                ingestionTimestamp: timestamp,
-            };
-            luvio.publishStoreMetadata(key, storeMetadataParams);
-        }
-        return createLink$3(key);
-    };
-    function getTypeCacheKeys$L$1(rootKeySet, luvio, input, fullPathFactory) {
-        // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-        const rootKey = keyBuilderFromType$t(luvio, input);
-        rootKeySet.set(rootKey, {
-            namespace: keyPrefix$2,
-            representationName: RepresentationType$K,
-            mergeable: true
-        });
-        rootKeySet.set(rootKey + '__pagination', {
-            namespace: keyPrefix$2,
-            representationName: RepresentationType$K,
-            mergeable: true
-        });
-        const input_lists_length = input.lists.length;
-        for (let i = 0; i < input_lists_length; i++) {
-            getTypeCacheKeys$M$1(rootKeySet, luvio, input.lists[i]);
-        }
-    }
-    const notifyUpdateAvailableFactory$2 = (luvio) => {
-        return function notifyListInfoSummaryUpdateAvailable(configs) {
-            const keys = configs.map(c => keyBuilder$1O(luvio, c));
-            return luvio.notifyStoreUpdateAvailable(keys);
-        };
-    };
-
     const notifyUpdateAvailableFactory$1 = (luvio) => {
         return function notifyListInfoUpdateAvailable(configs) {
             const generated_notifyUpdateAvailable = notifyUpdateAvailableFactory$6(luvio);
@@ -28459,7 +28563,7 @@
         buildCachedSnapshotCachePolicy$D, buildNetworkSnapshotCachePolicy$E);
     };
 
-    function validate$1e(obj, path = 'ActionRelatedListSingleBatchInputRepresentation') {
+    function validate$1f(obj, path = 'ActionRelatedListSingleBatchInputRepresentation') {
         const v_error = (() => {
             if (typeof obj !== 'object' || ArrayIsArray$2(obj) || obj === null) {
                 return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -28870,7 +28974,7 @@
             const untrustedConfig_relatedListsActionParameters_array = [];
             for (let i = 0, arrayLength = untrustedConfig_relatedListsActionParameters.length; i < arrayLength; i++) {
                 const untrustedConfig_relatedListsActionParameters_item = untrustedConfig_relatedListsActionParameters[i];
-                const referenceActionRelatedListSingleBatchInputRepresentationValidationError = validate$1e(untrustedConfig_relatedListsActionParameters_item);
+                const referenceActionRelatedListSingleBatchInputRepresentationValidationError = validate$1f(untrustedConfig_relatedListsActionParameters_item);
                 if (referenceActionRelatedListSingleBatchInputRepresentationValidationError === null) {
                     untrustedConfig_relatedListsActionParameters_array.push(untrustedConfig_relatedListsActionParameters_item);
                 }
@@ -30375,7 +30479,7 @@
         return keyPrefix$2 + '::RecordLayoutRepresentation:(' + 'formFactor:' + params.queryParams.formFactor + ',' + 'layoutType:' + params.queryParams.layoutType + ',' + 'mode:' + params.queryParams.mode + ',' + 'recordTypeId:' + params.queryParams.recordTypeId + ',' + 'objectApiName:' + params.urlParams.objectApiName + ')';
     }
     function getResponseCacheKeys$I(storeKeyMap, luvio, resourceParams, response) {
-        getTypeCacheKeys$O$1(storeKeyMap, luvio, response);
+        getTypeCacheKeys$M$1(storeKeyMap, luvio, response);
     }
     function ingestError$q(luvio, params, error, snapshotRefresh) {
         const key = keyBuilder$1b(luvio, params);
@@ -30383,8 +30487,8 @@
         const storeMetadataParams = {
             ttl: TTL$v,
             namespace: keyPrefix$2,
-            version: VERSION$13$1,
-            representationName: RepresentationType$O
+            version: VERSION$11$1,
+            representationName: RepresentationType$M
         };
         luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
         return errorSnapshot;
@@ -30405,11 +30509,11 @@
 
     function onFetchResponseSuccess$t(luvio, config, resourceParams, response) {
         const { body } = response;
-        const key = keyBuilder$1S(luvio, config);
-        luvio.storeIngest(key, ingest$H$1, body);
+        const key = keyBuilder$1Q(luvio, config);
+        luvio.storeIngest(key, ingest$F$1, body);
         const snapshot = luvio.storeLookup({
             recordId: key,
-            node: select$1F(),
+            node: select$1D(),
             variables: {},
         }, {
             config,
@@ -30454,8 +30558,8 @@
     function buildCachedSnapshotCachePolicy$w(context, storeLookup) {
         const { luvio, config } = context;
         const selector = {
-            recordId: keyBuilder$1S(luvio, config),
-            node: select$1F(),
+            recordId: keyBuilder$1Q(luvio, config),
+            node: select$1D(),
             variables: {},
         };
         return storeLookup(selector, {
@@ -30524,7 +30628,7 @@
     };
 
     function getResponseCacheKeys$H(storeKeyMap, luvio, resourceParams, response) {
-        getTypeCacheKeys$N$1(storeKeyMap, luvio, response);
+        getTypeCacheKeys$L$1(storeKeyMap, luvio, response);
     }
     function createResourceRequest$K(config) {
         const headers = {};
@@ -30542,7 +30646,7 @@
 
     function buildCachedSnapshot$5(luvio, config) {
         const { objectApiName, recordTypeId, layoutType, mode } = config;
-        const key = keyBuilder$1R(luvio, {
+        const key = keyBuilder$1P(luvio, {
             apiName: objectApiName,
             recordTypeId,
             layoutType,
@@ -30550,7 +30654,7 @@
         });
         const selector = {
             recordId: key,
-            node: select$1E(),
+            node: select$1C(),
             variables: {},
         };
         return luvio.storeLookup(selector, {
@@ -30583,7 +30687,7 @@
         body.recordTypeId = recordTypeId;
         body.layoutType = layoutType;
         body.mode = mode;
-        luvio.storeIngest(key, ingest$G$1, body);
+        luvio.storeIngest(key, ingest$E$1, body);
         const snapshot = buildCachedSnapshot$5(luvio, config);
         return luvio.storeBroadcast().then(() => snapshot);
     }
@@ -30597,7 +30701,7 @@
     }
     function prepareRequest$4(luvio, config) {
         const { recordTypeId, layoutType, mode, objectApiName } = config;
-        const key = keyBuilder$1R(luvio, {
+        const key = keyBuilder$1P(luvio, {
             apiName: objectApiName,
             recordTypeId,
             layoutType,
@@ -30662,13 +30766,13 @@
         const { config, luvio } = context;
         const { objectApiName, recordTypeId, layoutType, mode } = config;
         const selector = {
-            recordId: keyBuilder$1R(luvio, {
+            recordId: keyBuilder$1P(luvio, {
                 apiName: objectApiName,
                 recordTypeId,
                 layoutType,
                 mode,
             }),
-            node: select$1E(),
+            node: select$1C(),
             variables: {},
         };
         return storeLookup(selector, {
@@ -31118,22 +31222,22 @@
     }
     function select$13$1(luvio, params) {
         const paginationParams = createPaginationParams$1(params);
-        return select$1C(paginationParams);
+        return select$1K(paginationParams);
     }
     function keyBuilder$17$1(luvio, params) {
-        return keyBuilder$1O(luvio, {
+        return keyBuilder$1_(luvio, {
             objectApiName: params.urlParams.objectApiName,
             queryString: params.queryParams.q || null,
             recentListsOnly: params.queryParams.recentListsOnly || false
         });
     }
     function getResponseCacheKeys$E(storeKeyMap, luvio, resourceParams, response) {
-        getTypeCacheKeys$L$1(storeKeyMap, luvio, response);
+        getTypeCacheKeys$Q$1(storeKeyMap, luvio, response);
     }
     function ingestSuccess$w(luvio, resourceParams, response, snapshotRefresh) {
         const { body } = response;
         const key = keyBuilder$17$1(luvio, resourceParams);
-        luvio.storeIngest(key, ingest$D$1, body);
+        luvio.storeIngest(key, ingest$J$1, body);
         const snapshot = luvio.storeLookup({
             recordId: key,
             node: select$13$1(luvio, resourceParams),
@@ -31261,7 +31365,7 @@
             recordId: key,
             node: {
                 kind: 'Fragment',
-                version: VERSION$$$1,
+                version: VERSION$15$1,
                 private: [],
                 selections: [
                     {
@@ -31327,7 +31431,7 @@
         buildCachedSnapshotCachePolicy$t, buildNetworkSnapshotCachePolicy$u);
     };
 
-    function validate$14(obj, path = 'ListFilterByInfoInputRepresentation') {
+    function validate$15(obj, path = 'ListFilterByInfoInputRepresentation') {
         const v_error = (() => {
             if (typeof obj !== 'object' || ArrayIsArray$2(obj) || obj === null) {
                 return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -31358,7 +31462,7 @@
         return v_error === undefined ? null : v_error;
     }
 
-    function validate$13(obj, path = 'ListScopeInputRepresentation') {
+    function validate$14(obj, path = 'ListScopeInputRepresentation') {
         const v_error = (() => {
             if (typeof obj !== 'object' || ArrayIsArray$2(obj) || obj === null) {
                 return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -31482,7 +31586,7 @@
             const untrustedConfig_filteredByInfo_array = [];
             for (let i = 0, arrayLength = untrustedConfig_filteredByInfo.length; i < arrayLength; i++) {
                 const untrustedConfig_filteredByInfo_item = untrustedConfig_filteredByInfo[i];
-                const referenceListFilterByInfoInputRepresentationValidationError = validate$14(untrustedConfig_filteredByInfo_item);
+                const referenceListFilterByInfoInputRepresentationValidationError = validate$15(untrustedConfig_filteredByInfo_item);
                 if (referenceListFilterByInfoInputRepresentationValidationError === null) {
                     untrustedConfig_filteredByInfo_array.push(untrustedConfig_filteredByInfo_item);
                 }
@@ -31490,7 +31594,7 @@
             config.filteredByInfo = untrustedConfig_filteredByInfo_array;
         }
         const untrustedConfig_scope = untrustedConfig.scope;
-        const referenceListScopeInputRepresentationValidationError = validate$13(untrustedConfig_scope);
+        const referenceListScopeInputRepresentationValidationError = validate$14(untrustedConfig_scope);
         if (referenceListScopeInputRepresentationValidationError === null) {
             config.scope = untrustedConfig_scope;
         }
@@ -31758,7 +31862,7 @@
             const untrustedConfig_filteredByInfo_array = [];
             for (let i = 0, arrayLength = untrustedConfig_filteredByInfo.length; i < arrayLength; i++) {
                 const untrustedConfig_filteredByInfo_item = untrustedConfig_filteredByInfo[i];
-                const referenceListFilterByInfoInputRepresentationValidationError = validate$14(untrustedConfig_filteredByInfo_item);
+                const referenceListFilterByInfoInputRepresentationValidationError = validate$15(untrustedConfig_filteredByInfo_item);
                 if (referenceListFilterByInfoInputRepresentationValidationError === null) {
                     untrustedConfig_filteredByInfo_array.push(untrustedConfig_filteredByInfo_item);
                 }
@@ -31766,7 +31870,7 @@
             config.filteredByInfo = untrustedConfig_filteredByInfo_array;
         }
         const untrustedConfig_scope = untrustedConfig.scope;
-        const referenceListScopeInputRepresentationValidationError = validate$13(untrustedConfig_scope);
+        const referenceListScopeInputRepresentationValidationError = validate$14(untrustedConfig_scope);
         if (referenceListScopeInputRepresentationValidationError === null) {
             config.scope = untrustedConfig_scope;
         }
@@ -32517,7 +32621,7 @@
         buildCachedSnapshotCachePolicy$q, buildNetworkSnapshotCachePolicy$r);
     };
 
-    function validate$Y(obj, path = 'ListOrderedByInfoInputRepresentation') {
+    function validate$Z(obj, path = 'ListOrderedByInfoInputRepresentation') {
         const v_error = (() => {
             if (typeof obj !== 'object' || ArrayIsArray$2(obj) || obj === null) {
                 return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -32620,7 +32724,7 @@
             const untrustedConfig_orderedBy_array = [];
             for (let i = 0, arrayLength = untrustedConfig_orderedBy.length; i < arrayLength; i++) {
                 const untrustedConfig_orderedBy_item = untrustedConfig_orderedBy[i];
-                const referenceListOrderedByInfoInputRepresentationValidationError = validate$Y(untrustedConfig_orderedBy_item);
+                const referenceListOrderedByInfoInputRepresentationValidationError = validate$Z(untrustedConfig_orderedBy_item);
                 if (referenceListOrderedByInfoInputRepresentationValidationError === null) {
                     untrustedConfig_orderedBy_array.push(untrustedConfig_orderedBy_item);
                 }
@@ -33053,8 +33157,8 @@
                     reader.enterPath(i);
                     reader.enterPath(envelopeBodyPath);
                     const childResource = childResources[i];
-                    const childKey = keyBuilder$1U(luvio, childResource);
-                    const childFragment = select$1G();
+                    const childKey = keyBuilder$1S(luvio, childResource);
+                    const childFragment = select$1E();
                     const isMissingDataBeforeChildRead = reader.getIsDataMissing();
                     const childSnapshot = reader.read({
                         recordId: childKey,
@@ -33153,10 +33257,10 @@
                 getResponseCacheKeys$Y(keys, luvio, childResourceParams, childBody);
             }
             else if (childStatusCode === 404) {
-                const childKey = keyBuilder$1U(luvio, childResourceParams);
+                const childKey = keyBuilder$1S(luvio, childResourceParams);
                 keys.set(childKey, {
                     namespace: keyPrefix$2,
-                    representationName: RepresentationType$P,
+                    representationName: RepresentationType$N,
                     mergeable: false
                 });
             }
@@ -33169,7 +33273,7 @@
         const now = Date.now();
         for (let index = 0, len = childResourceParamsArray.length; index < len; index += 1) {
             const childResourceParams = childResourceParamsArray[index];
-            const childKey = keyBuilder$1U(luvio, childResourceParams);
+            const childKey = keyBuilder$1S(luvio, childResourceParams);
             const result = childEnvelopes[index];
             const { statusCode: childStatusCode, result: childBody } = result;
             if (childStatusCode === 200) {
@@ -36682,7 +36786,7 @@
         buildCachedSnapshotCachePolicy$d, buildNetworkSnapshotCachePolicy$e);
     };
 
-    function validate$y(obj, path = 'ListUserPreferenceInputRepresentation') {
+    function validate$z(obj, path = 'ListUserPreferenceInputRepresentation') {
         const v_error = (() => {
             if (typeof obj !== 'object' || ArrayIsArray$2(obj) || obj === null) {
                 return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -36759,7 +36863,7 @@
             const untrustedConfig_orderedByInfo_array = [];
             for (let i = 0, arrayLength = untrustedConfig_orderedByInfo.length; i < arrayLength; i++) {
                 const untrustedConfig_orderedByInfo_item = untrustedConfig_orderedByInfo[i];
-                const referenceListOrderedByInfoInputRepresentationValidationError = validate$Y(untrustedConfig_orderedByInfo_item);
+                const referenceListOrderedByInfoInputRepresentationValidationError = validate$Z(untrustedConfig_orderedByInfo_item);
                 if (referenceListOrderedByInfoInputRepresentationValidationError === null) {
                     untrustedConfig_orderedByInfo_array.push(untrustedConfig_orderedByInfo_item);
                 }
@@ -36767,7 +36871,7 @@
             config.orderedByInfo = untrustedConfig_orderedByInfo_array;
         }
         const untrustedConfig_userPreferences = untrustedConfig.userPreferences;
-        const referenceListUserPreferenceInputRepresentationValidationError = validate$y(untrustedConfig_userPreferences);
+        const referenceListUserPreferenceInputRepresentationValidationError = validate$z(untrustedConfig_userPreferences);
         if (referenceListUserPreferenceInputRepresentationValidationError === null) {
             config.userPreferences = untrustedConfig_userPreferences;
         }
@@ -37422,7 +37526,7 @@
             const untrustedConfig_orderedBy_array = [];
             for (let i = 0, arrayLength = untrustedConfig_orderedBy.length; i < arrayLength; i++) {
                 const untrustedConfig_orderedBy_item = untrustedConfig_orderedBy[i];
-                const referenceListOrderedByInfoInputRepresentationValidationError = validate$Y(untrustedConfig_orderedBy_item);
+                const referenceListOrderedByInfoInputRepresentationValidationError = validate$Z(untrustedConfig_orderedBy_item);
                 if (referenceListOrderedByInfoInputRepresentationValidationError === null) {
                     untrustedConfig_orderedBy_array.push(untrustedConfig_orderedBy_item);
                 }
@@ -37470,7 +37574,7 @@
         };
     };
 
-    function validate$w(obj, path = 'RelatedListRecordsSingleBatchInputRepresentation') {
+    function validate$x(obj, path = 'RelatedListRecordsSingleBatchInputRepresentation') {
         const v_error = (() => {
             if (typeof obj !== 'object' || ArrayIsArray$2(obj) || obj === null) {
                 return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -38424,7 +38528,7 @@
             const untrustedConfig_relatedListParameters_array = [];
             for (let i = 0, arrayLength = untrustedConfig_relatedListParameters.length; i < arrayLength; i++) {
                 const untrustedConfig_relatedListParameters_item = untrustedConfig_relatedListParameters[i];
-                const referenceRelatedListRecordsSingleBatchInputRepresentationValidationError = validate$w(untrustedConfig_relatedListParameters_item);
+                const referenceRelatedListRecordsSingleBatchInputRepresentationValidationError = validate$x(untrustedConfig_relatedListParameters_item);
                 if (referenceRelatedListRecordsSingleBatchInputRepresentationValidationError === null) {
                     untrustedConfig_relatedListParameters_array.push(untrustedConfig_relatedListParameters_item);
                 }
@@ -39218,7 +39322,7 @@
         buildCachedSnapshotCachePolicy$6, buildNetworkSnapshotCachePolicy$7);
     };
 
-    function validate$l(obj, path = 'SearchDataCategoryInputRepresentation') {
+    function validate$m(obj, path = 'SearchDataCategoryInputRepresentation') {
         const v_error = (() => {
             if (typeof obj !== 'object' || ArrayIsArray$2(obj) || obj === null) {
                 return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -39249,7 +39353,7 @@
         return v_error === undefined ? null : v_error;
     }
 
-    function validate$k(obj, path = 'SearchFilterInputRepresentation') {
+    function validate$l(obj, path = 'SearchFilterInputRepresentation') {
         const v_error = (() => {
             if (typeof obj !== 'object' || ArrayIsArray$2(obj) || obj === null) {
                 return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -39318,7 +39422,7 @@
         return v_error === undefined ? null : v_error;
     }
 
-    function validate$j(obj, path = 'SearchObjectOptionsRepresentation') {
+    function validate$k(obj, path = 'SearchObjectOptionsRepresentation') {
         const v_error = (() => {
             if (typeof obj !== 'object' || ArrayIsArray$2(obj) || obj === null) {
                 return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -39331,7 +39435,7 @@
             for (let i = 0; i < obj_dataCategories.length; i++) {
                 const obj_dataCategories_item = obj_dataCategories[i];
                 const path_dataCategories_item = path_dataCategories + '[' + i + ']';
-                const referencepath_dataCategories_itemValidationError = validate$l(obj_dataCategories_item, path_dataCategories_item);
+                const referencepath_dataCategories_itemValidationError = validate$m(obj_dataCategories_item, path_dataCategories_item);
                 if (referencepath_dataCategories_itemValidationError !== null) {
                     let message = 'Object doesn\'t match SearchDataCategoryInputRepresentation (at "' + path_dataCategories_item + '")\n';
                     message += referencepath_dataCategories_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -39346,7 +39450,7 @@
             for (let i = 0; i < obj_filters.length; i++) {
                 const obj_filters_item = obj_filters[i];
                 const path_filters_item = path_filters + '[' + i + ']';
-                const referencepath_filters_itemValidationError = validate$k(obj_filters_item, path_filters_item);
+                const referencepath_filters_itemValidationError = validate$l(obj_filters_item, path_filters_item);
                 if (referencepath_filters_itemValidationError !== null) {
                     let message = 'Object doesn\'t match SearchFilterInputRepresentation (at "' + path_filters_item + '")\n';
                     message += referencepath_filters_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -39477,7 +39581,7 @@
             for (let i = 0, arrayLength = untrustedConfig_searchObjectOptions_keys.length; i < arrayLength; i++) {
                 const key = untrustedConfig_searchObjectOptions_keys[i];
                 const untrustedConfig_searchObjectOptions_prop = untrustedConfig_searchObjectOptions[key];
-                const referenceSearchObjectOptionsRepresentationValidationError = validate$j(untrustedConfig_searchObjectOptions_prop);
+                const referenceSearchObjectOptionsRepresentationValidationError = validate$k(untrustedConfig_searchObjectOptions_prop);
                 if (referenceSearchObjectOptionsRepresentationValidationError === null) {
                     if (untrustedConfig_searchObjectOptions_object !== undefined) {
                         untrustedConfig_searchObjectOptions_object[key] = untrustedConfig_searchObjectOptions_prop;
@@ -39680,7 +39784,7 @@
             const untrustedConfig_filters_array = [];
             for (let i = 0, arrayLength = untrustedConfig_filters.length; i < arrayLength; i++) {
                 const untrustedConfig_filters_item = untrustedConfig_filters[i];
-                const referenceSearchFilterInputRepresentationValidationError = validate$k(untrustedConfig_filters_item);
+                const referenceSearchFilterInputRepresentationValidationError = validate$l(untrustedConfig_filters_item);
                 if (referenceSearchFilterInputRepresentationValidationError === null) {
                     untrustedConfig_filters_array.push(untrustedConfig_filters_item);
                 }
@@ -40268,7 +40372,7 @@
             const { body } = response;
             return luvio.handleSuccessResponse(() => ingestAndBroadcast(luvio, key, config, body), () => {
                 const cache = new StoreKeyMap();
-                getTypeCacheKeys$N$1(cache, luvio, body);
+                getTypeCacheKeys$L$1(cache, luvio, body);
                 return cache;
             });
         }, (err) => {
@@ -40278,7 +40382,7 @@
     }
     function ingestAndBroadcast(luvio, key, config, body) {
         addAdditionalFieldsForNorming(body, config.objectApiName, config.recordTypeId, config.layoutType, config.mode);
-        luvio.storeIngest(key, ingest$G$1, body);
+        luvio.storeIngest(key, ingest$E$1, body);
         return luvio.storeBroadcast().then(() => {
             return buildCachedSnapshot$5(luvio, config);
         });
@@ -40349,7 +40453,7 @@
                     recordTypeId,
                 },
             });
-            const key = keyBuilder$1R(luvio, {
+            const key = keyBuilder$1P(luvio, {
                 apiName: objectApiName,
                 recordTypeId,
                 layoutType,
@@ -40412,7 +40516,7 @@
     const createResourceParams$8 = /*#__PURE__*/ createResourceParams$12(getListRecordsByName_ConfigPropertyMetadata);
     function keyBuilder$9$1(luvio, config) {
         const resourceParams = createResourceParams$8(config);
-        return keyBuilder$1$(luvio, resourceParams);
+        return keyBuilder$1Z(luvio, resourceParams);
     }
     function typeCheckConfig$b(untrustedConfig) {
         const config = {};
@@ -40431,7 +40535,7 @@
     }
     function adapterFragment$1$1(luvio, config) {
         const resourceParams = createResourceParams$8(config);
-        return select$1L(luvio, resourceParams);
+        return select$1J(luvio, resourceParams);
     }
     function onFetchResponseSuccess$2$1(luvio, config, resourceParams, response) {
         const snapshot = ingestSuccess$P(luvio, resourceParams, response, {
@@ -40494,7 +40598,7 @@
         return items.length;
     }
     function getPaginationMetadata(luvio, resourceParams) {
-        const key = keyBuilder$1$(luvio, resourceParams);
+        const key = keyBuilder$1Z(luvio, resourceParams);
         const selector = {
             recordId: key,
             node: {
@@ -41148,7 +41252,7 @@
         const input_layout = input.layout;
         const input_layout_id = path.fullPath + '__layout';
         if (input_layout !== null && typeof input_layout === 'object') {
-            input.layout = ingest$H$1(input_layout, {
+            input.layout = ingest$F$1(input_layout, {
                 fullPath: input_layout_id,
                 propertyName: 'layout',
                 parent: {
@@ -41167,7 +41271,7 @@
             const key = input_objectInfos_keys[i];
             const input_objectInfos_prop = input_objectInfos[key];
             const input_objectInfos_prop_id = input_objectInfos_id + '__' + key;
-            input_objectInfos[key] = ingest$I$1(input_objectInfos_prop, {
+            input_objectInfos[key] = ingest$G$1(input_objectInfos_prop, {
                 fullPath: input_objectInfos_prop_id,
                 propertyName: key,
                 parent: {
@@ -41235,14 +41339,14 @@
             mergeable: false
         });
         if (input.layout !== null && typeof input.layout === 'object') {
-            getTypeCacheKeys$O$1(rootKeySet, luvio, input.layout);
+            getTypeCacheKeys$M$1(rootKeySet, luvio, input.layout);
         }
         const input_objectInfos = input.objectInfos;
         const input_objectInfos_keys = ObjectKeys$2(input_objectInfos);
         const input_objectInfos_length = input_objectInfos_keys.length;
         for (let i = 0; i < input_objectInfos_length; i++) {
             const key = input_objectInfos_keys[i];
-            getTypeCacheKeys$P$1(rootKeySet, luvio, input_objectInfos[key]);
+            getTypeCacheKeys$N$1(rootKeySet, luvio, input_objectInfos[key]);
         }
         getTypeCacheKeys$6$1(rootKeySet, luvio, input.record, () => rootKey + "__" + "record");
     }
@@ -41294,8 +41398,8 @@
     }
 
     const contextId$2 = `${keyPrefix$2}__${adapterName$4$1}`;
-    const layoutSelections = select$1F();
-    const objectInfoSelections = select$1H();
+    const layoutSelections = select$1D();
+    const objectInfoSelections = select$1F();
     function buildSelector(resp) {
         const recordSelections = buildSelectionFromRecord(resp.record);
         return [
@@ -41641,7 +41745,7 @@
             name: 'objectInfos',
             kind: 'Link',
             map: true,
-            fragment: select$1H()
+            fragment: select$1F()
         } : params.objectInfos;
         const recordPathSelection = params.record === undefined ? {
             name: 'record',
@@ -41689,7 +41793,7 @@
         const input_objectInfos_length = input_objectInfos_keys.length;
         for (let i = 0; i < input_objectInfos_length; i++) {
             const key = input_objectInfos_keys[i];
-            getTypeCacheKeys$P$1(rootKeySet, luvio, input_objectInfos[key]);
+            getTypeCacheKeys$N$1(rootKeySet, luvio, input_objectInfos[key]);
         }
         getTypeCacheKeys$4$1(rootKeySet, luvio, input.record);
     }
@@ -41723,7 +41827,7 @@
     function createFieldsIngest$2(params) {
         const { fields, optionalFields, trackedFields, recordConflictMap } = params;
         const ingest = dynamicIngest$2({
-            objectInfos: ingest$I$1,
+            objectInfos: ingest$G$1,
             record: createFieldsIngest$3(params)
         });
         return (data, path, luvio, store, timestamp) => {
@@ -42167,7 +42271,7 @@
             name: 'objectInfos',
             kind: 'Link',
             map: true,
-            fragment: select$1H()
+            fragment: select$1F()
         } : params.objectInfos;
         const recordPathSelection = params.record === undefined ? {
             name: 'record',
@@ -42215,7 +42319,7 @@
         const input_objectInfos_length = input_objectInfos_keys.length;
         for (let i = 0; i < input_objectInfos_length; i++) {
             const key = input_objectInfos_keys[i];
-            getTypeCacheKeys$P$1(rootKeySet, luvio, input_objectInfos[key]);
+            getTypeCacheKeys$N$1(rootKeySet, luvio, input_objectInfos[key]);
         }
         getTypeCacheKeys$2$1(rootKeySet, luvio, input.record);
     }
@@ -42249,7 +42353,7 @@
     function createFieldsIngest(params) {
         const { fields, optionalFields, trackedFields, recordConflictMap } = params;
         const ingest = dynamicIngest({
-            objectInfos: ingest$I$1,
+            objectInfos: ingest$G$1,
             record: createFieldsIngest$1(params)
         });
         return (data, path, luvio, store, timestamp) => {
@@ -43781,13 +43885,19 @@
             allowFunction: instrumentation$3.notifyRecordUpdateAvailableAllowed,
             dropFunction: instrumentation$3.notifyRecordUpdateAvailableDropped,
         });
-        throttle(60, 60000, createLDSAdapter(luvio, 'notifyListViewSummaryUpdateAvailable', notifyUpdateAvailableFactory$3));
-        throttle(60, 60000, createLDSAdapter(luvio, 'notifyListInfoSummaryUpdateAvailable', notifyUpdateAvailableFactory$2));
+        throttle(60, 60000, createLDSAdapter(luvio, 'notifyListViewSummaryUpdateAvailable', notifyUpdateAvailableFactory$2));
+        throttle(60, 60000, createLDSAdapter(luvio, 'notifyListInfoSummaryUpdateAvailable', notifyUpdateAvailableFactory$3));
         throttle(60, 60000, createLDSAdapter(luvio, 'notifyListInfoUpdateAvailable', notifyUpdateAvailableFactory$1));
         throttle(60, 60000, createLDSAdapter(luvio, 'notifyListRecordCollectionUpdateAvailable', notifyUpdateAvailableFactory$4));
         throttle(60, 60000, createLDSAdapter(luvio, 'notifyQuickActionDefaultsUpdateAvailable', notifyUpdateAvailableFactory));
+        // Setting up storeWatchers for custom notifyUpdateAvailable endpoints
+        setupListRecordCollectionStoreWatcher(luvio);
+        setupListSummaryCollectionStoreWatcher(luvio);
+        // Custom notifyUpdateAvailable endpoints for partial key support
+        throttle(60, 60000, setupNotifyAllListRecordUpdateAvailable(luvio));
+        throttle(60, 60000, setupNotifyAllListInfoSummaryUpdateAvailable(luvio));
     });
-    // version: 1.275.0-7ed4653a5
+    // version: 1.276.0-58fd72593
 
     var ldsIdempotencyWriteDisabled = {
         isOpen: function (e) {
@@ -44725,10 +44835,7 @@
             const entries = wasVisited === true || enableDurableMetadataRefresh === false
                 ? durableRecords
                 : refreshedDurableRecords;
-            const isMetadataRefresh = entries === refreshedDurableRecords;
-            setRecordTo(entries, key, 
-            // dont send record data with metadata refresh
-            isMetadataRefresh ? undefined : record, metadata);
+            setRecordTo(entries, key, record, metadata);
         }
         const durableStoreOperations = additionalDurableStoreOperations;
         const recordKeys = keys$7(durableRecords);
@@ -56269,13 +56376,21 @@
         draftFields[DEFAULT_FIELD_LAST_MODIFIED_DATE] = { value: timestampString, displayValue: null };
         draftFields[DEFAULT_FIELD_OWNER_ID] = { value: userId, displayValue: null };
         draftFields[DEFAULT_FIELD_ID] = { value: recordId, displayValue: null };
-        if (objectInfo !== undefined) {
-            const allObjectFields = keys$3$1(objectInfo.fields);
-            allObjectFields.forEach((fieldName) => {
-                if (draftFields[fieldName] === undefined) {
-                    draftFields[fieldName] = { value: null, displayValue: null };
-                }
-            });
+        const allObjectFields = keys$3$1(objectInfo.fields);
+        allObjectFields.forEach((fieldName) => {
+            if (draftFields[fieldName] === undefined) {
+                draftFields[fieldName] = { value: null, displayValue: null };
+            }
+        });
+        // TODO [W-14915806]: lightning-record-form injects the `IsPersonAccount`
+        // field for all `Account` and `PersonAccount` records. However, not all
+        // orgs use person accounts, and if that field is not present in the object
+        // info then it is not synthesized. We force it to be synthesized here to
+        // ensure lightning-record-form will work correctly with draft-created
+        // accounts.
+        if ((apiName === 'Account' || apiName === 'PersonAccount') &&
+            draftFields['IsPersonAccount'] === undefined) {
+            draftFields['IsPersonAccount'] = { value: null, displayValue: null };
         }
         return {
             id: recordId,
@@ -59482,7 +59597,7 @@
                 if (representationName === RepresentationType$U) {
                     incomingRecords.add(key);
                 }
-                else if (representationName === RepresentationType$P) {
+                else if (representationName === RepresentationType$N) {
                     incomingObjectInfos.add(key);
                 }
             }
@@ -60539,6 +60654,7 @@
     function buildFieldUnionArray(existingRecord, incomingRecord, objectInfo) {
         const allFields = Array.from(new Set([...Object.keys(existingRecord.fields), ...Object.keys(incomingRecord.fields)]));
         const fieldUnion = [];
+        let includesSpanningFields = false;
         allFields.forEach((fieldName) => {
             const objectInfoField = objectInfo.fields[fieldName];
             if (objectInfoField === undefined) {
@@ -60546,13 +60662,14 @@
                 const referenceField = findReferenceFieldForSpanningField(fieldName, objectInfo);
                 if (referenceField !== undefined) {
                     fieldUnion.push(`${fieldName}.Id`);
+                    includesSpanningFields = true;
                 }
             }
             else {
                 fieldUnion.push(fieldName);
             }
         });
-        return fieldUnion;
+        return { fields: fieldUnion, includesSpanningFields };
     }
     /**
      * Merges (if possible) an incoming record from a priming session with an existing record in the durable store.
@@ -60584,7 +60701,7 @@
                 ok: false,
                 code: 'conflict-drafts',
                 hasDraft: true,
-                fieldUnion: buildFieldUnionArray(existingRecord, incomingRecord, objectInfo),
+                fieldUnion: buildFieldUnionArray(existingRecord, incomingRecord, objectInfo).fields,
             };
         }
         // Check if incoming record's Etag is equal to the existing one
@@ -60646,10 +60763,19 @@
                 };
             }
             // If Etags do not match and the incoming record does not contain all fields, re-request the record
+            const { fields, includesSpanningFields } = buildFieldUnionArray(existingRecord, incomingRecord, objectInfo);
+            if (includesSpanningFields) {
+                return {
+                    ok: false,
+                    code: 'conflict-spanning-record',
+                    fieldUnion: fields,
+                    hasDraft: false,
+                };
+            }
             return {
                 ok: false,
                 code: 'conflict-missing-fields',
-                fieldUnion: buildFieldUnionArray(existingRecord, incomingRecord, objectInfo),
+                fieldUnion: fields,
                 hasDraft: false,
             };
         }
@@ -61697,7 +61823,7 @@
         id: '@salesforce/lds-network-adapter',
         instrument: instrument$2,
     });
-    // version: 1.275.0-c8b3e2f72
+    // version: 1.276.0-dcebc4076
 
     const { create: create$3, keys: keys$3 } = Object;
     const { stringify: stringify$1, parse: parse$1 } = JSON;
@@ -80091,7 +80217,7 @@
         configuration: { ...configurationForGraphQLAdapters$1 },
         instrument: instrument$1,
     });
-    // version: 1.275.0-7ed4653a5
+    // version: 1.276.0-58fd72593
 
     // On core the unstable adapters are re-exported with different names,
     // we want to match them here.
@@ -82345,7 +82471,7 @@
         unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
         graphQLImperative = ldsAdapter;
     });
-    // version: 1.275.0-7ed4653a5
+    // version: 1.276.0-58fd72593
 
     var gqlApi = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -83043,7 +83169,7 @@
     function register(r) {
         callbacks$1.forEach((callback) => callback(r));
     }
-    // version: 1.275.0-c8b3e2f72
+    // version: 1.276.0-dcebc4076
 
     /**
      * Returns true if the value acts like a Promise, i.e. has a "then" function,
@@ -87966,4 +88092,4 @@
     exports.subscribeToAdapter = subscribeToAdapter;
 
 }));
-// version: 1.275.0-c8b3e2f72
+// version: 1.276.0-dcebc4076