@salesforce/lds-worker-api 1.227.2 → 1.228.1

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

@@ -3847,7 +3847,7 @@
         }
         return resourceParams;
     }
-    // engine version: 0.145.0-a2297ae0
+    // engine version: 0.145.2-6a13677c
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -3974,7 +3974,7 @@
         }
         callbacks.push(callback);
     }
-    // version: 1.227.2-daae2b505
+    // version: 1.228.1-4e6356f71
 
     // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
     function instrumentAdapter$1(createFunction, _metadata) {
@@ -15435,7 +15435,7 @@
         }
         return superResult;
     }
-    // version: 1.227.2-daae2b505
+    // version: 1.228.1-4e6356f71
 
     function unwrap(data) {
         // The lwc-luvio bindings import a function from lwc called "unwrap".
@@ -16358,7 +16358,7 @@
         const { apiFamily, name } = metadata;
         return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
     }
-    // version: 1.227.2-daae2b505
+    // version: 1.228.1-4e6356f71
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -16457,7 +16457,7 @@
         TypeCheckShapes[TypeCheckShapes["Integer"] = 3] = "Integer";
         TypeCheckShapes[TypeCheckShapes["Unsupported"] = 4] = "Unsupported";
     })(TypeCheckShapes || (TypeCheckShapes = {}));
-    // engine version: 0.145.0-a2297ae0
+    // engine version: 0.145.2-6a13677c
 
     const { keys: ObjectKeys$3, create: ObjectCreate$3 } = Object;
 
@@ -17548,7 +17548,7 @@
             mergeable: false
         });
     }
-    const notifyUpdateAvailableFactory$3 = (luvio) => {
+    const notifyUpdateAvailableFactory$4 = (luvio) => {
         return function notifyListInfoUpdateAvailable(configs) {
             const keys = configs.map(c => keyBuilder$1V(luvio, c));
             return luvio.notifyStoreUpdateAvailable(keys);
@@ -18161,7 +18161,7 @@
             getTypeCacheKeys$R$1(rootKeySet, luvio, input_fields[key], () => rootKey + "__fields" + "__" + key);
         }
     }
-    const notifyUpdateAvailableFactory$2 = (luvio) => {
+    const notifyUpdateAvailableFactory$3 = (luvio) => {
         return function notifyRecordUpdateAvailable(configs) {
             const keys = configs.map(c => keyBuilder$1U(luvio, c));
             return luvio.notifyStoreUpdateAvailable(keys);
@@ -22579,7 +22579,7 @@
             getTypeCacheKeys$L$1(rootKeySet, luvio, input.lists[i]);
         }
     }
-    const notifyUpdateAvailableFactory$1 = (luvio) => {
+    const notifyUpdateAvailableFactory$2 = (luvio) => {
         return function notifyListViewSummaryUpdateAvailable(configs) {
             const keys = configs.map(c => keyBuilder$1N(luvio, c));
             return luvio.notifyStoreUpdateAvailable(keys);
@@ -25320,9 +25320,9 @@
         }, { contextId: contextId$4 });
     };
 
-    const notifyUpdateAvailableFactory = (luvio) => {
+    const notifyUpdateAvailableFactory$1 = (luvio) => {
         return function notifyListInfoUpdateAvailable(configs) {
-            const generated_notifyUpdateAvailable = notifyUpdateAvailableFactory$3(luvio);
+            const generated_notifyUpdateAvailable = notifyUpdateAvailableFactory$4(luvio);
             // Taken from getUiApiListInfoByListViewApiNameAndObjectApiName/keyBuilder artifact
             // We automatically set the type based on the listViewApiName, and we need to do the same
             // here for key matching and validation
@@ -25438,6 +25438,119 @@
         });
     }
 
+    const TTL$q = 900000;
+    const VERSION$Y$1 = "993b0a7bce6056c4f57ed300ec153d9c";
+    const RepresentationType$E = 'QuickActionDefaultsRepresentation';
+    function keyBuilder$1C(luvio, config) {
+        return keyPrefix$1 + '::' + RepresentationType$E + ':' + config.actionApiName;
+    }
+    function keyBuilderFromType$p(luvio, object) {
+        const keyParams = {
+            actionApiName: object.actionApiName
+        };
+        return keyBuilder$1C(luvio, keyParams);
+    }
+    function dynamicNormalize$4(ingestParams) {
+        return function normalize_dynamic(input, existing, path, luvio, store, timestamp) {
+            const input_fields = input.fields;
+            const input_fields_id = path.fullPath + '__fields';
+            const input_fields_keys = Object.keys(input_fields);
+            const input_fields_length = input_fields_keys.length;
+            for (let i = 0; i < input_fields_length; i++) {
+                const key = input_fields_keys[i];
+                const input_fields_prop = input_fields[key];
+                const input_fields_prop_id = input_fields_id + '__' + key;
+                input_fields[key] = ingestParams.fields(input_fields_prop, {
+                    fullPath: input_fields_prop_id,
+                    propertyName: key,
+                    parent: {
+                        data: input,
+                        key: path.fullPath,
+                        existing: existing,
+                    },
+                    ttl: path.ttl
+                }, luvio, store, timestamp);
+            }
+            return input;
+        };
+    }
+    const dynamicSelect$5 = function dynamicQuickActionDefaultsRepresentationSelect(params) {
+        const fieldsPathSelection = params.fields === undefined ? {
+            name: 'fields',
+            kind: 'Link',
+            map: true,
+            fragment: select$1F()
+        } : params.fields;
+        return {
+            kind: 'Fragment',
+            version: VERSION$Y$1,
+            private: [
+                'eTag'
+            ],
+            selections: [
+                {
+                    name: 'actionApiName',
+                    kind: 'Scalar'
+                },
+                fieldsPathSelection,
+                {
+                    name: 'objectApiName',
+                    kind: 'Scalar'
+                }
+            ]
+        };
+    };
+    function equals$L(existing, incoming) {
+        const existing_actionApiName = existing.actionApiName;
+        const incoming_actionApiName = incoming.actionApiName;
+        if (!(existing_actionApiName === incoming_actionApiName)) {
+            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_fields = existing.fields;
+        const incoming_fields = incoming.fields;
+        const equals_fields_props = equalsObject$1(existing_fields, incoming_fields, (existing_fields_prop, incoming_fields_prop) => {
+            if (!(existing_fields_prop.__ref === incoming_fields_prop.__ref)) {
+                return false;
+            }
+        });
+        if (equals_fields_props === false) {
+            return false;
+        }
+        return true;
+    }
+    function getTypeCacheKeys$F$1(rootKeySet, luvio, input, fullPathFactory) {
+        // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+        const rootKey = keyBuilderFromType$p(luvio, input);
+        rootKeySet.set(rootKey, {
+            namespace: keyPrefix$1,
+            representationName: RepresentationType$E,
+            mergeable: false
+        });
+        const input_fields = input.fields;
+        const input_fields_keys = ObjectKeys$2(input_fields);
+        const input_fields_length = input_fields_keys.length;
+        for (let i = 0; i < input_fields_length; i++) {
+            const key = input_fields_keys[i];
+            getTypeCacheKeys$R$1(rootKeySet, luvio, input_fields[key], () => rootKey + "__fields" + "__" + key);
+        }
+    }
+    const notifyUpdateAvailableFactory = (luvio) => {
+        return function notifyQuickActionDefaultsUpdateAvailable(configs) {
+            const keys = configs.map(c => keyBuilder$1C(luvio, c));
+            return luvio.notifyStoreUpdateAvailable(keys);
+        };
+    };
+
     function toSortedStringArrayAllowEmpty(value) {
         const valueArray = isArray$7(value) ? value : [value];
         if (valueArray.length === 0) {
@@ -25460,18 +25573,18 @@
         return undefined;
     }
 
-    const VERSION$Y$1 = "3f49d751896cf66e6e29788d8880e2cc";
-    const RepresentationType$E = 'PlatformActionRepresentation';
-    function keyBuilder$1C(luvio, config) {
-        return keyPrefix$1 + '::' + RepresentationType$E + ':' + config.externalId + ':' + (config.relatedSourceObject === null ? '' : config.relatedSourceObject) + ':' + (config.relatedListRecordId === null ? '' : config.relatedListRecordId);
+    const VERSION$X$1 = "3f49d751896cf66e6e29788d8880e2cc";
+    const RepresentationType$D = 'PlatformActionRepresentation';
+    function keyBuilder$1B(luvio, config) {
+        return keyPrefix$1 + '::' + RepresentationType$D + ':' + config.externalId + ':' + (config.relatedSourceObject === null ? '' : config.relatedSourceObject) + ':' + (config.relatedListRecordId === null ? '' : config.relatedListRecordId);
     }
-    function keyBuilderFromType$p(luvio, object) {
+    function keyBuilderFromType$o(luvio, object) {
         const keyParams = {
             externalId: object.externalId,
             relatedSourceObject: object.relatedSourceObject,
             relatedListRecordId: object.relatedListRecordId
         };
-        return keyBuilder$1C(luvio, keyParams);
+        return keyBuilder$1B(luvio, keyParams);
     }
     function normalize$x(input, existing, path, luvio, store, timestamp) {
         return input;
@@ -25479,7 +25592,7 @@
     const select$1s = function PlatformActionRepresentationSelect() {
         return {
             kind: 'Fragment',
-            version: VERSION$Y$1,
+            version: VERSION$X$1,
             private: [
                 'id'
             ],
@@ -25559,7 +25672,7 @@
             ]
         };
     };
-    function equals$L(existing, incoming) {
+    function equals$K(existing, incoming) {
         const existing_actionListContext = existing.actionListContext;
         const incoming_actionListContext = incoming.actionListContext;
         if (!(existing_actionListContext === incoming_actionListContext)) {
@@ -25658,31 +25771,31 @@
         return true;
     }
     const ingest$x$1 = function PlatformActionRepresentationIngest(input, path, luvio, store, timestamp) {
-        const key = keyBuilderFromType$p(luvio, input);
+        const key = keyBuilderFromType$o(luvio, input);
         const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
-        ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$x, "UiApi", VERSION$Y$1, RepresentationType$E, equals$L);
+        ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$x, "UiApi", VERSION$X$1, RepresentationType$D, equals$K);
         return createLink$3(key);
     };
-    function getTypeCacheKeys$F$1(rootKeySet, luvio, input, fullPathFactory) {
+    function getTypeCacheKeys$E$1(rootKeySet, luvio, input, fullPathFactory) {
         // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-        const rootKey = keyBuilderFromType$p(luvio, input);
+        const rootKey = keyBuilderFromType$o(luvio, input);
         rootKeySet.set(rootKey, {
             namespace: keyPrefix$1,
-            representationName: RepresentationType$E,
+            representationName: RepresentationType$D,
             mergeable: false
         });
     }
 
-    const VERSION$X$1 = "378d506f563a4bd724b322d440df33d1";
-    const RepresentationType$D = 'EntityActionRepresentation';
-    function keyBuilder$1B(luvio, config) {
-        return keyPrefix$1 + '::' + RepresentationType$D + ':' + config.url;
+    const VERSION$W$1 = "378d506f563a4bd724b322d440df33d1";
+    const RepresentationType$C = 'EntityActionRepresentation';
+    function keyBuilder$1A(luvio, config) {
+        return keyPrefix$1 + '::' + RepresentationType$C + ':' + config.url;
     }
-    function keyBuilderFromType$o(luvio, object) {
+    function keyBuilderFromType$n(luvio, object) {
         const keyParams = {
             url: object.url
         };
-        return keyBuilder$1B(luvio, keyParams);
+        return keyBuilder$1A(luvio, keyParams);
     }
     function normalize$w(input, existing, path, luvio, store, timestamp) {
         const input_actions = input.actions;
@@ -25706,7 +25819,7 @@
     const select$1r = function EntityActionRepresentationSelect() {
         return {
             kind: 'Fragment',
-            version: VERSION$X$1,
+            version: VERSION$W$1,
             private: [
                 'links',
                 'url'
@@ -25721,7 +25834,7 @@
             ]
         };
     };
-    function equals$K(existing, incoming) {
+    function equals$J(existing, incoming) {
         const existing_url = existing.url;
         const incoming_url = incoming.url;
         if (!(existing_url === incoming_url)) {
@@ -25750,28 +25863,28 @@
         return true;
     }
     const ingest$w$1 = function EntityActionRepresentationIngest(input, path, luvio, store, timestamp) {
-        const key = keyBuilderFromType$o(luvio, input);
+        const key = keyBuilderFromType$n(luvio, input);
         const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
-        ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$w, "UiApi", VERSION$X$1, RepresentationType$D, equals$K);
+        ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$w, "UiApi", VERSION$W$1, RepresentationType$C, equals$J);
         return createLink$3(key);
     };
-    function getTypeCacheKeys$E$1(rootKeySet, luvio, input, fullPathFactory) {
+    function getTypeCacheKeys$D$1(rootKeySet, luvio, input, fullPathFactory) {
         // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-        const rootKey = keyBuilderFromType$o(luvio, input);
+        const rootKey = keyBuilderFromType$n(luvio, input);
         rootKeySet.set(rootKey, {
             namespace: keyPrefix$1,
-            representationName: RepresentationType$D,
+            representationName: RepresentationType$C,
             mergeable: false
         });
         const input_actions_length = input.actions.length;
         for (let i = 0; i < input_actions_length; i++) {
-            getTypeCacheKeys$F$1(rootKeySet, luvio, input.actions[i]);
+            getTypeCacheKeys$E$1(rootKeySet, luvio, input.actions[i]);
         }
     }
 
-    const TTL$q = 300000;
-    const VERSION$W$1 = "e485d96c1402a9ca2f56e56485af0216";
-    const RepresentationType$C = 'ActionRepresentation';
+    const TTL$p = 300000;
+    const VERSION$V$1 = "e485d96c1402a9ca2f56e56485af0216";
+    const RepresentationType$B = 'ActionRepresentation';
     function normalize$v(input, existing, path, luvio, store, timestamp) {
         const input_actions = input.actions;
         const input_actions_id = path.fullPath + '__actions';
@@ -25797,7 +25910,7 @@
     const select$1q = function ActionRepresentationSelect() {
         return {
             kind: 'Fragment',
-            version: VERSION$W$1,
+            version: VERSION$V$1,
             private: [
                 'eTag',
                 'url'
@@ -25812,7 +25925,7 @@
             ]
         };
     };
-    function equals$J(existing, incoming) {
+    function equals$I(existing, incoming) {
         const existing_eTag = existing.eTag;
         const incoming_eTag = incoming.eTag;
         if (!(existing_eTag === incoming_eTag)) {
@@ -25837,16 +25950,16 @@
     }
     const ingest$v$1 = function ActionRepresentationIngest(input, path, luvio, store, timestamp) {
         const key = path.fullPath;
-        const ttlToUse = TTL$q;
-        ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$v, "UiApi", VERSION$W$1, RepresentationType$C, equals$J);
+        const ttlToUse = TTL$p;
+        ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$v, "UiApi", VERSION$V$1, RepresentationType$B, equals$I);
         return createLink$3(key);
     };
-    function getTypeCacheKeys$D$1(rootKeySet, luvio, input, fullPathFactory) {
+    function getTypeCacheKeys$C$1(rootKeySet, luvio, input, fullPathFactory) {
         // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
         const rootKey = fullPathFactory();
         rootKeySet.set(rootKey, {
             namespace: keyPrefix$1,
-            representationName: RepresentationType$C,
+            representationName: RepresentationType$B,
             mergeable: false
         });
         const input_actions = input.actions;
@@ -25854,22 +25967,22 @@
         const input_actions_length = input_actions_keys.length;
         for (let i = 0; i < input_actions_length; i++) {
             const key = input_actions_keys[i];
-            getTypeCacheKeys$E$1(rootKeySet, luvio, input_actions[key]);
+            getTypeCacheKeys$D$1(rootKeySet, luvio, input_actions[key]);
         }
     }
 
     function select$1p(luvio, params) {
         return select$1q();
     }
-    function keyBuilder$1A(luvio, params) {
+    function keyBuilder$1z(luvio, params) {
         return keyPrefix$1 + '::ActionRepresentation:(' + 'actionTypes:' + params.queryParams.actionTypes + ',' + 'apiNames:' + params.queryParams.apiNames + ',' + 'formFactor:' + params.queryParams.formFactor + ',' + 'retrievalMode:' + params.queryParams.retrievalMode + ',' + 'sections:' + params.queryParams.sections + ')';
     }
     function getResponseCacheKeys$P(storeKeyMap, luvio, resourceParams, response) {
-        getTypeCacheKeys$D$1(storeKeyMap, luvio, response, () => keyBuilder$1A(luvio, resourceParams));
+        getTypeCacheKeys$C$1(storeKeyMap, luvio, response, () => keyBuilder$1z(luvio, resourceParams));
     }
     function ingestSuccess$F(luvio, resourceParams, response, snapshotRefresh) {
         const { body } = response;
-        const key = keyBuilder$1A(luvio, resourceParams);
+        const key = keyBuilder$1z(luvio, resourceParams);
         luvio.storeIngest(key, ingest$v$1, body);
         const snapshot = luvio.storeLookup({
             recordId: key,
@@ -25880,13 +25993,13 @@
         return snapshot;
     }
     function ingestError$B(luvio, params, error, snapshotRefresh) {
-        const key = keyBuilder$1A(luvio, params);
+        const key = keyBuilder$1z(luvio, params);
         const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
         const storeMetadataParams = {
-            ttl: TTL$q,
+            ttl: TTL$p,
             namespace: keyPrefix$1,
-            version: VERSION$W$1,
-            representationName: RepresentationType$C
+            version: VERSION$V$1,
+            representationName: RepresentationType$B
         };
         luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
         return errorSnapshot;
@@ -25915,9 +26028,9 @@
     ];
     const getGlobalActions_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig$1(adapterName$P, getGlobalActions_ConfigPropertyMetadata);
     const createResourceParams$O = /*#__PURE__*/ createResourceParams$X(getGlobalActions_ConfigPropertyMetadata);
-    function keyBuilder$1z(luvio, config) {
+    function keyBuilder$1y(luvio, config) {
         const resourceParams = createResourceParams$O(config);
-        return keyBuilder$1A(luvio, resourceParams);
+        return keyBuilder$1z(luvio, resourceParams);
     }
     function typeCheckConfig$U(untrustedConfig) {
         const config = {};
@@ -25973,7 +26086,7 @@
     function buildCachedSnapshotCachePolicy$H(context, storeLookup) {
         const { luvio, config } = context;
         const selector = {
-            recordId: keyBuilder$1z(luvio, config),
+            recordId: keyBuilder$1y(luvio, config),
             node: adapterFragment$A(luvio, config),
             variables: {},
         };
@@ -25993,17 +26106,17 @@
         buildCachedSnapshotCachePolicy$H, buildNetworkSnapshotCachePolicy$I);
     };
 
-    const TTL$p = 900000;
-    const VERSION$V$1 = "3c5af9dc4086169091e3c5df2414c495";
-    const RepresentationType$B = 'QuickActionLayoutRepresentation';
-    function keyBuilder$1y(luvio, config) {
-        return keyPrefix$1 + '::' + RepresentationType$B + ':' + config.actionApiName;
+    const TTL$o = 900000;
+    const VERSION$U$1 = "3c5af9dc4086169091e3c5df2414c495";
+    const RepresentationType$A = 'QuickActionLayoutRepresentation';
+    function keyBuilder$1x(luvio, config) {
+        return keyPrefix$1 + '::' + RepresentationType$A + ':' + config.actionApiName;
     }
-    function keyBuilderFromType$n(luvio, object) {
+    function keyBuilderFromType$m(luvio, object) {
         const keyParams = {
             actionApiName: object.actionApiName
         };
-        return keyBuilder$1y(luvio, keyParams);
+        return keyBuilder$1x(luvio, keyParams);
     }
     function normalize$u(input, existing, path, luvio, store, timestamp) {
         return input;
@@ -26011,7 +26124,7 @@
     const select$1o = function QuickActionLayoutRepresentationSelect() {
         return {
             kind: 'Fragment',
-            version: VERSION$V$1,
+            version: VERSION$U$1,
             private: [
                 'eTag'
             ],
@@ -26028,24 +26141,24 @@
             ]
         };
     };
-    function equals$I(existing, incoming) {
+    function equals$H(existing, incoming) {
         if (existing.eTag !== incoming.eTag) {
             return false;
         }
         return true;
     }
     const ingest$u$1 = function QuickActionLayoutRepresentationIngest(input, path, luvio, store, timestamp) {
-        const key = keyBuilderFromType$n(luvio, input);
-        const ttlToUse = TTL$p;
-        ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$u, "UiApi", VERSION$V$1, RepresentationType$B, equals$I);
+        const key = keyBuilderFromType$m(luvio, input);
+        const ttlToUse = TTL$o;
+        ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$u, "UiApi", VERSION$U$1, RepresentationType$A, equals$H);
         return createLink$3(key);
     };
-    function getTypeCacheKeys$C$1(rootKeySet, luvio, input, fullPathFactory) {
+    function getTypeCacheKeys$B$1(rootKeySet, luvio, input, fullPathFactory) {
         // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-        const rootKey = keyBuilderFromType$n(luvio, input);
+        const rootKey = keyBuilderFromType$m(luvio, input);
         rootKeySet.set(rootKey, {
             namespace: keyPrefix$1,
-            representationName: RepresentationType$B,
+            representationName: RepresentationType$A,
             mergeable: false
         });
     }
@@ -26053,17 +26166,17 @@
     function select$1n(luvio, params) {
         return select$1o();
     }
-    function keyBuilder$1x(luvio, params) {
-        return keyBuilder$1y(luvio, {
+    function keyBuilder$1w(luvio, params) {
+        return keyBuilder$1x(luvio, {
             actionApiName: params.urlParams.actionApiName
         });
     }
     function getResponseCacheKeys$O(storeKeyMap, luvio, resourceParams, response) {
-        getTypeCacheKeys$C$1(storeKeyMap, luvio, response);
+        getTypeCacheKeys$B$1(storeKeyMap, luvio, response);
     }
     function ingestSuccess$E(luvio, resourceParams, response, snapshotRefresh) {
         const { body } = response;
-        const key = keyBuilder$1x(luvio, resourceParams);
+        const key = keyBuilder$1w(luvio, resourceParams);
         luvio.storeIngest(key, ingest$u$1, body);
         const snapshot = luvio.storeLookup({
             recordId: key,
@@ -26074,13 +26187,13 @@
         return snapshot;
     }
     function ingestError$A(luvio, params, error, snapshotRefresh) {
-        const key = keyBuilder$1x(luvio, params);
+        const key = keyBuilder$1w(luvio, params);
         const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
         const storeMetadataParams = {
-            ttl: TTL$p,
+            ttl: TTL$o,
             namespace: keyPrefix$1,
-            version: VERSION$V$1,
-            representationName: RepresentationType$B
+            version: VERSION$U$1,
+            representationName: RepresentationType$A
         };
         luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
         return errorSnapshot;
@@ -26105,9 +26218,9 @@
     ];
     const getQuickActionLayout_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig$1(adapterName$O, getQuickActionLayout_ConfigPropertyMetadata);
     const createResourceParams$N = /*#__PURE__*/ createResourceParams$X(getQuickActionLayout_ConfigPropertyMetadata);
-    function keyBuilder$1w(luvio, config) {
+    function keyBuilder$1v(luvio, config) {
         const resourceParams = createResourceParams$N(config);
-        return keyBuilder$1x(luvio, resourceParams);
+        return keyBuilder$1w(luvio, resourceParams);
     }
     function typeCheckConfig$T(untrustedConfig) {
         const config = {};
@@ -26162,7 +26275,7 @@
     function buildCachedSnapshotCachePolicy$G(context, storeLookup) {
         const { luvio, config } = context;
         const selector = {
-            recordId: keyBuilder$1w(luvio, config),
+            recordId: keyBuilder$1v(luvio, config),
             node: adapterFragment$z(luvio, config),
             variables: {},
         };
@@ -26217,15 +26330,15 @@
     function select$1m(luvio, params) {
         return select$1q();
     }
-    function keyBuilder$1v(luvio, params) {
+    function keyBuilder$1u(luvio, params) {
         return keyPrefix$1 + '::ActionRepresentation:(' + 'actionTypes:' + params.queryParams.actionTypes + ',' + 'formFactor:' + params.queryParams.formFactor + ',' + 'sections:' + params.queryParams.sections + ',' + 'objectApiNames:' + params.urlParams.objectApiNames + ')';
     }
     function getResponseCacheKeys$N(storeKeyMap, luvio, resourceParams, response) {
-        getTypeCacheKeys$D$1(storeKeyMap, luvio, response, () => keyBuilder$1v(luvio, resourceParams));
+        getTypeCacheKeys$C$1(storeKeyMap, luvio, response, () => keyBuilder$1u(luvio, resourceParams));
     }
     function ingestSuccess$D(luvio, resourceParams, response, snapshotRefresh) {
         const { body } = response;
-        const key = keyBuilder$1v(luvio, resourceParams);
+        const key = keyBuilder$1u(luvio, resourceParams);
         luvio.storeIngest(key, ingest$v$1, body);
         const snapshot = luvio.storeLookup({
             recordId: key,
@@ -26236,13 +26349,13 @@
         return snapshot;
     }
     function ingestError$z(luvio, params, error, snapshotRefresh) {
-        const key = keyBuilder$1v(luvio, params);
+        const key = keyBuilder$1u(luvio, params);
         const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
         const storeMetadataParams = {
-            ttl: TTL$q,
+            ttl: TTL$p,
             namespace: keyPrefix$1,
-            version: VERSION$W$1,
-            representationName: RepresentationType$C
+            version: VERSION$V$1,
+            representationName: RepresentationType$B
         };
         luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
         return errorSnapshot;
@@ -26270,9 +26383,9 @@
     ];
     const getLookupActions_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig$1(adapterName$N, getLookupActions_ConfigPropertyMetadata);
     const createResourceParams$M = /*#__PURE__*/ createResourceParams$X(getLookupActions_ConfigPropertyMetadata);
-    function keyBuilder$1u(luvio, config) {
+    function keyBuilder$1t(luvio, config) {
         const resourceParams = createResourceParams$M(config);
-        return keyBuilder$1v(luvio, resourceParams);
+        return keyBuilder$1u(luvio, resourceParams);
     }
     function typeCheckConfig$S(untrustedConfig) {
         const config = {};
@@ -26328,7 +26441,7 @@
     function buildCachedSnapshotCachePolicy$F(context, storeLookup) {
         const { luvio, config } = context;
         const selector = {
-            recordId: keyBuilder$1u(luvio, config),
+            recordId: keyBuilder$1t(luvio, config),
             node: adapterFragment$y(luvio, config),
             variables: {},
         };
@@ -26351,15 +26464,15 @@
     function select$1l(luvio, params) {
         return select$1q();
     }
-    function keyBuilder$1t(luvio, params) {
+    function keyBuilder$1s(luvio, params) {
         return keyPrefix$1 + '::ActionRepresentation:(' + 'actionTypes:' + params.queryParams.actionTypes + ',' + 'formFactor:' + params.queryParams.formFactor + ',' + 'sections:' + params.queryParams.sections + ',' + 'objectApiName:' + params.urlParams.objectApiName + ')';
     }
     function getResponseCacheKeys$M(storeKeyMap, luvio, resourceParams, response) {
-        getTypeCacheKeys$D$1(storeKeyMap, luvio, response, () => keyBuilder$1t(luvio, resourceParams));
+        getTypeCacheKeys$C$1(storeKeyMap, luvio, response, () => keyBuilder$1s(luvio, resourceParams));
     }
     function ingestSuccess$C(luvio, resourceParams, response, snapshotRefresh) {
         const { body } = response;
-        const key = keyBuilder$1t(luvio, resourceParams);
+        const key = keyBuilder$1s(luvio, resourceParams);
         luvio.storeIngest(key, ingest$v$1, body);
         const snapshot = luvio.storeLookup({
             recordId: key,
@@ -26370,13 +26483,13 @@
         return snapshot;
     }
     function ingestError$y(luvio, params, error, snapshotRefresh) {
-        const key = keyBuilder$1t(luvio, params);
+        const key = keyBuilder$1s(luvio, params);
         const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
         const storeMetadataParams = {
-            ttl: TTL$q,
+            ttl: TTL$p,
             namespace: keyPrefix$1,
-            version: VERSION$W$1,
-            representationName: RepresentationType$C
+            version: VERSION$V$1,
+            representationName: RepresentationType$B
         };
         luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
         return errorSnapshot;
@@ -26404,9 +26517,9 @@
     ];
     const getObjectCreateActions_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig$1(adapterName$M, getObjectCreateActions_ConfigPropertyMetadata);
     const createResourceParams$L = /*#__PURE__*/ createResourceParams$X(getObjectCreateActions_ConfigPropertyMetadata);
-    function keyBuilder$1s(luvio, config) {
+    function keyBuilder$1r(luvio, config) {
         const resourceParams = createResourceParams$L(config);
-        return keyBuilder$1t(luvio, resourceParams);
+        return keyBuilder$1s(luvio, resourceParams);
     }
     function typeCheckConfig$R(untrustedConfig) {
         const config = {};
@@ -26462,7 +26575,7 @@
     function buildCachedSnapshotCachePolicy$E(context, storeLookup) {
         const { luvio, config } = context;
         const selector = {
-            recordId: keyBuilder$1s(luvio, config),
+            recordId: keyBuilder$1r(luvio, config),
             node: adapterFragment$x(luvio, config),
             variables: {},
         };
@@ -26482,20 +26595,20 @@
         buildCachedSnapshotCachePolicy$E, buildNetworkSnapshotCachePolicy$F);
     };
 
-    const VERSION$U$1 = "fecd80e9e24a1c1e75fd5395cd34ff2e";
-    const RepresentationType$A = 'ActionOverrideRepresentation';
+    const VERSION$T$1 = "fecd80e9e24a1c1e75fd5395cd34ff2e";
+    const RepresentationType$z = 'ActionOverrideRepresentation';
     function normalize$t(input, existing, path, luvio, store, timestamp) {
         return input;
     }
     const select$1k = function ActionOverrideRepresentationSelect() {
         return {
             kind: 'Fragment',
-            version: VERSION$U$1,
+            version: VERSION$T$1,
             private: [],
             opaque: true
         };
     };
-    function equals$H(existing, incoming) {
+    function equals$G(existing, incoming) {
         if (JSONStringify$2(incoming) !== JSONStringify$2(existing)) {
             return false;
         }
@@ -26504,15 +26617,15 @@
     const ingest$t$1 = function ActionOverrideRepresentationIngest(input, path, luvio, store, timestamp) {
         const key = path.fullPath;
         const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
-        ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$t, "UiApi", VERSION$U$1, RepresentationType$A, equals$H);
+        ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$t, "UiApi", VERSION$T$1, RepresentationType$z, equals$G);
         return createLink$3(key);
     };
-    function getTypeCacheKeys$B$1(rootKeySet, luvio, input, fullPathFactory) {
+    function getTypeCacheKeys$A$1(rootKeySet, luvio, input, fullPathFactory) {
         // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
         const rootKey = fullPathFactory();
         rootKeySet.set(rootKey, {
             namespace: keyPrefix$1,
-            representationName: RepresentationType$A,
+            representationName: RepresentationType$z,
             mergeable: false
         });
     }
@@ -26520,15 +26633,15 @@
     function select$1j(luvio, params) {
         return select$1k();
     }
-    function keyBuilder$1r(luvio, params) {
+    function keyBuilder$1q(luvio, params) {
         return keyPrefix$1 + '::ActionOverrideRepresentation:(' + 'type:' + params.queryParams.type + ',' + 'objectApiName:' + params.urlParams.objectApiName + ')';
     }
     function getResponseCacheKeys$L(storeKeyMap, luvio, resourceParams, response) {
-        getTypeCacheKeys$B$1(storeKeyMap, luvio, response, () => keyBuilder$1r(luvio, resourceParams));
+        getTypeCacheKeys$A$1(storeKeyMap, luvio, response, () => keyBuilder$1q(luvio, resourceParams));
     }
     function ingestSuccess$B(luvio, resourceParams, response, snapshotRefresh) {
         const { body } = response;
-        const key = keyBuilder$1r(luvio, resourceParams);
+        const key = keyBuilder$1q(luvio, resourceParams);
         luvio.storeIngest(key, ingest$t$1, body);
         const snapshot = luvio.storeLookup({
             recordId: key,
@@ -26539,7 +26652,7 @@
         return snapshot;
     }
     function ingestError$x(luvio, params, error, snapshotRefresh) {
-        const key = keyBuilder$1r(luvio, params);
+        const key = keyBuilder$1q(luvio, params);
         const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
         luvio.storeIngestError(key, errorSnapshot);
         return errorSnapshot;
@@ -26565,9 +26678,9 @@
     ];
     const getActionOverrides_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig$1(adapterName$L, getActionOverrides_ConfigPropertyMetadata);
     const createResourceParams$K = /*#__PURE__*/ createResourceParams$X(getActionOverrides_ConfigPropertyMetadata);
-    function keyBuilder$1q(luvio, config) {
+    function keyBuilder$1p(luvio, config) {
         const resourceParams = createResourceParams$K(config);
-        return keyBuilder$1r(luvio, resourceParams);
+        return keyBuilder$1q(luvio, resourceParams);
     }
     function typeCheckConfig$Q(untrustedConfig) {
         const config = {};
@@ -26623,7 +26736,7 @@
     function buildCachedSnapshotCachePolicy$D(context, storeLookup) {
         const { luvio, config } = context;
         const selector = {
-            recordId: keyBuilder$1q(luvio, config),
+            recordId: keyBuilder$1p(luvio, config),
             node: adapterFragment$w(luvio, config),
             variables: {},
         };
@@ -26643,118 +26756,11 @@
         buildCachedSnapshotCachePolicy$D, buildNetworkSnapshotCachePolicy$E);
     };
 
-    const TTL$o = 900000;
-    const VERSION$T$1 = "993b0a7bce6056c4f57ed300ec153d9c";
-    const RepresentationType$z = 'QuickActionDefaultsRepresentation';
-    function keyBuilder$1p(luvio, config) {
-        return keyPrefix$1 + '::' + RepresentationType$z + ':' + config.actionApiName;
-    }
-    function keyBuilderFromType$m(luvio, object) {
-        const keyParams = {
-            actionApiName: object.actionApiName
-        };
-        return keyBuilder$1p(luvio, keyParams);
-    }
-    function dynamicNormalize$4(ingestParams) {
-        return function normalize_dynamic(input, existing, path, luvio, store, timestamp) {
-            const input_fields = input.fields;
-            const input_fields_id = path.fullPath + '__fields';
-            const input_fields_keys = Object.keys(input_fields);
-            const input_fields_length = input_fields_keys.length;
-            for (let i = 0; i < input_fields_length; i++) {
-                const key = input_fields_keys[i];
-                const input_fields_prop = input_fields[key];
-                const input_fields_prop_id = input_fields_id + '__' + key;
-                input_fields[key] = ingestParams.fields(input_fields_prop, {
-                    fullPath: input_fields_prop_id,
-                    propertyName: key,
-                    parent: {
-                        data: input,
-                        key: path.fullPath,
-                        existing: existing,
-                    },
-                    ttl: path.ttl
-                }, luvio, store, timestamp);
-            }
-            return input;
-        };
-    }
-    const dynamicSelect$5 = function dynamicQuickActionDefaultsRepresentationSelect(params) {
-        const fieldsPathSelection = params.fields === undefined ? {
-            name: 'fields',
-            kind: 'Link',
-            map: true,
-            fragment: select$1F()
-        } : params.fields;
-        return {
-            kind: 'Fragment',
-            version: VERSION$T$1,
-            private: [
-                'eTag'
-            ],
-            selections: [
-                {
-                    name: 'actionApiName',
-                    kind: 'Scalar'
-                },
-                fieldsPathSelection,
-                {
-                    name: 'objectApiName',
-                    kind: 'Scalar'
-                }
-            ]
-        };
-    };
-    function equals$G(existing, incoming) {
-        const existing_actionApiName = existing.actionApiName;
-        const incoming_actionApiName = incoming.actionApiName;
-        if (!(existing_actionApiName === incoming_actionApiName)) {
-            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_fields = existing.fields;
-        const incoming_fields = incoming.fields;
-        const equals_fields_props = equalsObject$1(existing_fields, incoming_fields, (existing_fields_prop, incoming_fields_prop) => {
-            if (!(existing_fields_prop.__ref === incoming_fields_prop.__ref)) {
-                return false;
-            }
-        });
-        if (equals_fields_props === false) {
-            return false;
-        }
-        return true;
-    }
-    function getTypeCacheKeys$A$1(rootKeySet, luvio, input, fullPathFactory) {
-        // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-        const rootKey = keyBuilderFromType$m(luvio, input);
-        rootKeySet.set(rootKey, {
-            namespace: keyPrefix$1,
-            representationName: RepresentationType$z,
-            mergeable: false
-        });
-        const input_fields = input.fields;
-        const input_fields_keys = ObjectKeys$2(input_fields);
-        const input_fields_length = input_fields_keys.length;
-        for (let i = 0; i < input_fields_length; i++) {
-            const key = input_fields_keys[i];
-            getTypeCacheKeys$R$1(rootKeySet, luvio, input_fields[key], () => rootKey + "__fields" + "__" + key);
-        }
-    }
-
     const QUICK_ACTION_DEFAULTS_STORE_METADATA_PARAMS = {
-        ttl: TTL$o,
+        ttl: TTL$q,
         namespace: keyPrefix$1,
-        representationName: RepresentationType$z,
-        version: VERSION$T$1,
+        representationName: RepresentationType$E,
+        version: VERSION$Y$1,
     };
     function merge$1(existing, incoming) {
         if (existing === undefined) {
@@ -26771,7 +26777,7 @@
     }
     const dynamicIngest$4 = (ingestParams) => {
         return function QuickActionDefaultsRepresentationIngest(input, path, luvio, store, timestamp) {
-            const key = keyBuilderFromType$m(luvio, input);
+            const key = keyBuilderFromType$p(luvio, input);
             const existingRecord = store.readEntry(key);
             let incomingRecord = dynamicNormalize$4(ingestParams)(input, store.readEntry(key), {
                 fullPath: key,
@@ -26779,7 +26785,7 @@
                 propertyName: path.propertyName,
             }, luvio, store, timestamp);
             incomingRecord = merge$1(existingRecord, incomingRecord);
-            if (existingRecord === undefined || equals$G(existingRecord, incomingRecord) === false) {
+            if (existingRecord === undefined || equals$L(existingRecord, incomingRecord) === false) {
                 luvio.storePublish(key, incomingRecord);
             }
             luvio.publishStoreMetadata(key, QUICK_ACTION_DEFAULTS_STORE_METADATA_PARAMS);
@@ -26831,21 +26837,21 @@
     }
 
     function keyBuilder$1o(luvio, params) {
-        return keyBuilder$1p(luvio, {
+        return keyBuilder$1C(luvio, {
             actionApiName: params.urlParams.actionApiName
         });
     }
     function getResponseCacheKeys$K(storeKeyMap, luvio, resourceParams, response) {
-        getTypeCacheKeys$A$1(storeKeyMap, luvio, response);
+        getTypeCacheKeys$F$1(storeKeyMap, luvio, response);
     }
     function ingestError$w(luvio, params, error, snapshotRefresh) {
         const key = keyBuilder$1o(luvio, params);
         const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
         const storeMetadataParams = {
-            ttl: TTL$o,
+            ttl: TTL$q,
             namespace: keyPrefix$1,
-            version: VERSION$T$1,
-            representationName: RepresentationType$z
+            version: VERSION$Y$1,
+            representationName: RepresentationType$E
         };
         luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
         return errorSnapshot;
@@ -26980,7 +26986,7 @@
         return keyPrefix$1 + '::ActionRepresentation:(' + 'actionTypes:' + params.queryParams.actionTypes + ',' + 'apiNames:' + params.queryParams.apiNames + ',' + 'formFactor:' + params.queryParams.formFactor + ',' + 'retrievalMode:' + params.queryParams.retrievalMode + ',' + 'sections:' + params.queryParams.sections + ',' + 'recordIds:' + params.urlParams.recordIds + ')';
     }
     function getResponseCacheKeys$J(storeKeyMap, luvio, resourceParams, response) {
-        getTypeCacheKeys$D$1(storeKeyMap, luvio, response, () => keyBuilder$1m(luvio, resourceParams));
+        getTypeCacheKeys$C$1(storeKeyMap, luvio, response, () => keyBuilder$1m(luvio, resourceParams));
     }
     function ingestSuccess$A(luvio, resourceParams, response, snapshotRefresh) {
         const { body } = response;
@@ -26998,10 +27004,10 @@
         const key = keyBuilder$1m(luvio, params);
         const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
         const storeMetadataParams = {
-            ttl: TTL$q,
+            ttl: TTL$p,
             namespace: keyPrefix$1,
-            version: VERSION$W$1,
-            representationName: RepresentationType$C
+            version: VERSION$V$1,
+            representationName: RepresentationType$B
         };
         luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
         return errorSnapshot;
@@ -27120,7 +27126,7 @@
         return keyPrefix$1 + '::ActionRepresentation:(' + 'actionTypes:' + params.queryParams.actionTypes + ',' + 'formFactor:' + params.queryParams.formFactor + ',' + 'sections:' + params.queryParams.sections + ',' + 'recordIds:' + params.urlParams.recordIds + ')';
     }
     function getResponseCacheKeys$I(storeKeyMap, luvio, resourceParams, response) {
-        getTypeCacheKeys$D$1(storeKeyMap, luvio, response, () => keyBuilder$1k(luvio, resourceParams));
+        getTypeCacheKeys$C$1(storeKeyMap, luvio, response, () => keyBuilder$1k(luvio, resourceParams));
     }
     function ingestSuccess$z(luvio, resourceParams, response, snapshotRefresh) {
         const { body } = response;
@@ -27138,10 +27144,10 @@
         const key = keyBuilder$1k(luvio, params);
         const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
         const storeMetadataParams = {
-            ttl: TTL$q,
+            ttl: TTL$p,
             namespace: keyPrefix$1,
-            version: VERSION$W$1,
-            representationName: RepresentationType$C
+            version: VERSION$V$1,
+            representationName: RepresentationType$B
         };
         luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
         return errorSnapshot;
@@ -27324,7 +27330,7 @@
         return keyPrefix$1 + '::ActionRepresentation:(' + 'recordIds:' + params.urlParams.recordIds + ',' + 'relatedListId:' + params.urlParams.relatedListId + ',' + (params.body.actionTypes === undefined ? 'actionTypes' : 'actionTypes:' + params.body.actionTypes) + '::' + (params.body.apiNames === undefined ? 'apiNames' : 'apiNames:' + params.body.apiNames) + '::' + (params.body.formFactor === undefined ? 'formFactor' : 'formFactor:' + params.body.formFactor) + '::' + (params.body.retrievalMode === undefined ? 'retrievalMode' : 'retrievalMode:' + params.body.retrievalMode) + '::' + (params.body.sections === undefined ? 'sections' : 'sections:' + params.body.sections) + ')';
     }
     function getResponseCacheKeys$H(storeKeyMap, luvio, resourceParams, response) {
-        getTypeCacheKeys$D$1(storeKeyMap, luvio, response, () => keyBuilder$1i(luvio, resourceParams));
+        getTypeCacheKeys$C$1(storeKeyMap, luvio, response, () => keyBuilder$1i(luvio, resourceParams));
     }
     function ingestSuccess$y(luvio, resourceParams, response, snapshotRefresh) {
         const { body } = response;
@@ -27342,10 +27348,10 @@
         const key = keyBuilder$1i(luvio, params);
         const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
         const storeMetadataParams = {
-            ttl: TTL$q,
+            ttl: TTL$p,
             namespace: keyPrefix$1,
-            version: VERSION$W$1,
-            representationName: RepresentationType$C
+            version: VERSION$V$1,
+            representationName: RepresentationType$B
         };
         luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
         return errorSnapshot;
@@ -27770,7 +27776,7 @@
         return keyPrefix$1 + '::ActionRepresentation:(' + 'actionTypes:' + params.queryParams.actionTypes + ',' + 'formFactor:' + params.queryParams.formFactor + ',' + 'sections:' + params.queryParams.sections + ',' + 'recordIds:' + params.urlParams.recordIds + ',' + 'relatedListRecordIds:' + params.urlParams.relatedListRecordIds + ')';
     }
     function getResponseCacheKeys$F(storeKeyMap, luvio, resourceParams, response) {
-        getTypeCacheKeys$D$1(storeKeyMap, luvio, response, () => keyBuilder$1e(luvio, resourceParams));
+        getTypeCacheKeys$C$1(storeKeyMap, luvio, response, () => keyBuilder$1e(luvio, resourceParams));
     }
     function ingestSuccess$w(luvio, resourceParams, response, snapshotRefresh) {
         const { body } = response;
@@ -27788,10 +27794,10 @@
         const key = keyBuilder$1e(luvio, params);
         const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
         const storeMetadataParams = {
-            ttl: TTL$q,
+            ttl: TTL$p,
             namespace: keyPrefix$1,
-            version: VERSION$W$1,
-            representationName: RepresentationType$C
+            version: VERSION$V$1,
+            representationName: RepresentationType$B
         };
         luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
         return errorSnapshot;
@@ -41144,14 +41150,15 @@
             allowFunction: instrumentation$2.getRecordNotifyChangeAllowed,
             dropFunction: instrumentation$2.getRecordNotifyChangeDropped,
         });
-        throttle(60, 60000, createLDSAdapter(luvio, 'notifyRecordUpdateAvailable', notifyUpdateAvailableFactory$2), {
+        throttle(60, 60000, createLDSAdapter(luvio, 'notifyRecordUpdateAvailable', notifyUpdateAvailableFactory$3), {
             allowFunction: instrumentation$2.notifyRecordUpdateAvailableAllowed,
             dropFunction: instrumentation$2.notifyRecordUpdateAvailableDropped,
         });
-        throttle(60, 60000, createLDSAdapter(luvio, 'notifyListViewSummaryUpdateAvailable', notifyUpdateAvailableFactory$1));
-        throttle(60, 60000, createLDSAdapter(luvio, 'notifyListInfoUpdateAvailable', notifyUpdateAvailableFactory));
+        throttle(60, 60000, createLDSAdapter(luvio, 'notifyListViewSummaryUpdateAvailable', notifyUpdateAvailableFactory$2));
+        throttle(60, 60000, createLDSAdapter(luvio, 'notifyListInfoUpdateAvailable', notifyUpdateAvailableFactory$1));
+        throttle(60, 60000, createLDSAdapter(luvio, 'notifyQuickActionDefaultsUpdateAvailable', notifyUpdateAvailableFactory));
     });
-    // version: 1.227.2-e5b78df09
+    // version: 1.228.1-0cb6f94f1
 
     var caseSensitiveUserId = '005B0000000GR4OIAW';
 
@@ -46266,6 +46273,12 @@
             const resourceRequestCopy = clone$1(resourceRequest);
             resourceRequestCopy.headers = resourceRequestCopy.headers || {};
             resourceRequestCopy.headers[HTTP_HEADER_IDEMPOTENCY_KEY] = uuidv4();
+            // enable return extra fields for record creation and record update http call
+            if (resourceRequest.basePath === '/ui-api/records' &&
+                (resourceRequest.method === 'post' || resourceRequest.method === 'patch')) {
+                resourceRequestCopy.queryParams = resourceRequestCopy.queryParams || {};
+                resourceRequestCopy.queryParams['includeFieldsInBody'] = true;
+            }
             const { data } = await handler.enqueue(resourceRequestCopy).catch((err) => {
                 throw transformErrorToDraftSynthesisError(err);
             });
@@ -57803,7 +57816,7 @@
         id: '@salesforce/lds-network-adapter',
         instrument: instrument$1,
     });
-    // version: 1.227.2-daae2b505
+    // version: 1.228.1-4e6356f71
 
     const { create: create$2, keys: keys$2 } = Object;
     const { stringify: stringify$1, parse: parse$1 } = JSON;
@@ -57818,6 +57831,21 @@
         });
         return fragments;
     }
+    function mergeFragmentWithExistingSelections(fragmentFieldSelection, existingSelections) {
+        // Check if there is an existing selection for this field we can merge with
+        const existingField = getRequestedField(fragmentFieldSelection.name.value, existingSelections);
+        if (existingField === undefined) {
+            existingSelections.push(fragmentFieldSelection);
+        }
+        else {
+            if (existingField.selectionSet) {
+                const mergedSelections = mergeSelectionSets(existingField.selectionSet, fragmentFieldSelection.selectionSet);
+                existingField.selectionSet.selections = mergedSelections
+                    ? mergedSelections.selections
+                    : [];
+            }
+        }
+    }
 
     function buildFieldState(state, fullPath, data) {
         return {
@@ -57886,6 +57914,220 @@
             }
         }
     }
+    let selectionSetRequestedFieldsWeakMap = new WeakMap();
+    function getRequestedFieldsForType(typename, selectionSet, namedFragmentsMap, isFragmentApplicable) {
+        let cachedRequestedFieldsConfigurations = selectionSetRequestedFieldsWeakMap.get(selectionSet);
+        if (cachedRequestedFieldsConfigurations === undefined) {
+            cachedRequestedFieldsConfigurations = new Map();
+            selectionSetRequestedFieldsWeakMap.set(selectionSet, cachedRequestedFieldsConfigurations);
+        }
+        const cachedRequestedFieldsForType = cachedRequestedFieldsConfigurations.get(typename);
+        if (cachedRequestedFieldsForType !== undefined) {
+            return cachedRequestedFieldsForType;
+        }
+        const selections = calculateRequestedFieldsForType(typename, selectionSet, namedFragmentsMap, isFragmentApplicable);
+        cachedRequestedFieldsConfigurations.set(typename, selections);
+        return selections;
+    }
+    function getRequestedField(responseDataFieldName, requestedFields) {
+        return requestedFields.find((fieldNode) => (fieldNode.alias && fieldNode.alias.value === responseDataFieldName) ||
+            (!fieldNode.alias && fieldNode.name.value === responseDataFieldName));
+    }
+    function calculateRequestedFieldsForType(typename, selectionSet, namedFragmentsMap, isFragmentApplicable) {
+        const selections = [];
+        selectionSet.selections.forEach((selection) => {
+            if (selection.kind === 'Field') {
+                selections.push(selection);
+            }
+            if (selection.kind === 'InlineFragment' && isFragmentApplicable(selection, typename)) {
+                // loops over the map to get the values.
+                getRequestedFieldsForType(typename, selection.selectionSet, namedFragmentsMap, isFragmentApplicable).forEach((fragmentFieldSelection) => {
+                    mergeFragmentWithExistingSelections(fragmentFieldSelection, selections);
+                });
+            }
+            if (selection.kind === 'FragmentSpread') {
+                const namedFragment = namedFragmentsMap[selection.name.value];
+                if (namedFragment && isFragmentApplicable(namedFragment, typename)) {
+                    // loops over the map to get the values.
+                    getRequestedFieldsForType(typename, namedFragment.selectionSet, namedFragmentsMap, isFragmentApplicable).forEach((fragmentFieldSelection) => {
+                        mergeFragmentWithExistingSelections(fragmentFieldSelection, selections);
+                    });
+                }
+            }
+        });
+        // Needs to happen after the selections are merged.
+        return selections.reduce((acc, fieldNode) => {
+            const fieldName = fieldNode.alias ? fieldNode.alias.value : fieldNode.name.value;
+            // TODO: W-13485835. Some fields are not being merged, and this logic reproduces the current behavior in which the first field with name is being used.
+            if (!acc.has(fieldName)) {
+                acc.set(fieldName, fieldNode);
+            }
+            else {
+                const existingFieldNode = acc.get(fieldName);
+                acc.set(fieldName, {
+                    ...existingFieldNode,
+                    selectionSet: mergeSelectionSets(existingFieldNode === null || existingFieldNode === void 0 ? void 0 : existingFieldNode.selectionSet, fieldNode.selectionSet),
+                });
+            }
+            return acc;
+        }, new Map());
+    }
+    function mergeSelectionSets(set1, set2) {
+        if (!set2) {
+            return set1;
+        }
+        const set1Selections = !set1 ? [] : set1.selections;
+        const mergedSelections = [...set1Selections];
+        for (const selection of set2.selections) {
+            if (selection.kind === 'Field') {
+                const existingFieldIndex = mergedSelections.findIndex((sel) => {
+                    return sel.kind === 'Field' && isExactSameField(sel, selection);
+                });
+                if (existingFieldIndex > -1) {
+                    const existingField = mergedSelections[existingFieldIndex];
+                    const mergedSelectionSet = mergeSelectionSets(existingField.selectionSet, selection.selectionSet);
+                    if (mergedSelectionSet) {
+                        mergedSelections[existingFieldIndex] = {
+                            ...existingField,
+                            selectionSet: mergedSelectionSet,
+                        };
+                    }
+                }
+                else {
+                    mergedSelections.push(selection);
+                }
+            }
+            else if (selection.kind === 'FragmentSpread') {
+                if (!mergedSelections.some((sel) => sel.kind === 'FragmentSpread' &&
+                    sel.name.value === selection.name.value &&
+                    areDirectivesEqual(sel.directives, selection.directives))) {
+                    mergedSelections.push(selection);
+                }
+            }
+            else if (selection.kind === 'InlineFragment') {
+                const existingFragmentIndex = mergedSelections.findIndex((sel) => {
+                    return (sel.kind === 'InlineFragment' &&
+                        areTypeConditionsEqual(sel.typeCondition, selection.typeCondition) &&
+                        areDirectivesEqual(sel.directives, selection.directives));
+                });
+                if (existingFragmentIndex > -1) {
+                    const existingFragment = mergedSelections[existingFragmentIndex];
+                    const mergedSelectionSet = mergeSelectionSets(existingFragment.selectionSet, selection.selectionSet);
+                    if (mergedSelectionSet) {
+                        mergedSelections[existingFragmentIndex] = {
+                            ...existingFragment,
+                            selectionSet: mergedSelectionSet,
+                        };
+                    }
+                }
+                else {
+                    mergedSelections.push(selection);
+                }
+            }
+        }
+        return { kind: 'SelectionSet', selections: mergedSelections };
+    }
+    function areArgumentsEqual(args1, args2) {
+        if (!args1 && !args2) {
+            return true;
+        }
+        // length 0 arguments is semantically equivalent to falsy arguments.
+        if ((!args1 || args1.length === 0) && (!args2 || args2.length === 0)) {
+            return true;
+        }
+        if ((!args1 && args2) || (args1 && !args2)) {
+            return false;
+        }
+        if (args1.length !== args2.length) {
+            return false;
+        }
+        for (const arg of args1) {
+            const matchingArg = args2.find((a) => a.name.value === arg.name.value && areValuesEqual(a.value, arg.value));
+            if (!matchingArg) {
+                return false;
+            }
+        }
+        return true;
+    }
+    function areDirectivesEqual(dirs1, dirs2) {
+        if (!dirs1 && !dirs2) {
+            return true;
+        }
+        if ((!dirs1 || dirs1.length === 0) && (!dirs2 || dirs2.length === 0)) {
+            return true;
+        }
+        if ((!dirs1 && dirs2) || (dirs1 && !dirs2)) {
+            return false;
+        }
+        if (dirs1.length !== dirs2.length) {
+            return false;
+        }
+        for (const dir of dirs1) {
+            const matchingDir = dirs2.find((d) => d.name.value === dir.name.value && areArgumentsEqual(d.arguments, dir.arguments));
+            if (!matchingDir) {
+                return false;
+            }
+        }
+        return true;
+    }
+    function areValuesEqual(valueNode1, valueNode2) {
+        if (valueNode1.kind !== valueNode2.kind) {
+            return false;
+        }
+        // Typescript doesn't understand that the above check means that the switch applies to both values. So there will be casts here.
+        switch (valueNode1.kind) {
+            case 'StringValue':
+            case 'IntValue':
+            case 'FloatValue':
+            case 'BooleanValue':
+            case 'EnumValue':
+                return valueNode1.value === valueNode2.value;
+            case 'NullValue':
+                return true; // Both Null value nodes? Always true.
+            case 'ListValue':
+                if (valueNode1.values.length !== valueNode2.values.length) {
+                    return false;
+                }
+                for (let i = 0; i < valueNode1.values.length; i++) {
+                    if (!areValuesEqual(valueNode1.values[i], valueNode2.values[i])) {
+                        return false;
+                    }
+                }
+                return true;
+            case 'ObjectValue':
+                if (valueNode1.fields.length !== valueNode2.fields.length) {
+                    return false;
+                }
+                for (let i = 0; i < valueNode1.fields.length; i++) {
+                    const field1 = valueNode1.fields[i];
+                    const field2 = valueNode2.fields.find((f) => f.name.value === field1.name.value);
+                    if (!field2 || !areValuesEqual(field1.value, field2.value)) {
+                        return false;
+                    }
+                }
+                return true;
+            case 'Variable':
+                return valueNode1.name.value === valueNode2.name.value;
+            default:
+                return false;
+        }
+    }
+    function areTypeConditionsEqual(typeCondition1, typeCondition2) {
+        if (typeCondition1 === undefined && typeCondition2 === undefined) {
+            return true;
+        }
+        if ((!typeCondition1 && typeCondition2) || (typeCondition1 && !typeCondition2)) {
+            return false;
+        }
+        return typeCondition1.name.value === typeCondition2.name.value;
+    }
+    function isExactSameField(field1, field2) {
+        var _a, _b;
+        return (field1.name.value === field2.name.value &&
+            ((_a = field1.alias) === null || _a === void 0 ? void 0 : _a.value) === ((_b = field2.alias) === null || _b === void 0 ? void 0 : _b.value) &&
+            areArgumentsEqual(field1.arguments, field2.arguments) &&
+            areDirectivesEqual(field1.directives, field2.directives));
+    }
 
     function serializeOperationNode$1(operationNode, variables, fragmentMap) {
         return `${serializeSelectionSet(operationNode.selectionSet, variables, fragmentMap)}`;
@@ -57942,6 +58184,53 @@
         return operations[0]; // If a named operation is not provided, we return the first one
     }
 
+    const { hasOwnProperty: ObjectPrototypeHasOwnProperty$1 } = Object.prototype;
+    // Deep merge that works on GraphQL data. It:
+    // - recursively merges any Object properties that are present in both
+    // - recursively merges arrays by deepMerging each Object item in the array (by index).
+    function deepMerge(target, ...sources) {
+        for (const source of sources) {
+            for (const key in source) {
+                if (ObjectPrototypeHasOwnProperty$1.call(source, key)) {
+                    const targetValue = target[key];
+                    const sourceValue = source[key];
+                    if (Array.isArray(targetValue) && Array.isArray(sourceValue)) {
+                        const maxLength = Math.max(targetValue.length, sourceValue.length);
+                        target[key] = Array.from({ length: maxLength }, (_, index) => {
+                            const targetItem = targetValue[index];
+                            const sourceItem = sourceValue[index];
+                            if (targetItem === undefined) {
+                                return sourceItem;
+                            }
+                            else if (sourceItem === undefined) {
+                                return targetItem;
+                            }
+                            else if (targetItem instanceof Object &&
+                                !Array.isArray(targetItem) &&
+                                sourceItem instanceof Object &&
+                                !Array.isArray(sourceItem)) {
+                                return deepMerge({}, targetItem, sourceItem);
+                            }
+                            else {
+                                return sourceItem;
+                            }
+                        });
+                    }
+                    else if (targetValue instanceof Object &&
+                        !Array.isArray(targetValue) &&
+                        sourceValue instanceof Object &&
+                        !Array.isArray(sourceValue)) {
+                        deepMerge(targetValue, sourceValue);
+                    }
+                    else {
+                        target[key] = sourceValue;
+                    }
+                }
+            }
+        }
+        return target;
+    }
+
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
      * All rights reserved.
@@ -71665,13 +71954,12 @@
             selectionSetNode === undefined) {
             return;
         }
-        const { selections } = selectionSetNode;
-        if (selections === undefined ||
-            selections === null) {
-            return;
-        }
-        const mergedSelections = mergeSelections(queryTransformHelper.getMinimumSelections(), selections);
-        mergedSelections.forEach(selection => {
+        const minimumSelectionSet = {
+            kind: 'SelectionSet',
+            selections: queryTransformHelper.getMinimumSelections()
+        };
+        const mergedSelections = mergeSelectionSets(selectionSetNode, minimumSelectionSet);
+        mergedSelections === null || mergedSelections === void 0 ? void 0 : mergedSelections.selections.forEach(selection => {
             if (selection.kind === 'Field') {
                 const fieldType = queryTransformHelper.getFieldType(selection);
                 const fieldTransformHelper = fieldType === undefined ? undefined : getQueryTransformerForType(fieldType.typename);
@@ -71700,42 +71988,7 @@
                 }
             }
         });
-        Object.assign(selectionSetNode, {
-            selections: mergedSelections.length > 0 ? mergedSelections : undefined
-        });
-    }
-    function mergeSelections(minimumSelections, querySelections) {
-        const mergedSelections = [...querySelections];
-        for (let i = 0; i < minimumSelections.length; i++) {
-            const minimumSelection = minimumSelections[i];
-            if (minimumSelection.kind === 'Field') {
-                const existingNode = mergedSelections.find(selection => {
-                    return selection.kind === 'Field' && selection.name.value === minimumSelection.name.value && (selection.directives === undefined || selection.directives.length === 0);
-                });
-                if (existingNode !== undefined && existingNode.kind === 'Field') { // Maybe do better type narrowing above
-                    const existingNodeHasSubselections = existingNode.selectionSet !== undefined && existingNode.selectionSet.selections.length > 0;
-                    const minimumFieldNodeHasSubselections = minimumSelection.selectionSet !== undefined && minimumSelection.selectionSet.selections.length > 0;
-                    // TODO(correctness enhancement): this doesn't handle arugments. Add alias if arguments disagree?
-                    if (existingNodeHasSubselections && minimumFieldNodeHasSubselections) {
-                        const mergedChildSelections = mergeSelections(minimumSelection.selectionSet.selections, existingNode.selectionSet.selections);
-                        Object.assign(existingNode.selectionSet, {
-                            selections: mergedChildSelections
-                        });
-                    }
-                }
-                else {
-                    mergedSelections.push(minimumSelection);
-                }
-            }
-            if (minimumSelection.kind === 'InlineFragment') {
-                mergedSelections.push(minimumSelection);
-            }
-            if (minimumSelection.kind === 'FragmentSpread') ;
-        }
-        return mergedSelections;
-    }
-    function getRequestedField(responseDataFieldName, requestedFields) {
-        return requestedFields.find(fieldNode => (fieldNode.alias && fieldNode.alias.value === responseDataFieldName) || (!fieldNode.alias && fieldNode.name.value === responseDataFieldName));
+        Object.assign(selectionSetNode, mergedSelections);
     }
     function getPageMetadata(paginationMetadata, paginationParams) {
         const metadataProperties = {};
@@ -71781,67 +72034,6 @@
         const argumentString = mutableArgumentNodes.length > 0 ? '__' + serializeFieldArguments(mutableArgumentNodes, variables) : '';
         return field.name.value + argumentString; // It should be safe to always use the fieldName - If an alias is meaningful, there will be arguments on the key also.
     }
-    function mergeFragmentWithExistingSelections(fragmentFieldSelection, existingSelections) {
-        // Check if there is an existing selection for this field we can merge with
-        // If this isn't done, we will see issues such as W-12293630 & W-12236456 as examples
-        const existingField = getRequestedField(fragmentFieldSelection.name.value, existingSelections);
-        if (existingField === undefined) {
-            existingSelections.push(fragmentFieldSelection);
-        }
-        else {
-            if (existingField.selectionSet === undefined) {
-                existingField.selectionSet === fragmentFieldSelection.selectionSet;
-            }
-            else if (fragmentFieldSelection.selectionSet !== undefined) {
-                existingField.selectionSet.selections = mergeSelections(fragmentFieldSelection.selectionSet.selections, existingField.selectionSet.selections);
-            }
-        }
-    }
-    function calculateRequestedFieldsForType(typename, selectionSet, namedFragmentsMap, isFragmentApplicable) {
-        const selections = [];
-        selectionSet.selections.forEach(selection => {
-            if (selection.kind === "Field") {
-                selections.push(selection);
-            }
-            if (selection.kind === "InlineFragment" && isFragmentApplicable(selection, typename)) {
-                // loops over the map to get the values.
-                getRequestedFieldsForType(typename, selection.selectionSet, namedFragmentsMap, isFragmentApplicable)
-                    .forEach(fragmentFieldSelection => { mergeFragmentWithExistingSelections(fragmentFieldSelection, selections); });
-            }
-            if (selection.kind === "FragmentSpread") {
-                const namedFragment = namedFragmentsMap[selection.name.value];
-                if (namedFragment && isFragmentApplicable(namedFragment, typename)) {
-                    // loops over the map to get the values.
-                    getRequestedFieldsForType(typename, namedFragment.selectionSet, namedFragmentsMap, isFragmentApplicable)
-                        .forEach(fragmentFieldSelection => { mergeFragmentWithExistingSelections(fragmentFieldSelection, selections); });
-                }
-            }
-        });
-        // Needs to happen after the selections are merged.
-        return selections.reduce((acc, fieldNode) => {
-            const fieldName = fieldNode.alias ? fieldNode.alias.value : fieldNode.name.value;
-            // TODO: W-13485835. Some fields are not being merged, and this logic reproduces the current behavior in which the first field with name is being used.
-            if (!acc.has(fieldName)) {
-                acc.set(fieldName, fieldNode);
-            }
-            return acc;
-        }, new Map());
-    }
-    let selectionSetRequestedFieldsWeakMap = new WeakMap();
-    function getRequestedFieldsForType(typename, selectionSet, namedFragmentsMap, isFragmentApplicable) {
-        let cachedRequestedFieldsConfigurations = selectionSetRequestedFieldsWeakMap.get(selectionSet);
-        if (cachedRequestedFieldsConfigurations === undefined) {
-            cachedRequestedFieldsConfigurations = new Map();
-            selectionSetRequestedFieldsWeakMap.set(selectionSet, cachedRequestedFieldsConfigurations);
-        }
-        const cachedRequestedFieldsForType = cachedRequestedFieldsConfigurations.get(typename);
-        if (cachedRequestedFieldsForType !== undefined) {
-            return cachedRequestedFieldsForType;
-        }
-        const selections = calculateRequestedFieldsForType(typename, selectionSet, namedFragmentsMap, isFragmentApplicable);
-        cachedRequestedFieldsConfigurations.set(typename, selections);
-        return selections;
-    }
     function getQueryTransformerForType(typename, fragmentMap) {
         switch (typename) {
             case "PercentAggregate": return {
@@ -72460,18 +72652,7 @@
         (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
             const builtSelection = buildSelectionForNodeFn(source, reader, field, sel, variables, fragments, parentRecordId);
             if (builtSelection !== undefined) {
-                if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                    Object.keys(builtSelection).forEach((key, value) => {
-                        // We only assign a field selection in the fragment if it doesn't already exist in sink
-                        // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                        if (sink[key] === undefined) {
-                            sink[key] = builtSelection[key];
-                        }
-                    });
-                }
-                else {
-                    Object.assign(sink, builtSelection);
-                }
+                deepMerge(sink, builtSelection);
             }
         });
         return sink;
@@ -76081,7 +76262,7 @@
         configuration: { ...configurationForGraphQLAdapters },
         instrument,
     });
-    // version: 1.227.2-e5b78df09
+    // version: 1.228.1-0cb6f94f1
 
     // On core the unstable adapters are re-exported with different names,
 
@@ -78328,7 +78509,7 @@
         unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
         graphQLImperative = ldsAdapter;
     });
-    // version: 1.227.2-e5b78df09
+    // version: 1.228.1-0cb6f94f1
 
     var gqlApi = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -79059,4 +79240,4 @@
     Object.defineProperty(exports, '__esModule', { value: true });
 
 }));
-// version: 1.227.2-daae2b505
+// version: 1.228.1-4e6356f71