@salesforce/lds-worker-api 1.419.0 → 1.421.0

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

@@ -2357,7 +2357,7 @@
     /**
      * Checks if the given variable is an object
      */
-    function isObject$2(value) {
+    function isObject$3(value) {
         return typeof value === 'object' && value !== null;
     }
 
@@ -2987,10 +2987,10 @@
             }
             if (fragment.opaque) {
                 this.checkIfChanged(result.value, { useDeepEquals: true });
-                if (isObject$2(result.value) && !readerOpaqueReferenceMap.has(result.value)) {
+                if (isObject$3(result.value) && !readerOpaqueReferenceMap.has(result.value)) {
                     readerOpaqueReferenceMap.set(result.value, this.opaqueCopy(result.value));
                 }
-                const opaqueValue = isObject$2(result.value)
+                const opaqueValue = isObject$3(result.value)
                     ? readerOpaqueReferenceMap.get(result.value)
                     : result.value;
                 return {
@@ -4152,7 +4152,7 @@
         }
         return resourceParams;
     }
-    // engine version: 0.160.1-e075b880
+    // engine version: 0.160.3-354dc58b
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -4280,7 +4280,7 @@
         }
         callbacks.push(callback);
     }
-    // version: 1.419.0-ade430921b
+    // version: 1.421.0-2828c95aef
 
     // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
     function instrumentAdapter$1(createFunction, _metadata) {
@@ -5324,7 +5324,7 @@
         const { apiFamily, name } = metadata;
         return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
     }
-    // version: 1.419.0-ade430921b
+    // version: 1.421.0-2828c95aef
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -5423,7 +5423,7 @@
         TypeCheckShapes[TypeCheckShapes["Integer"] = 3] = "Integer";
         TypeCheckShapes[TypeCheckShapes["Unsupported"] = 4] = "Unsupported";
     })(TypeCheckShapes || (TypeCheckShapes = {}));
-    // engine version: 0.160.1-e075b880
+    // engine version: 0.160.3-354dc58b
 
     const { keys: ObjectKeys$4, create: ObjectCreate$4 } = Object;
 
@@ -35497,7 +35497,7 @@
         throttle(60, 60000, setupNotifyAllListRecordUpdateAvailable(luvio));
         throttle(60, 60000, setupNotifyAllListInfoSummaryUpdateAvailable(luvio));
     });
-    // version: 1.419.0-8232dcd0ab
+    // version: 1.421.0-45320a2742
 
     var allowUpdatesForNonCachedRecords = {
         isOpen: function (e) {
@@ -48928,7 +48928,7 @@
     const MessagingDurableSegment = 'MESSAGING';
     const MessageNotifyStoreUpdateAvailable = 'notifyStoreUpdateAvailable';
 
-    const { keys: keys$5, create: create$5, assign: assign$4, freeze: freeze$2 } = Object;
+    const { keys: keys$5, create: create$5, assign: assign$4, freeze: freeze$2, isFrozen: isFrozen$1$1 } = Object;
 
     //Durable store error instrumentation key
     const DURABLE_STORE_ERROR = 'durable-store-error';
@@ -49012,6 +49012,74 @@
         }
         return { revivedKeys, hadUnexpectedShape };
     }
+    /**
+     * Extracts field filtering configuration from the selection.
+     */
+    function extractFieldFilteringConfig(select, recordId, baseEnvironment) {
+        const rootRecordKey = serializeStructuredKey(baseEnvironment.storeGetCanonicalKey(recordId));
+        let topLevelFields;
+        let nestedFieldRequirements;
+        if (select &&
+            select.node.kind === 'Fragment' &&
+            'selections' in select.node &&
+            select.node.selections) {
+            topLevelFields = extractRequestedFieldNames(select.node.selections);
+            nestedFieldRequirements = extractNestedFieldRequirements(select.node.selections);
+        }
+        // Merge all nested field requirements into a single set
+        let nestedFields;
+        if (nestedFieldRequirements && nestedFieldRequirements.size > 0) {
+            nestedFields = new Set();
+            for (const fieldSet of nestedFieldRequirements.values()) {
+                for (const field of fieldSet) {
+                    nestedFields.add(field);
+                }
+            }
+        }
+        return { rootRecordKey, topLevelFields, nestedFields };
+    }
+    /**
+     * Categorizes keys into different fetch strategies based on filtering requirements.
+     */
+    function categorizeKeysForL2Fetch(keysToRevive, config, baseEnvironment, shouldFilterFields) {
+        const unfilteredKeys = [];
+        const rootKeysWithTopLevelFields = [];
+        const nestedKeysWithNestedFields = [];
+        const canFilter = config.topLevelFields !== undefined && config.topLevelFields.size > 0;
+        for (let i = 0, len = keysToRevive.length; i < len; i += 1) {
+            const canonicalKey = serializeStructuredKey(baseEnvironment.storeGetCanonicalKey(keysToRevive[i]));
+            if (!shouldFilterFields(canonicalKey) || !canFilter) {
+                unfilteredKeys.push(canonicalKey);
+                continue;
+            }
+            const isRootRecord = canonicalKey === config.rootRecordKey;
+            if (isRootRecord) {
+                rootKeysWithTopLevelFields.push(canonicalKey);
+            }
+            else if (config.nestedFields !== undefined && config.nestedFields.size > 0) {
+                nestedKeysWithNestedFields.push(canonicalKey);
+            }
+            else {
+                unfilteredKeys.push(canonicalKey);
+            }
+        }
+        return { unfilteredKeys, rootKeysWithTopLevelFields, nestedKeysWithNestedFields };
+    }
+    /**
+     * Builds L2 fetch promises for different key categories.
+     */
+    function buildL2FetchPromises(categorizedKeys, config, durableStore) {
+        const promises = [
+            durableStore.getEntries(categorizedKeys.unfilteredKeys, DefaultDurableSegment),
+        ];
+        if (config.topLevelFields && categorizedKeys.rootKeysWithTopLevelFields.length > 0) {
+            promises.push(durableStore.getEntriesWithSpecificFields(categorizedKeys.rootKeysWithTopLevelFields, config.topLevelFields, DefaultDurableSegment));
+        }
+        if (config.nestedFields && categorizedKeys.nestedKeysWithNestedFields.length > 0) {
+            promises.push(durableStore.getEntriesWithSpecificFields(categorizedKeys.nestedKeysWithNestedFields, config.nestedFields, DefaultDurableSegment));
+        }
+        return promises;
+    }
     /**
      * This method returns a Promise to a snapshot that is revived from L2 cache.  If
      * L2 does not have the entries necessary to fulfill the snapshot then this method
@@ -49047,53 +49115,41 @@
         const keysToRevive = keysToReviveSet.keysAsArray();
         const start = Date.now();
         const { l2Trips } = reviveMetrics;
-        // Extract requested fields first to determine if filtering is possible
-        let requestedFields;
-        if (select.node.kind === 'Fragment' && 'selections' in select.node && select.node.selections) {
-            requestedFields = extractRequestedFieldNames(select.node.selections);
-        }
-        const canonicalKeys = [];
-        const filteredCanonicalKeys = [];
-        for (let i = 0, len = keysToRevive.length; i < len; i += 1) {
-            const canonicalKey = serializeStructuredKey(baseEnvironment.storeGetCanonicalKey(keysToRevive[i]));
-            // Only filter if we have fields to filter and shouldFilterFields returns true
-            if (requestedFields !== undefined &&
-                requestedFields.size > 0 &&
-                shouldFilterFields(canonicalKey)) {
-                filteredCanonicalKeys.push(canonicalKey);
-            }
-            else {
-                canonicalKeys.push(canonicalKey);
-            }
-        }
-        const fetchPromises = [
-            durableStore.getEntries(canonicalKeys, DefaultDurableSegment),
-        ];
-        if (requestedFields !== undefined &&
-            requestedFields.size > 0 &&
-            filteredCanonicalKeys.length > 0) {
-            fetchPromises.push(durableStore.getEntriesWithSpecificFields(filteredCanonicalKeys, requestedFields, DefaultDurableSegment));
-        }
-        return Promise.all(fetchPromises).then(([durableRecords, filteredDurableRecords]) => {
+        // Extract field filtering requirements from the selection
+        const fieldFilteringConfig = extractFieldFilteringConfig(select, recordId, baseEnvironment);
+        // Categorize keys by how they should be fetched from L2
+        const categorizedKeys = categorizeKeysForL2Fetch(keysToRevive, fieldFilteringConfig, baseEnvironment, shouldFilterFields);
+        // Build fetch promises for each category
+        const fetchPromises = buildL2FetchPromises(categorizedKeys, fieldFilteringConfig, durableStore);
+        return Promise.all(fetchPromises).then(([durableRecords, filteredDurableRecords, nestedFilteredDurableRecords]) => {
+            const totalKeysRequested = categorizedKeys.unfilteredKeys.length +
+                categorizedKeys.rootKeysWithTopLevelFields.length +
+                categorizedKeys.nestedKeysWithNestedFields.length;
             l2Trips.push({
                 duration: Date.now() - start,
-                keysRequestedCount: canonicalKeys.length + filteredCanonicalKeys.length,
+                keysRequestedCount: totalKeysRequested,
             });
-            // Process both normal and filtered records in a single pass
+            // Process all three categories of records
             const revivedKeys = new StoreKeySet();
             let hadUnexpectedShape = false;
-            // Process normal records
+            // Process normal records (all fields)
             if (durableRecords !== undefined) {
                 const normalResult = publishDurableStoreEntries(durableRecords, baseEnvironment.storePut.bind(baseEnvironment), baseEnvironment.publishStoreMetadata.bind(baseEnvironment));
                 revivedKeys.merge(normalResult.revivedKeys);
                 hadUnexpectedShape = hadUnexpectedShape || normalResult.hadUnexpectedShape;
             }
-            // Process filtered records with merging
+            // Process filtered records (root with top-level fields) with merging
             if (filteredDurableRecords !== undefined) {
                 const filteredResult = publishDurableStoreEntries(filteredDurableRecords, createMergeFilteredPut((key) => baseEnvironment.store.readEntry(key), baseEnvironment.storePut.bind(baseEnvironment)), baseEnvironment.publishStoreMetadata.bind(baseEnvironment));
                 revivedKeys.merge(filteredResult.revivedKeys);
                 hadUnexpectedShape = hadUnexpectedShape || filteredResult.hadUnexpectedShape;
             }
+            // Process nested filtered records with merging
+            if (nestedFilteredDurableRecords !== undefined) {
+                const nestedFilteredResult = publishDurableStoreEntries(nestedFilteredDurableRecords, createMergeFilteredPut((key) => baseEnvironment.store.readEntry(key), baseEnvironment.storePut.bind(baseEnvironment)), baseEnvironment.publishStoreMetadata.bind(baseEnvironment));
+                revivedKeys.merge(nestedFilteredResult.revivedKeys);
+                hadUnexpectedShape = hadUnexpectedShape || nestedFilteredResult.hadUnexpectedShape;
+            }
             // if the data coming back from DS had an unexpected shape then just
             // return the L1 snapshot
             if (hadUnexpectedShape === true) {
@@ -49139,6 +49195,54 @@
             return { snapshot: unavailableSnapshot, metrics: reviveMetrics };
         });
     }
+    /**
+     * Filters out null fields from a fields object (null indicates field doesn't exist in L2).
+     * Returns a new object without null values, or the original if no filtering needed.
+     */
+    function filterNullFields(fields) {
+        const keys$1 = keys$5(fields);
+        let hasNull = false;
+        // Check if any nulls exist before allocating new object
+        for (let i = 0, len = keys$1.length; i < len; i += 1) {
+            if (fields[keys$1[i]] === null) {
+                hasNull = true;
+                break;
+            }
+        }
+        if (!hasNull) {
+            return fields;
+        }
+        const cleaned = {};
+        for (let i = 0, len = keys$1.length; i < len; i += 1) {
+            const key = keys$1[i];
+            if (fields[key] !== null) {
+                cleaned[key] = fields[key];
+            }
+        }
+        return cleaned;
+    }
+    /**
+     * Merges new fields into existing fields object, skipping null values.
+     * Creates a new object to avoid mutations.
+     */
+    function mergeFieldsObjects(existing, incoming) {
+        const merged = { ...existing };
+        const keys$1 = keys$5(incoming);
+        for (let i = 0, len = keys$1.length; i < len; i += 1) {
+            const key = keys$1[i];
+            // Skip null values - they indicate the field doesn't exist in L2
+            if (incoming[key] !== null) {
+                merged[key] = incoming[key];
+            }
+        }
+        return merged;
+    }
+    /**
+     * Type guard to check if value is a non-null object.
+     */
+    function isObject$1(value) {
+        return typeof value === 'object' && value !== null;
+    }
     /**
      * Creates a put function that merges filtered fields with existing L1 records instead of replacing them.
      * This is used when reviving filtered fields from L2 to preserve existing data in L1.
@@ -49146,28 +49250,36 @@
     function createMergeFilteredPut(readEntry, storePut) {
         return (key, filteredData) => {
             const existingRecord = readEntry(key);
-            if (existingRecord !== undefined &&
-                existingRecord !== null &&
-                typeof filteredData === 'object' &&
-                filteredData !== null &&
-                typeof existingRecord === 'object') {
-                const filteredFields = filteredData;
-                const existingObj = existingRecord;
-                // Check if object is frozen (can happen after deepFreeze)
-                // If frozen, create a shallow copy to merge fields into
-                let targetObj = existingObj;
-                if (Object.isFrozen(existingObj)) {
-                    targetObj = { ...existingObj };
-                }
-                const keys = Object.keys(filteredFields);
-                for (let i = 0, len = keys.length; i < len; i += 1) {
-                    const fieldKey = keys[i];
-                    targetObj[fieldKey] = filteredFields[fieldKey];
+            // Merge with existing record if both are objects
+            if (isObject$1(existingRecord) && isObject$1(filteredData)) {
+                // Create target object (copy if frozen to avoid mutation errors)
+                const targetObj = isFrozen$1$1(existingRecord)
+                    ? { ...existingRecord }
+                    : existingRecord;
+                const keys$1 = keys$5(filteredData);
+                for (let i = 0, len = keys$1.length; i < len; i += 1) {
+                    const fieldKey = keys$1[i];
+                    const incomingValue = filteredData[fieldKey];
+                    // Special handling for 'fields' property to merge rather than replace
+                    if (fieldKey === 'fields' &&
+                        isObject$1(incomingValue) &&
+                        isObject$1(targetObj[fieldKey])) {
+                        targetObj[fieldKey] = mergeFieldsObjects(targetObj[fieldKey], incomingValue);
+                    }
+                    else {
+                        targetObj[fieldKey] = incomingValue;
+                    }
                 }
                 storePut(key, targetObj);
             }
             else {
-                // No existing record, just put the filtered data
+                // No existing record - clean null fields before storing
+                if (isObject$1(filteredData) && 'fields' in filteredData) {
+                    const fields = filteredData.fields;
+                    if (isObject$1(fields)) {
+                        filteredData.fields = filterNullFields(fields);
+                    }
+                }
                 storePut(key, filteredData);
             }
         };
@@ -49181,16 +49293,101 @@
             return undefined;
         }
         // Find the 'fields' ObjectSelection
-        const fieldsSelection = selections.find((sel) => sel.kind === 'Object' && sel.name === 'fields');
-        if (!fieldsSelection || !fieldsSelection.selections) {
+        let fieldsSelection;
+        for (let i = 0, len = selections.length; i < len; i += 1) {
+            const sel = selections[i];
+            if (sel.kind === 'Object' && sel.name === 'fields') {
+                fieldsSelection = sel;
+                break;
+            }
+        }
+        if (!fieldsSelection ||
+            !fieldsSelection.selections ||
+            fieldsSelection.selections.length === 0) {
             return undefined;
         }
         // Extract all field names from the fields selections
+        const fieldSelections = fieldsSelection.selections;
         const fieldNames = new Set();
-        for (const fieldSel of fieldsSelection.selections) {
-            fieldNames.add(fieldSel.name);
+        for (let i = 0, len = fieldSelections.length; i < len; i += 1) {
+            fieldNames.add(fieldSelections[i].name);
         }
-        return fieldNames.size > 0 ? fieldNames : undefined;
+        return fieldNames;
+    }
+    /**
+     * Extracts nested field requirements for spanning fields.
+     * For spanning fields like Case.CreatedBy.Name, we need to extract what fields
+     * are requested from the nested record (User in this case).
+     * The structure is: fields { CreatedBy { value (Link with fragment) { fields { Name } } } }
+     */
+    function extractNestedFieldRequirements(selections) {
+        if (!selections) {
+            return undefined;
+        }
+        // Find the 'fields' ObjectSelection
+        let fieldsSelection;
+        for (let i = 0, len = selections.length; i < len; i += 1) {
+            const sel = selections[i];
+            if (sel.kind === 'Object' && sel.name === 'fields') {
+                fieldsSelection = sel;
+                break;
+            }
+        }
+        if (!fieldsSelection || !fieldsSelection.selections) {
+            return undefined;
+        }
+        let nestedFieldsMap;
+        // Look for ObjectSelections within fields (these are spanning fields)
+        const fieldSelections = fieldsSelection.selections;
+        for (let i = 0, len = fieldSelections.length; i < len; i += 1) {
+            const fieldSel = fieldSelections[i];
+            if (fieldSel.kind !== 'Object') {
+                continue;
+            }
+            const objSel = fieldSel;
+            if (!objSel.selections) {
+                continue;
+            }
+            // Look for the 'value' Link selection
+            let valueLinkSelection;
+            for (let j = 0, jlen = objSel.selections.length; j < jlen; j += 1) {
+                const sel = objSel.selections[j];
+                if (sel.kind === 'Link' && sel.name === 'value') {
+                    valueLinkSelection = sel;
+                    break;
+                }
+            }
+            if (!valueLinkSelection || !('fragment' in valueLinkSelection)) {
+                continue;
+            }
+            const fragment = valueLinkSelection.fragment;
+            if (!fragment || !fragment.selections) {
+                continue;
+            }
+            // Look for the 'fields' selection within the fragment
+            let nestedFieldsSelection;
+            for (let j = 0, jlen = fragment.selections.length; j < jlen; j += 1) {
+                const sel = fragment.selections[j];
+                if (sel.kind === 'Object' && sel.name === 'fields') {
+                    nestedFieldsSelection = sel;
+                    break;
+                }
+            }
+            if (nestedFieldsSelection && nestedFieldsSelection.selections) {
+                const nestedFields = new Set();
+                for (const nestedFieldSel of nestedFieldsSelection.selections) {
+                    nestedFields.add(nestedFieldSel.name);
+                }
+                if (nestedFields.size > 0) {
+                    // Lazy initialize map only if we have nested fields
+                    if (!nestedFieldsMap) {
+                        nestedFieldsMap = new Map();
+                    }
+                    nestedFieldsMap.set(fieldSel.name, nestedFields);
+                }
+            }
+        }
+        return nestedFieldsMap;
     }
 
     const TTL_DURABLE_SEGMENT = 'TTL_DURABLE_SEGMENT';
@@ -91334,7 +91531,7 @@
             else {
                 returnParams[key] = `${value}`;
             }
-            if (isObject$1(value) === true && keys$2$1(value).length > 0) {
+            if (isObject$2(value) === true && keys$2$1(value).length > 0) {
                 returnParams[key] = stringify$4(value);
             }
         }
@@ -91387,7 +91584,7 @@
         return status >= 200 && status <= 299;
     }
     // adapted from adapter-utils untrustedIsObject
-    function isObject$1(value) {
+    function isObject$2(value) {
         return typeof value === 'object' && value !== null && isArray$2$1(value) === false;
     }
     function stringifyIfPresent(value) {
@@ -98878,7 +99075,7 @@
             },
         };
     }
-    // version: 1.419.0-8232dcd0ab
+    // version: 1.421.0-45320a2742
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -98904,7 +99101,7 @@
             },
         };
     }
-    // version: 1.419.0-8232dcd0ab
+    // version: 1.421.0-45320a2742
 
     /*!
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -101423,7 +101620,7 @@
             lazyObjectInfoService = new ObjectInfoService(getObjectInfo, getObjectInfos, getObjectInfoDirectory, lazyDurableStore);
             const baseEnv = new Environment(store, lazyNetworkAdapter);
             const shouldFilterFieldsOnRevive = (key) => {
-                if (reviveOnlyRequestedFields.isOpen({ fallback: false })) {
+                if (reviveOnlyRequestedFields.isOpen({ fallback: true })) {
                     return isStoreKeyRecordId(key);
                 }
                 return false;
@@ -101553,7 +101750,7 @@
         id: '@salesforce/lds-network-adapter',
         instrument: instrument$2,
     });
-    // version: 1.419.0-ade430921b
+    // version: 1.421.0-2828c95aef
 
     const { create: create$2, keys: keys$2 } = Object;
     const { stringify, parse } = JSON;
@@ -104198,6 +104395,7 @@
             return {
                 __typename: new BaseScalarFieldDef(false),
                 AnalyticsWorkspace: new BaseObjectFieldDef(this.typeRegistry.Analytics__AnalyticsWorkspace, true),
+                SourceOrgId: new BaseObjectFieldDef(this.typeRegistry.IDValue, true),
                 AssetUsageType: new BaseObjectFieldDef(this.typeRegistry.PicklistValue, true),
                 ActivePromotionRequestId: new BaseObjectFieldDef(this.typeRegistry.IDValue, true),
                 MetadataSourceType: new BaseObjectFieldDef(this.typeRegistry.PicklistValue, true),
@@ -104616,6 +104814,29 @@
         }
     }
 
+    class CanvasLayoutComponentRepository extends UnidentifiableGraphQLTypeRepository {
+        constructor(services, typeRegistry) {
+            super(services);
+            this.services = services;
+            this.typeRegistry = typeRegistry;
+            this.namespace = "oas";
+            this.typeName = "CanvasLayoutComponent";
+            this.implementedInterfaces = ["LayoutComponent"];
+        }
+        get fields() {
+            return {
+                __typename: new BaseScalarFieldDef(false),
+                apiName: new BaseScalarFieldDef(true),
+                componentType: new BaseScalarFieldDef(false),
+                displayLocation: new BaseScalarFieldDef(true),
+                height: new BaseScalarFieldDef(true),
+                referenceId: new BaseScalarFieldDef(true),
+                showScroll: new BaseScalarFieldDef(true),
+                width: new BaseScalarFieldDef(true),
+            };
+        }
+    }
+
     class ChildRelationshipRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
             super(services);
@@ -104741,6 +104962,27 @@
         }
     }
 
+    class CustomLinkLayoutComponentRepository extends UnidentifiableGraphQLTypeRepository {
+        constructor(services, typeRegistry) {
+            super(services);
+            this.services = services;
+            this.typeRegistry = typeRegistry;
+            this.namespace = "oas";
+            this.typeName = "CustomLinkLayoutComponent";
+            this.implementedInterfaces = ["LayoutComponent"];
+        }
+        get fields() {
+            return {
+                __typename: new BaseScalarFieldDef(false),
+                apiName: new BaseScalarFieldDef(true),
+                componentType: new BaseScalarFieldDef(false),
+                behavior: new BaseScalarFieldDef(true),
+                customLinkUrl: new BaseScalarFieldDef(true),
+                label: new BaseScalarFieldDef(true),
+            };
+        }
+    }
+
     class DateAggregateRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
             super(services);
@@ -104935,6 +105177,24 @@
         }
     }
 
+    class EmptySpaceLayoutComponentRepository extends UnidentifiableGraphQLTypeRepository {
+        constructor(services, typeRegistry) {
+            super(services);
+            this.services = services;
+            this.typeRegistry = typeRegistry;
+            this.namespace = "oas";
+            this.typeName = "EmptySpaceLayoutComponent";
+            this.implementedInterfaces = ["LayoutComponent"];
+        }
+        get fields() {
+            return {
+                __typename: new BaseScalarFieldDef(false),
+                apiName: new BaseScalarFieldDef(true),
+                componentType: new BaseScalarFieldDef(false),
+            };
+        }
+    }
+
     class EncryptedStringValueRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
             super(services);
@@ -104953,6 +105213,25 @@
         }
     }
 
+    class FieldLayoutComponentRepository extends UnidentifiableGraphQLTypeRepository {
+        constructor(services, typeRegistry) {
+            super(services);
+            this.services = services;
+            this.typeRegistry = typeRegistry;
+            this.namespace = "oas";
+            this.typeName = "FieldLayoutComponent";
+            this.implementedInterfaces = ["LayoutComponent"];
+        }
+        get fields() {
+            return {
+                __typename: new BaseScalarFieldDef(false),
+                apiName: new BaseScalarFieldDef(true),
+                componentType: new BaseScalarFieldDef(false),
+                label: new BaseScalarFieldDef(true),
+            };
+        }
+    }
+
     class FieldRepository extends BaseInterfaceRepository {
         constructor(services, typeRegistry) {
             super(services);
@@ -105169,6 +105448,189 @@
         }
     }
 
+    class LayoutComponentRepository extends BaseInterfaceRepository {
+        constructor(services, typeRegistry) {
+            super(services);
+            this.services = services;
+            this.typeRegistry = typeRegistry;
+            this.namespace = "oas";
+            this.typeName = "LayoutComponent";
+            this.implementedInterfaces = [];
+        }
+        get fields() {
+            return {
+                __typename: new BaseScalarFieldDef(false),
+                apiName: new BaseScalarFieldDef(true),
+                componentType: new BaseScalarFieldDef(false),
+            };
+        }
+        get possibleTypes() {
+            return {
+                FieldLayoutComponent: this.typeRegistry.FieldLayoutComponent,
+                VisualforceLayoutComponent: this.typeRegistry.VisualforceLayoutComponent,
+                CanvasLayoutComponent: this.typeRegistry.CanvasLayoutComponent,
+                CustomLinkLayoutComponent: this.typeRegistry.CustomLinkLayoutComponent,
+                ReportLayoutComponent: this.typeRegistry.ReportLayoutComponent,
+                EmptySpaceLayoutComponent: this.typeRegistry.EmptySpaceLayoutComponent,
+            };
+        }
+    }
+
+    class LayoutConnectionRepository extends UnidentifiableGraphQLTypeRepository {
+        constructor(services, typeRegistry) {
+            super(services);
+            this.services = services;
+            this.typeRegistry = typeRegistry;
+            this.namespace = "oas";
+            this.typeName = "LayoutConnection";
+            this.implementedInterfaces = [];
+        }
+        get fields() {
+            return {
+                __typename: new BaseScalarFieldDef(false),
+                edges: new BaseArrayFieldDef(new BaseObjectFieldDef(this.typeRegistry.LayoutEdge, true), true),
+                pageInfo: new BaseObjectFieldDef(this.typeRegistry.PageInfo, false),
+                totalCount: new BaseScalarFieldDef(true),
+            };
+        }
+    }
+
+    class LayoutEdgeRepository extends UnidentifiableGraphQLTypeRepository {
+        constructor(services, typeRegistry) {
+            super(services);
+            this.services = services;
+            this.typeRegistry = typeRegistry;
+            this.namespace = "oas";
+            this.typeName = "LayoutEdge";
+            this.implementedInterfaces = [];
+        }
+        get fields() {
+            return {
+                __typename: new BaseScalarFieldDef(false),
+                node: new BaseObjectFieldDef(this.typeRegistry.Layout, true),
+                cursor: new BaseScalarFieldDef(false),
+            };
+        }
+    }
+
+    class LayoutItemRepository extends UnidentifiableGraphQLTypeRepository {
+        constructor(services, typeRegistry) {
+            super(services);
+            this.services = services;
+            this.typeRegistry = typeRegistry;
+            this.namespace = "oas";
+            this.typeName = "LayoutItem";
+            this.implementedInterfaces = [];
+        }
+        get fields() {
+            return {
+                __typename: new BaseScalarFieldDef(false),
+                editableForNew: new BaseScalarFieldDef(false),
+                editableForUpdate: new BaseScalarFieldDef(false),
+                label: new BaseScalarFieldDef(false),
+                layoutComponents: new BaseArrayFieldDef(new BaseObjectFieldDef(this.typeRegistry.LayoutComponent, false), true),
+                lookupIdApiName: new BaseScalarFieldDef(true),
+                required: new BaseScalarFieldDef(false),
+                sortable: new BaseScalarFieldDef(false),
+                uiBehavior: new BaseScalarFieldDef(true),
+            };
+        }
+    }
+
+    class LayoutRepository extends IdentifiableGraphQLTypeRepository {
+        constructor(services, typeRegistry) {
+            super(services);
+            this.services = services;
+            this.typeRegistry = typeRegistry;
+            this.namespace = "oas";
+            this.typeName = "Layout";
+            this.implementedInterfaces = [];
+            this.idField = "id";
+        }
+        get fields() {
+            return {
+                __typename: new BaseScalarFieldDef(false),
+                id: new BaseScalarFieldDef(true),
+                layoutType: new BaseScalarFieldDef(true),
+                mode: new BaseScalarFieldDef(true),
+                objectApiName: new BaseScalarFieldDef(false),
+                recordTypeId: new BaseScalarFieldDef(true),
+                saveOptions: new BaseArrayFieldDef(new BaseObjectFieldDef(this.typeRegistry.LayoutSaveOption, false), true),
+                sections: new BaseArrayFieldDef(new BaseObjectFieldDef(this.typeRegistry.LayoutSection, false), true),
+            };
+        }
+        get cacheControl() {
+            return { type: "max-age", maxAge: 60 };
+        }
+    }
+
+    class LayoutRowRepository extends UnidentifiableGraphQLTypeRepository {
+        constructor(services, typeRegistry) {
+            super(services);
+            this.services = services;
+            this.typeRegistry = typeRegistry;
+            this.namespace = "oas";
+            this.typeName = "LayoutRow";
+            this.implementedInterfaces = [];
+        }
+        get fields() {
+            return {
+                __typename: new BaseScalarFieldDef(false),
+                layoutItems: new BaseArrayFieldDef(new BaseObjectFieldDef(this.typeRegistry.LayoutItem, false), true),
+            };
+        }
+    }
+
+    class LayoutSaveOptionRepository extends UnidentifiableGraphQLTypeRepository {
+        constructor(services, typeRegistry) {
+            super(services);
+            this.services = services;
+            this.typeRegistry = typeRegistry;
+            this.namespace = "oas";
+            this.typeName = "LayoutSaveOption";
+            this.implementedInterfaces = [];
+        }
+        get fields() {
+            return {
+                __typename: new BaseScalarFieldDef(false),
+                defaultValue: new BaseScalarFieldDef(false),
+                isDisplayed: new BaseScalarFieldDef(false),
+                label: new BaseScalarFieldDef(false),
+                name: new BaseScalarFieldDef(false),
+                restHeaderName: new BaseScalarFieldDef(true),
+                soapHeaderName: new BaseScalarFieldDef(true),
+            };
+        }
+    }
+
+    class LayoutSectionRepository extends IdentifiableGraphQLTypeRepository {
+        constructor(services, typeRegistry) {
+            super(services);
+            this.services = services;
+            this.typeRegistry = typeRegistry;
+            this.namespace = "oas";
+            this.typeName = "LayoutSection";
+            this.implementedInterfaces = [];
+            this.idField = "id";
+        }
+        get fields() {
+            return {
+                __typename: new BaseScalarFieldDef(false),
+                collapsible: new BaseScalarFieldDef(false),
+                columns: new BaseScalarFieldDef(false),
+                heading: new BaseScalarFieldDef(true),
+                id: new BaseScalarFieldDef(true),
+                layoutRows: new BaseArrayFieldDef(new BaseObjectFieldDef(this.typeRegistry.LayoutRow, false), true),
+                rows: new BaseScalarFieldDef(false),
+                tabOrder: new BaseScalarFieldDef(true),
+                useHeading: new BaseScalarFieldDef(false),
+            };
+        }
+        get cacheControl() {
+            return { type: "max-age", maxAge: 60 };
+        }
+    }
+
     class ListColumnRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
             super(services);
@@ -105530,7 +105992,6 @@
         get fields() {
             return {
                 __typename: new BaseScalarFieldDef(false),
-                picklistAtrributesValueType: new BaseScalarFieldDef(true),
                 connectDisplayName: new BaseScalarFieldDef(true),
                 internalName: new BaseScalarFieldDef(true),
             };
@@ -106045,6 +106506,32 @@
         }
     }
 
+    class ReportLayoutComponentRepository extends UnidentifiableGraphQLTypeRepository {
+        constructor(services, typeRegistry) {
+            super(services);
+            this.services = services;
+            this.typeRegistry = typeRegistry;
+            this.namespace = "oas";
+            this.typeName = "ReportLayoutComponent";
+            this.implementedInterfaces = ["LayoutComponent"];
+        }
+        get fields() {
+            return {
+                __typename: new BaseScalarFieldDef(false),
+                apiName: new BaseScalarFieldDef(true),
+                componentType: new BaseScalarFieldDef(false),
+                cacheData: new BaseScalarFieldDef(true),
+                error: new BaseScalarFieldDef(true),
+                filter: new BaseScalarFieldDef(true),
+                hideOnError: new BaseScalarFieldDef(true),
+                placeholder: new BaseScalarFieldDef(true),
+                reportId: new BaseScalarFieldDef(true),
+                showTitle: new BaseScalarFieldDef(true),
+                size: new BaseScalarFieldDef(true),
+            };
+        }
+    }
+
     class RichTextAreaValueRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
             super(services);
@@ -106155,6 +106642,7 @@
                 allowedOperators: new BaseArrayFieldDef(new BaseScalarFieldDef(false), true),
                 sortable: new BaseScalarFieldDef(true),
                 lookupIdColumn: new BaseScalarFieldDef(true),
+                inlineEditAttributes: new BaseObjectFieldDef(this.typeRegistry.Setup__ListInlineEditAttributes, true),
             };
         }
     }
@@ -106179,6 +106667,44 @@
         }
     }
 
+    class Setup__ListInlineEditAttributeDetailsRepository extends UnidentifiableGraphQLTypeRepository {
+        constructor(services, typeRegistry) {
+            super(services);
+            this.services = services;
+            this.typeRegistry = typeRegistry;
+            this.namespace = "oas";
+            this.typeName = "Setup__ListInlineEditAttributeDetails";
+            this.implementedInterfaces = [];
+        }
+        get fields() {
+            return {
+                __typename: new BaseScalarFieldDef(false),
+                recordTypeId: new BaseScalarFieldDef(false),
+                editable: new BaseScalarFieldDef(false),
+                required: new BaseScalarFieldDef(false),
+            };
+        }
+    }
+
+    class Setup__ListInlineEditAttributesRepository extends UnidentifiableGraphQLTypeRepository {
+        constructor(services, typeRegistry) {
+            super(services);
+            this.services = services;
+            this.typeRegistry = typeRegistry;
+            this.namespace = "oas";
+            this.typeName = "Setup__ListInlineEditAttributes";
+            this.implementedInterfaces = [];
+        }
+        get fields() {
+            return {
+                __typename: new BaseScalarFieldDef(false),
+                objectApiName: new BaseScalarFieldDef(true),
+                fieldApiName: new BaseScalarFieldDef(true),
+                attributes: new BaseArrayFieldDef(new BaseObjectFieldDef(this.typeRegistry.Setup__ListInlineEditAttributeDetails, true), true),
+            };
+        }
+    }
+
     class Setup__ListOrderRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
             super(services);
@@ -106250,6 +106776,7 @@
             return {
                 __typename: new BaseScalarFieldDef(false),
                 listViewType: new BaseScalarFieldDef(false),
+                isInlineEditable: new BaseScalarFieldDef(true),
                 label: new BaseScalarFieldDef(true),
                 displayColumns: new BaseArrayFieldDef(new BaseObjectFieldDef(this.typeRegistry.Setup__ListColumn, false), false),
                 filters: new BaseArrayFieldDef(new BaseObjectFieldDef(this.typeRegistry.Setup__ListFilter, false), true),
@@ -106764,6 +107291,8 @@
                 aggregate: new BaseObjectFieldDef(this.typeRegistry.RecordQueryAggregate, false),
                 objectInfos: new BaseArrayFieldDef(new BaseObjectFieldDef(this.typeRegistry.ObjectInfo, true), true),
                 relatedListByName: new BaseObjectFieldDef(this.typeRegistry.RelatedListInfo, true),
+                currentUser: new BaseObjectFieldDef(this.typeRegistry.RecordRepresentation, true),
+                recordLayouts: new BaseObjectFieldDef(this.typeRegistry.LayoutConnection, true),
             };
         }
     }
@@ -106809,6 +107338,29 @@
         }
     }
 
+    class VisualforceLayoutComponentRepository extends UnidentifiableGraphQLTypeRepository {
+        constructor(services, typeRegistry) {
+            super(services);
+            this.services = services;
+            this.typeRegistry = typeRegistry;
+            this.namespace = "oas";
+            this.typeName = "VisualforceLayoutComponent";
+            this.implementedInterfaces = ["LayoutComponent"];
+        }
+        get fields() {
+            return {
+                __typename: new BaseScalarFieldDef(false),
+                apiName: new BaseScalarFieldDef(true),
+                componentType: new BaseScalarFieldDef(false),
+                height: new BaseScalarFieldDef(true),
+                showLabel: new BaseScalarFieldDef(true),
+                showScroll: new BaseScalarFieldDef(true),
+                visualforceUrl: new BaseScalarFieldDef(true),
+                width: new BaseScalarFieldDef(true),
+            };
+        }
+    }
+
     class GraphQLTypeRegistry {
         constructor(services) {
             this.services = services;
@@ -106911,6 +107463,28 @@
             this._ListColumn = new ListColumnRepository(this.services, this);
             this._ListOrder = new ListOrderRepository(this.services, this);
             this._RelatedListInfo = new RelatedListInfoRepository(this.services, this);
+            this._LayoutSaveOption =
+                new LayoutSaveOptionRepository(this.services, this);
+            this._FieldLayoutComponent =
+                new FieldLayoutComponentRepository(this.services, this);
+            this._VisualforceLayoutComponent =
+                new VisualforceLayoutComponentRepository(this.services, this);
+            this._CanvasLayoutComponent =
+                new CanvasLayoutComponentRepository(this.services, this);
+            this._CustomLinkLayoutComponent =
+                new CustomLinkLayoutComponentRepository(this.services, this);
+            this._ReportLayoutComponent =
+                new ReportLayoutComponentRepository(this.services, this);
+            this._EmptySpaceLayoutComponent =
+                new EmptySpaceLayoutComponentRepository(this.services, this);
+            this._LayoutComponent = new LayoutComponentRepository(this.services, this);
+            this._LayoutItem = new LayoutItemRepository(this.services, this);
+            this._LayoutRow = new LayoutRowRepository(this.services, this);
+            this._LayoutSection = new LayoutSectionRepository(this.services, this);
+            this._Layout = new LayoutRepository(this.services, this);
+            this._LayoutEdge = new LayoutEdgeRepository(this.services, this);
+            this._LayoutConnection =
+                new LayoutConnectionRepository(this.services, this);
             this._UIAPI = new UIAPIRepository(this.services, this);
             this._SObject__Field = new SObject__FieldRepository(this.services, this);
             this._Setup__SetupPolymorphicParentRelationship =
@@ -106935,6 +107509,10 @@
                 new Setup__SetupAggregateConnectionRepository(this.services, this);
             this._Setup__SetupQueryAggregate =
                 new Setup__SetupQueryAggregateRepository(this.services, this);
+            this._Setup__ListInlineEditAttributeDetails =
+                new Setup__ListInlineEditAttributeDetailsRepository(this.services, this);
+            this._Setup__ListInlineEditAttributes =
+                new Setup__ListInlineEditAttributesRepository(this.services, this);
             this._Setup__ListColumn =
                 new Setup__ListColumnRepository(this.services, this);
             this._Setup__ListFilter =
@@ -107222,6 +107800,48 @@
         get RelatedListInfo() {
             return this._RelatedListInfo;
         }
+        get LayoutSaveOption() {
+            return this._LayoutSaveOption;
+        }
+        get FieldLayoutComponent() {
+            return this._FieldLayoutComponent;
+        }
+        get VisualforceLayoutComponent() {
+            return this._VisualforceLayoutComponent;
+        }
+        get CanvasLayoutComponent() {
+            return this._CanvasLayoutComponent;
+        }
+        get CustomLinkLayoutComponent() {
+            return this._CustomLinkLayoutComponent;
+        }
+        get ReportLayoutComponent() {
+            return this._ReportLayoutComponent;
+        }
+        get EmptySpaceLayoutComponent() {
+            return this._EmptySpaceLayoutComponent;
+        }
+        get LayoutComponent() {
+            return this._LayoutComponent;
+        }
+        get LayoutItem() {
+            return this._LayoutItem;
+        }
+        get LayoutRow() {
+            return this._LayoutRow;
+        }
+        get LayoutSection() {
+            return this._LayoutSection;
+        }
+        get Layout() {
+            return this._Layout;
+        }
+        get LayoutEdge() {
+            return this._LayoutEdge;
+        }
+        get LayoutConnection() {
+            return this._LayoutConnection;
+        }
         get UIAPI() {
             return this._UIAPI;
         }
@@ -107261,6 +107881,12 @@
         get Setup__SetupQueryAggregate() {
             return this._Setup__SetupQueryAggregate;
         }
+        get Setup__ListInlineEditAttributeDetails() {
+            return this._Setup__ListInlineEditAttributeDetails;
+        }
+        get Setup__ListInlineEditAttributes() {
+            return this._Setup__ListInlineEditAttributes;
+        }
         get Setup__ListColumn() {
             return this._Setup__ListColumn;
         }
@@ -109049,15 +109675,16 @@
             _(config, CONFIG_SCHEMA);
             return new graphql_imperative_ctor(config, documentRootType, services);
         });
-        graphql_imperative_legacy_v1_import = services.graphQLLegacyImperativeBindings.bind(({ config, assertIsValid }) => {
-            const validatedConfig = validateNonQueryGraphQLConfig(config);
-            if (validatedConfig.isErr()) {
-                throw new Error(`Invalid configuration passed to GraphQL: ${validatedConfig.error}`);
-            }
-            const _ = assertIsValid;
-            _(validatedConfig.value, CONFIG_SCHEMA);
-            return new graphql_imperative_ctor(validatedConfig.value, documentRootType, services);
-        });
+        graphql_imperative_legacy_v1_import =
+            services.graphQLLegacyImperativeBindings.bind(({ config, assertIsValid }) => {
+                const validatedConfig = validateNonQueryGraphQLConfig(config);
+                if (validatedConfig.isErr()) {
+                    throw new Error(`Invalid configuration passed to GraphQL: ${validatedConfig.error}`);
+                }
+                const _ = assertIsValid;
+                _(validatedConfig.value, CONFIG_SCHEMA);
+                return new graphql_imperative_ctor(validatedConfig.value, documentRootType, services);
+            });
         /*
          * State Manager
          */
@@ -109095,7 +109722,7 @@
             cb(graphql_v1_import, graphql_imperative$1, graphql_imperative_legacy_v1_import, graphql_state_manager, useOneStoreGraphQL);
         }
     }
-    // version: 1.419.0-8232dcd0ab
+    // version: 1.421.0-45320a2742
 
     function createFragmentMap(documentNode) {
         const fragments = {};
@@ -138320,7 +138947,7 @@
         configuration: { ...configurationForGraphQLAdapters$1 },
         instrument: instrument$1,
     });
-    // version: 1.419.0-8232dcd0ab
+    // version: 1.421.0-45320a2742
 
     // On core the unstable adapters are re-exported with different names,
     // we want to match them here.
@@ -138472,7 +139099,7 @@
         unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
         graphQLImperative = ldsAdapter;
     });
-    // version: 1.419.0-8232dcd0ab
+    // version: 1.421.0-45320a2742
 
     var gqlApi = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -139271,7 +139898,7 @@
     function register(r) {
         callbacks$1.forEach((callback) => callback(r));
     }
-    // version: 1.419.0-ade430921b
+    // version: 1.421.0-2828c95aef
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -140608,4 +141235,4 @@
     exports.subscribeToAdapter = subscribeToAdapter;
 
 }));
-// version: 1.419.0-ade430921b
+// version: 1.421.0-2828c95aef