@salesforce/lds-worker-api 1.275.0 → 1.276.0

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

@@ -4028,7 +4028,7 @@ function createResourceParamsImpl(config, configMetadata) {
     }
     return resourceParams;
 }
-// engine version: 0.154.11-e144742b
+// engine version: 0.154.12-43ac02c6
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -4156,7 +4156,7 @@ function withDefaultLuvio(callback) {
     }
     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) {
@@ -15664,7 +15664,7 @@ function gql(literals, ...subs) {
     }
     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".
@@ -16589,7 +16589,7 @@ function createGraphQLWireAdapterConstructor(luvio, adapter, metadata, astResolv
     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.,
@@ -16688,7 +16688,7 @@ var TypeCheckShapes;
     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;
 
@@ -22253,6 +22253,461 @@ function createResourceRequest$15(config) {
     };
 }
 
+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}`;
 }
@@ -22481,12 +22936,26 @@ function listFields(luvio, { fields = [], optionalFields = [], sortBy, }, listIn
         },
     };
 }
+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,
@@ -22519,7 +22988,7 @@ function keyBuilder$1$(luvio, params) {
     });
 }
 
-function select$1L(luvio, params) {
+function select$1J(luvio, params) {
     const { fields = [], optionalFields = [] } = params.queryParams;
     return dynamicSelect$7({
         records: {
@@ -22536,7 +23005,7 @@ function select$1L(luvio, params) {
 }
 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) {
@@ -22545,7 +23014,7 @@ function ingestSuccess$P(luvio, resourceParams, response, snapshotRefresh) {
     }
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$1L(luvio, resourceParams),
+        node: select$1J(luvio, resourceParams),
         variables: {},
     }, snapshotRefresh);
     return snapshot;
@@ -22573,7 +23042,7 @@ function getResponseCacheKeys$_(storeKeyMap, luvio, resourceParams, response) {
     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,
@@ -22651,24 +23120,24 @@ function isErrorSnapshot(snapshot) {
     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: [
             {
@@ -22690,7 +23159,7 @@ const select$1K = function ListViewSummaryRepresentationSelect() {
         ]
     };
 };
-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)) {
@@ -22713,42 +23182,42 @@ function equals$Y(existing, incoming) {
     }
     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: {
@@ -22761,19 +23230,19 @@ function normalize$J(input, existing, path, luvio, store, timestamp) {
     }
     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';
@@ -22786,7 +23255,7 @@ const select$1J = function ListViewSummaryCollectionRepresentationSelect(paginat
                     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];
@@ -22824,7 +23293,7 @@ const select$1J = function ListViewSummaryCollectionRepresentationSelect(paginat
         },
     };
 };
-function getPageMetadata$2(paginationMetadata, paginationParams) {
+function getPageMetadata$1(paginationMetadata, paginationParams) {
     const metadataProperties = {};
     const sink = {
         metadataProperties
@@ -22854,7 +23323,7 @@ function getPageMetadata$2(paginationMetadata, paginationParams) {
     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)) {
@@ -22927,11 +23396,11 @@ function equals$X(existing, incoming) {
     }
     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,
@@ -22976,42 +23445,42 @@ const ingest$J$1 = function ListViewSummaryCollectionRepresentationIngest(input,
             ...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);
     };
 };
@@ -23023,34 +23492,34 @@ function createPaginationParams$3(params) {
         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;
@@ -23079,9 +23548,9 @@ const getListViewSummaryCollection_ConfigPropertyMetadata = [
 ];
 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 = {};
@@ -23101,7 +23570,7 @@ function validateAdapterConfig$15(untrustedConfig, configPropertyNames) {
 }
 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, {
@@ -23164,12 +23633,12 @@ function getCachedItemsNumber$3(cacheSnapshot) {
     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: [
                 {
@@ -23212,7 +23681,7 @@ function buildNetworkSnapshotCachePolicy$O(context, coercedAdapterRequestContext
 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: {},
     };
@@ -23242,7 +23711,7 @@ function createPaginationParams$2(params) {
         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,
@@ -23403,7 +23872,7 @@ function buildCachedSnapshot$8(luvio, storeLookup, config, listInfo, fields) {
     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: {},
     };
@@ -24064,24 +24533,24 @@ const factory$h = (luvio) => {
 };
 
 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'
         ],
@@ -24183,59 +24652,59 @@ const select$1H = function ObjectInfoRepresentationSelect() {
         ]
     };
 };
-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;
@@ -24260,9 +24729,9 @@ const getObjectInfo_ConfigPropertyMetadata = [
 ];
 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 = {};
@@ -24282,7 +24751,7 @@ function validateAdapterConfig$13(untrustedConfig, configPropertyNames) {
 }
 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, {
@@ -24318,7 +24787,7 @@ function buildNetworkSnapshotCachePolicy$N(context, coercedAdapterRequestContext
 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: {},
     };
@@ -24349,27 +24818,27 @@ var DiscriminatorValues$5$1;
 })(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'
         ],
@@ -24407,24 +24876,24 @@ const select$1F = function RecordLayoutRepresentationSelect() {
         ]
     };
 };
-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
     });
 }
@@ -24452,27 +24921,27 @@ function getRecordId18Array(value) {
 }
 
 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',
@@ -24492,32 +24961,32 @@ const select$1E = function RecordLayoutUserStateRepresentationSelect() {
         ]
     };
 };
-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);
@@ -24526,7 +24995,7 @@ function normalize$F(input, existing, path, luvio, store, timestamp) {
         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: {
@@ -24563,7 +25032,7 @@ function normalize$F(input, existing, path, luvio, store, timestamp) {
                     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: {
@@ -24585,7 +25054,7 @@ function normalize$F(input, existing, path, luvio, store, timestamp) {
         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: {
@@ -24617,7 +25086,7 @@ function normalize$F(input, existing, path, luvio, store, timestamp) {
     }
     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)) {
@@ -24680,10 +25149,10 @@ function equals$T(existing, incoming) {
     }
     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);
 };
 
@@ -24728,9 +25197,9 @@ function validateAdapterConfig$12(untrustedConfig, configPropertyNames) {
     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) {
@@ -24778,7 +25247,7 @@ function buildRecordUiSelector(recordDefs, layoutTypes, modes, recordOptionalFie
     return {
         kind: 'Fragment',
         private: ['eTag'],
-        version: VERSION$11$1,
+        version: VERSION$$$1,
         selections: [
             {
                 kind: 'Link',
@@ -24980,7 +25449,7 @@ function collectRecordDefs(resp, recordIds) {
     }
     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(',');
@@ -25014,7 +25483,7 @@ function markRecordUiOptionalFields(optionalFields, recordLookupFields, recordNo
 }
 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: {
@@ -25056,7 +25525,7 @@ function getCacheKeys(keySet, luvio, config, key, originalResponseBody) {
         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();
@@ -25101,7 +25570,7 @@ function onFetchResponseSuccess$I(luvio, config, selectorKey, key, responseBody)
         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 = [];
@@ -25178,7 +25647,7 @@ function publishDependencies(luvio, recordIds, depKeys) {
 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,
@@ -25258,7 +25727,7 @@ var LayoutMode$2;
 })(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,
@@ -25266,7 +25735,7 @@ function buildSnapshotRefresh$3(luvio, config) {
     };
 }
 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) {
@@ -25488,7 +25957,7 @@ const buildObjectInfoCacheSnapshot = (recordLayoutSnapshot) => (context, storeLo
 };
 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,
@@ -25797,371 +26266,6 @@ const factory$f = (luvio) => {
     }, { 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);
@@ -28453,7 +28557,7 @@ const getRecordEditActionsAdapterFactory = (luvio) => function UiApi__getRecordE
     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 + '")');
@@ -28864,7 +28968,7 @@ function typeCheckConfig$S(untrustedConfig) {
         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);
             }
@@ -30369,7 +30473,7 @@ function keyBuilder$1b(luvio, params) {
     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);
@@ -30377,8 +30481,8 @@ function ingestError$q(luvio, params, error, snapshotRefresh) {
     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;
@@ -30399,11 +30503,11 @@ function createResourceRequest$L(config) {
 
 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,
@@ -30448,8 +30552,8 @@ function validateAdapterConfig$O(untrustedConfig, _configPropertyNames) {
 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, {
@@ -30518,7 +30622,7 @@ const getLayoutAdapterFactory = (luvio) => function UiApi__getLayout(untrustedCo
 };
 
 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 = {};
@@ -30536,7 +30640,7 @@ function createResourceRequest$K(config) {
 
 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,
@@ -30544,7 +30648,7 @@ function buildCachedSnapshot$5(luvio, config) {
     });
     const selector = {
         recordId: key,
-        node: select$1E(),
+        node: select$1C(),
         variables: {},
     };
     return luvio.storeLookup(selector, {
@@ -30577,7 +30681,7 @@ function onFetchResponseSuccess$s(luvio, config, key, response) {
     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);
 }
@@ -30591,7 +30695,7 @@ function onFetchResponseError$s(luvio, config, key, error) {
 }
 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,
@@ -30656,13 +30760,13 @@ function buildCachedSnapshotCachePolicy$v(context, storeLookup) {
     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, {
@@ -31112,22 +31216,22 @@ function createPaginationParams$1(params) {
 }
 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),
@@ -31255,7 +31359,7 @@ function getPaginationMetadata$2(luvio, resourceParams) {
         recordId: key,
         node: {
             kind: 'Fragment',
-            version: VERSION$$$1,
+            version: VERSION$15$1,
             private: [],
             selections: [
                 {
@@ -31321,7 +31425,7 @@ const getListInfosByObjectNameAdapterFactory = (luvio) => function UiApi__getLis
     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 + '")');
@@ -31352,7 +31456,7 @@ function validate$14(obj, path = 'ListFilterByInfoInputRepresentation') {
     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 + '")');
@@ -31476,7 +31580,7 @@ function typeCheckConfig$I(untrustedConfig) {
         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);
             }
@@ -31484,7 +31588,7 @@ function typeCheckConfig$I(untrustedConfig) {
         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;
     }
@@ -31752,7 +31856,7 @@ function typeCheckConfig$F(untrustedConfig) {
         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);
             }
@@ -31760,7 +31864,7 @@ function typeCheckConfig$F(untrustedConfig) {
         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;
     }
@@ -32511,7 +32615,7 @@ const getListPreferencesAdapterFactory = (luvio) => function UiApi__getListPrefe
     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 + '")');
@@ -32614,7 +32718,7 @@ function typeCheckConfig$C(untrustedConfig) {
         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);
             }
@@ -33047,8 +33151,8 @@ function selectChildResourceParams$4(luvio, childResources, resourceParams) {
                 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,
@@ -33147,10 +33251,10 @@ function getResponseCacheKeys$v(keys, luvio, resourceParams, response) {
             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
             });
         }
@@ -33163,7 +33267,7 @@ function ingestSuccessChildResourceParams$5(luvio, childResourceParamsArray, chi
     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) {
@@ -36676,7 +36780,7 @@ const getRelatedListInfoAdapterFactory = (luvio) => function UiApi__getRelatedLi
     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 + '")');
@@ -36753,7 +36857,7 @@ function typeCheckConfig$o(untrustedConfig) {
         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);
             }
@@ -36761,7 +36865,7 @@ function typeCheckConfig$o(untrustedConfig) {
         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;
     }
@@ -37416,7 +37520,7 @@ function typeCheckConfig$l(untrustedConfig) {
         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);
             }
@@ -37464,7 +37568,7 @@ const updateRelatedListPreferencesAdapterFactory = (luvio) => {
     };
 };
 
-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 + '")');
@@ -38418,7 +38522,7 @@ function typeCheckConfig$k(untrustedConfig) {
         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);
             }
@@ -39212,7 +39316,7 @@ const getLookupMetadataAdapterFactory = (luvio) => function UiApi__getLookupMeta
     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 + '")');
@@ -39243,7 +39347,7 @@ function validate$l(obj, path = 'SearchDataCategoryInputRepresentation') {
     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 + '")');
@@ -39312,7 +39416,7 @@ function validate$k(obj, path = 'SearchFilterInputRepresentation') {
     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 + '")');
@@ -39325,7 +39429,7 @@ function validate$j(obj, path = 'SearchObjectOptionsRepresentation') {
         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');
@@ -39340,7 +39444,7 @@ function validate$j(obj, path = 'SearchObjectOptionsRepresentation') {
         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');
@@ -39471,7 +39575,7 @@ function typeCheckConfig$f(untrustedConfig) {
         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;
@@ -39674,7 +39778,7 @@ function typeCheckConfig$e(untrustedConfig) {
         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);
             }
@@ -40262,7 +40366,7 @@ function updateLayoutUserState$1(luvio, config, key, updateRequest) {
         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) => {
@@ -40272,7 +40376,7 @@ function updateLayoutUserState$1(luvio, config, key, updateRequest) {
 }
 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);
     });
@@ -40343,7 +40447,7 @@ const factory$b = (luvio) => {
                 recordTypeId,
             },
         });
-        const key = keyBuilder$1R(luvio, {
+        const key = keyBuilder$1P(luvio, {
             apiName: objectApiName,
             recordTypeId,
             layoutType,
@@ -40406,7 +40510,7 @@ const getListRecordsByName_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValid
 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 = {};
@@ -40425,7 +40529,7 @@ function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
 }
 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, {
@@ -40488,7 +40592,7 @@ function getCachedItemsNumber(cacheSnapshot) {
     return items.length;
 }
 function getPaginationMetadata(luvio, resourceParams) {
-    const key = keyBuilder$1$(luvio, resourceParams);
+    const key = keyBuilder$1Z(luvio, resourceParams);
     const selector = {
         recordId: key,
         node: {
@@ -41142,7 +41246,7 @@ function normalize$1(input, existing, path, luvio, store, timestamp) {
     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: {
@@ -41161,7 +41265,7 @@ function normalize$1(input, existing, path, luvio, store, timestamp) {
         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: {
@@ -41229,14 +41333,14 @@ function getTypeCacheKeys$5$1(rootKeySet, luvio, input, fullPathFactory) {
         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");
 }
@@ -41288,8 +41392,8 @@ function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
 }
 
 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 [
@@ -41635,7 +41739,7 @@ const dynamicSelect$2 = function dynamicRecordDefaultsTemplateCloneRepresentatio
         name: 'objectInfos',
         kind: 'Link',
         map: true,
-        fragment: select$1H()
+        fragment: select$1F()
     } : params.objectInfos;
     const recordPathSelection = params.record === undefined ? {
         name: 'record',
@@ -41683,7 +41787,7 @@ function getTypeCacheKeys$3$1(rootKeySet, luvio, input, fullPathFactory) {
     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);
 }
@@ -41717,7 +41821,7 @@ function selectFields$5(fields) {
 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) => {
@@ -42161,7 +42265,7 @@ const dynamicSelect = function dynamicRecordDefaultsTemplateCreateRepresentation
         name: 'objectInfos',
         kind: 'Link',
         map: true,
-        fragment: select$1H()
+        fragment: select$1F()
     } : params.objectInfos;
     const recordPathSelection = params.record === undefined ? {
         name: 'record',
@@ -42209,7 +42313,7 @@ function getTypeCacheKeys$1$1(rootKeySet, luvio, input, fullPathFactory) {
     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);
 }
@@ -42243,7 +42347,7 @@ function selectFields$2(fields) {
 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) => {
@@ -43775,13 +43879,19 @@ withDefaultLuvio((luvio) => {
         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) {
@@ -44719,10 +44829,7 @@ function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStor
         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);
@@ -56263,13 +56370,21 @@ function buildSyntheticRecordRepresentation(luvio, createOperation, userId, obje
     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,
@@ -59476,7 +59591,7 @@ function enableObjectInfoCaching(env, ensureObjectInfoCached) {
             if (representationName === RepresentationType$U) {
                 incomingRecords.add(key);
             }
-            else if (representationName === RepresentationType$P) {
+            else if (representationName === RepresentationType$N) {
                 incomingObjectInfos.add(key);
             }
         }
@@ -60533,6 +60648,7 @@ function findReferenceFieldForSpanningField(fieldName, objectInfo) {
 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) {
@@ -60540,13 +60656,14 @@ function buildFieldUnionArray(existingRecord, incomingRecord, objectInfo) {
             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.
@@ -60578,7 +60695,7 @@ function mergeRecord(existingRecord, incomingRecord, objectInfo) {
             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
@@ -60640,10 +60757,19 @@ function mergeRecord(existingRecord, incomingRecord, objectInfo) {
             };
         }
         // 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,
         };
     }
@@ -61691,7 +61817,7 @@ register$1({
     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;
@@ -80085,7 +80211,7 @@ register$1({
     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.
@@ -82339,7 +82465,7 @@ withDefaultLuvio((luvio) => {
     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,
@@ -83037,7 +83163,7 @@ const callbacks$1 = [];
 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,
@@ -87942,4 +88068,4 @@ const { luvio } = getRuntime();
 setDefaultLuvio({ luvio });
 
 export { createPrimingSession, draftManager, draftQueue, evictCacheRecordsByIds, evictExpiredCacheEntries, executeAdapter, executeMutatingAdapter, getImperativeAdapterNames, invokeAdapter, invokeAdapterWithDraftToReplace, invokeAdapterWithMetadata, nimbusDraftQueue, registerReportObserver, setMetadataTTL, setUiApiRecordTTL, stopEviction, subscribeToAdapter };
-// version: 1.275.0-c8b3e2f72
+// version: 1.276.0-dcebc4076