@salesforce/lds-worker-api 1.428.0-dev1 → 1.428.0-dev11

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

@@ -4280,7 +4280,7 @@
         }
         callbacks.push(callback);
     }
-    // version: 1.428.0-dev1-c95a813572
+    // version: 1.428.0-dev11-b4d8cf1aec
 
     // 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.428.0-dev1-c95a813572
+    // version: 1.428.0-dev11-b4d8cf1aec
 
     function isSupportedEntity(_objectApiName) {
         return true;
@@ -32616,7 +32616,7 @@
         throttle(60, 60000, setupNotifyAllListRecordUpdateAvailable(luvio));
         throttle(60, 60000, setupNotifyAllListInfoSummaryUpdateAvailable(luvio));
     });
-    // version: 1.428.0-dev1-52205c6c54
+    // version: 1.428.0-dev11-659d2de2fa
 
     var allowUpdatesForNonCachedRecords = {
         isOpen: function (e) {
@@ -95118,6 +95118,7 @@
       constructor(services) {
         super(services);
         this.services = services;
+        this.additionalNullResponses = [];
       }
       fetch() {
         try {
@@ -95126,6 +95127,15 @@
           return resolvedPromiseLike$2(err$1(toError(reason)));
         }
       }
+      isSemanticNullResponse(response) {
+        return this.additionalNullResponses.includes(response.status);
+      }
+      isProtocolNoBodyStatus(status) {
+        return status === 204 || status === 205;
+      }
+      isUndeclaredNoBodyResponse(response) {
+        return this.isProtocolNoBodyStatus(response.status) && !this.isSemanticNullResponse(response);
+      }
       async coerceError(errorResponse) {
         return toError(errorResponse.statusText);
       }
@@ -95133,10 +95143,24 @@
         return response.then(
           (response2) => {
             if (response2.ok) {
-              return response2.json().then(
-                (json) => ok$1(json),
-                (reason) => err$1(toError(reason))
-              ).finally(() => {
+              let resultPromise;
+              if (this.isSemanticNullResponse(response2)) {
+                resultPromise = Promise.resolve(ok$1(null));
+              } else if (this.isUndeclaredNoBodyResponse(response2)) {
+                resultPromise = Promise.resolve(
+                  err$1(
+                    toError(
+                      `Unexpected ${response2.status} response: no-content status was not declared in the API specification. Declare this response in your OAS without a content property.`
+                    )
+                  )
+                );
+              } else {
+                resultPromise = response2.json().then(
+                  (json) => ok$1(json),
+                  (reason) => err$1(toError(reason))
+                );
+              }
+              return resultPromise.finally(() => {
                 try {
                   this.afterRequestHooks({ statusCode: response2.status });
                 } catch {
@@ -95183,6 +95207,7 @@
       constructor(services) {
         super(services);
         this.services = services;
+        this.additionalNullResponses = [];
       }
       requestFromNetwork() {
         return this.fetch();
@@ -95194,6 +95219,15 @@
           return resolvedPromiseLike$2(err$1(toError(reason)));
         }
       }
+      isSemanticNullResponse(response) {
+        return this.additionalNullResponses.includes(response.status);
+      }
+      isProtocolNoBodyStatus(status) {
+        return status === 204 || status === 205;
+      }
+      isUndeclaredNoBodyResponse(response) {
+        return this.isProtocolNoBodyStatus(response.status) && !this.isSemanticNullResponse(response);
+      }
       async coerceError(errorResponse) {
         return toError(errorResponse.statusText);
       }
@@ -95204,12 +95238,26 @@
         return response.then(
           (response2) => {
             if (response2.ok) {
-              return response2.json().then(
-                (json) => {
-                  return this.processFetchReturnValue(json);
-                },
-                (reason) => err$1(toError(reason))
-              ).finally(() => {
+              let resultPromise;
+              if (this.isSemanticNullResponse(response2)) {
+                resultPromise = Promise.resolve(ok$1(null));
+              } else if (this.isUndeclaredNoBodyResponse(response2)) {
+                resultPromise = Promise.resolve(
+                  err$1(
+                    toError(
+                      `Unexpected ${response2.status} response: no-content status was not declared in the API specification. Declare this response in your OAS without a content property.`
+                    )
+                  )
+                );
+              } else {
+                resultPromise = response2.json().then(
+                  (json) => {
+                    return this.processFetchReturnValue(json);
+                  },
+                  (reason) => err$1(toError(reason))
+                );
+              }
+              return resultPromise.finally(() => {
                 try {
                   this.afterRequestHooks({ statusCode: response2.status });
                 } catch {
@@ -96197,7 +96245,7 @@
             },
         };
     }
-    // version: 1.428.0-dev1-52205c6c54
+    // version: 1.428.0-dev11-659d2de2fa
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -96223,7 +96271,7 @@
             },
         };
     }
-    // version: 1.428.0-dev1-52205c6c54
+    // version: 1.428.0-dev11-659d2de2fa
 
     /*!
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -96708,6 +96756,9 @@
       return err$1([error]);
     }
     function validateJsonSchema$1(data, schema, path = "$", document = schema) {
+      return validateJsonSchemaInternal$1(data, schema, path, document, /* @__PURE__ */ new Map());
+    }
+    function validateJsonSchemaInternal$1(data, schema, path, document, visited) {
       if (schema === true) return validSchemaResponse$1();
       if (schema === false)
         return invalidSchemaResponseWithError$1(
@@ -96716,22 +96767,22 @@
       const dataType = data === null ? "null" : Array.isArray(data) ? "array" : typeof data;
       const errorCollector = new JsonSchemaErrorCollector$1();
       if ("anyOf" in schema) {
-        errorCollector.append(validateAnyOf$1(data, schema, path, document));
+        errorCollector.append(validateAnyOf$1(data, schema, path, document, visited));
       } else if ("oneOf" in schema) {
-        errorCollector.append(validateOneOf$1(data, schema, path, document));
+        errorCollector.append(validateOneOf$1(data, schema, path, document, visited));
       } else if ("allOf" in schema) {
-        errorCollector.append(validateAllOf$1(data, schema, path, document));
+        errorCollector.append(validateAllOf$1(data, schema, path, document, visited));
       } else if ("not" in schema) {
-        errorCollector.append(validateNot$1(data, schema, path, document));
+        errorCollector.append(validateNot$1(data, schema, path, document, visited));
       } else if ("$ref" in schema) {
-        errorCollector.append(validateRef$1(data, schema, path, document));
+        errorCollector.append(validateRef$1(data, schema, path, document, visited));
       } else if ("type" in schema) {
         if (schema.type === "object") {
           if (dataType !== "object") {
             errorCollector.add(incorrectTypeError$1("object", dataType, path));
           } else {
             errorCollector.append(
-              validateObject$1(data, schema, path, document)
+              validateObject$1(data, schema, path, document, visited)
             );
           }
         } else if (schema.type === "array") {
@@ -96739,7 +96790,7 @@
             errorCollector.add(incorrectTypeError$1("array", dataType, path));
           } else {
             errorCollector.append(
-              validateArray$1(data, schema, path, document)
+              validateArray$1(data, schema, path, document, visited)
             );
           }
         } else {
@@ -96756,16 +96807,17 @@
       }
       return errorCollector.toValidationResponse();
     }
-    function validateAnyOf$1(data, schema, path, document) {
+    function validateAnyOf$1(data, schema, path, document, visited) {
       let isValid = false;
       const errorCollector = new JsonSchemaErrorCollector$1();
       for (let i = 0, { length } = schema.anyOf; i < length; i++) {
         const element = schema.anyOf[i];
-        const validationResponse = validateJsonSchema$1(
+        const validationResponse = validateJsonSchemaInternal$1(
           data,
           element,
           `${path}.anyOf[${i}]`,
-          document
+          document,
+          visited
         );
         if (validationResponse.isOk()) {
           isValid = true;
@@ -96782,13 +96834,22 @@
       }
       return validSchemaResponse$1();
     }
-    function validateOneOf$1(data, schema, path, document) {
+    function validateOneOf$1(data, schema, path, document, visited) {
+      if (schema.discriminator !== void 0) {
+        return validateDiscriminatedOneOf$1(data, schema.discriminator, path, document, visited);
+      }
       let validSubShemaPaths = [];
       const errorCollector = new JsonSchemaErrorCollector$1();
       for (let i = 0, { length } = schema.oneOf; i < length; i++) {
         const element = schema.oneOf[i];
         const oneOfPath = `${path}.oneOf[${i}]`;
-        const validationResponse = validateJsonSchema$1(data, element, oneOfPath, document);
+        const validationResponse = validateJsonSchemaInternal$1(
+          data,
+          element,
+          oneOfPath,
+          document,
+          visited
+        );
         if (validationResponse.isOk()) {
           validSubShemaPaths.push(oneOfPath);
         } else {
@@ -96810,16 +96871,45 @@
       }
       return validSchemaResponse$1();
     }
-    function validateAllOf$1(data, schema, path, document) {
+    function validateDiscriminatedOneOf$1(data, discriminator, path, document, visited) {
+      if (data === null || typeof data !== "object" || Array.isArray(data)) {
+        return invalidSchemaResponseWithError$1(incorrectTypeError$1("object", typeof data, path));
+      }
+      const { propertyName, mapping } = discriminator;
+      const discriminatorValue = data[propertyName];
+      if (discriminatorValue === void 0) {
+        return invalidSchemaResponseWithError$1(
+          new MissingRequiredPropertyError$1(
+            `Object at path '${path}' is missing required discriminator property '${propertyName}'.`
+          )
+        );
+      }
+      if (typeof discriminatorValue !== "string") {
+        return invalidSchemaResponseWithError$1(
+          incorrectTypeError$1("string", typeof discriminatorValue, `${path}.${propertyName}`)
+        );
+      }
+      const targetRef = mapping[discriminatorValue];
+      if (targetRef === void 0) {
+        return invalidSchemaResponseWithError$1(
+          new JsonSchemaViolationError$1(
+            `Discriminator value '${discriminatorValue}' at '${path}.${propertyName}' is not in the mapping. Expected one of: [${Object.keys(mapping).join(", ")}].`
+          )
+        );
+      }
+      return validateJsonSchemaInternal$1(data, { $ref: targetRef }, path, document, visited);
+    }
+    function validateAllOf$1(data, schema, path, document, visited) {
       let isValid = true;
       const errorCollector = new JsonSchemaErrorCollector$1();
       for (let i = 0, { length } = schema.allOf; i < length; i++) {
         const element = schema.allOf[i];
-        const validationResponse = validateJsonSchema$1(
+        const validationResponse = validateJsonSchemaInternal$1(
           data,
           element,
           `${path}.allOf[${i}]`,
-          document
+          document,
+          visited
         );
         if (!validationResponse.isOk()) {
           errorCollector.append(validationResponse);
@@ -96833,8 +96923,14 @@
       }
       return errorCollector.toValidationResponse();
     }
-    function validateNot$1(data, schema, path, document) {
-      const validationResponse = validateJsonSchema$1(data, schema.not, path, document);
+    function validateNot$1(data, schema, path, document, visited) {
+      const validationResponse = validateJsonSchemaInternal$1(
+        data,
+        schema.not,
+        path,
+        document,
+        visited
+      );
       if (validationResponse.isOk()) {
         return invalidSchemaResponseWithError$1(
           new JsonSchemaViolationError$1(
@@ -96844,7 +96940,7 @@
       }
       return validSchemaResponse$1();
     }
-    function validateObject$1(data, schema, path, document) {
+    function validateObject$1(data, schema, path, document, visited) {
       const schemaKeys = Object.keys(schema.properties);
       const requiredKeys = new Set(schema.required);
       const schemaKeySet = new Set(schemaKeys);
@@ -96852,11 +96948,12 @@
       Object.keys(data).forEach((key) => {
         if (!schemaKeySet.has(key)) {
           errorCollector.append(
-            validateJsonSchema$1(
+            validateJsonSchemaInternal$1(
               data[key],
               schema.additionalProperties,
               `${path}.additionalProperties[${key}]`,
-              document
+              document,
+              visited
             )
           );
         }
@@ -96873,18 +96970,19 @@
         }
         if (keyInData) {
           errorCollector.append(
-            validateJsonSchema$1(
+            validateJsonSchemaInternal$1(
               data[key],
               schema.properties[key],
               `${path}.${key}`,
-              document
+              document,
+              visited
             )
           );
         }
       }
       return errorCollector.toValidationResponse();
     }
-    function validateArray$1(data, schema, path, document) {
+    function validateArray$1(data, schema, path, document, visited) {
       if (schema.minItems !== void 0 && data.length < schema.minItems) {
         return invalidSchemaResponseWithError$1(
           new MinItemsViolationError$1(
@@ -96902,7 +97000,13 @@
       const errorCollector = new JsonSchemaErrorCollector$1();
       data.forEach(
         (element, index) => errorCollector.append(
-          validateJsonSchema$1(element, schema.items, `${path}[${index}]`, document)
+          validateJsonSchemaInternal$1(
+            element,
+            schema.items,
+            `${path}[${index}]`,
+            document,
+            visited
+          )
         )
       );
       return errorCollector.toValidationResponse();
@@ -96937,7 +97041,7 @@
       }
       return validSchemaResponse$1();
     }
-    function validateRef$1(data, schema, path, document) {
+    function validateRef$1(data, schema, path, document, visited) {
       if (!schema.$ref.startsWith("#")) {
         return invalidSchemaResponseWithError$1(
           new InvalidRefError$1(
@@ -96945,11 +97049,23 @@
           )
         );
       }
+      let refsForData = visited.get(data);
+      if (refsForData !== void 0 && refsForData.has(schema.$ref)) {
+        return validSchemaResponse$1();
+      }
+      if (refsForData === void 0) {
+        refsForData = /* @__PURE__ */ new Set();
+        visited.set(data, refsForData);
+      }
+      refsForData.add(schema.$ref);
       try {
         const schemaToValidate = findSchemaAtPath$1(document, schema.$ref);
-        return validateJsonSchema$1(data, schemaToValidate, path, document);
+        return validateJsonSchemaInternal$1(data, schemaToValidate, path, document, visited);
       } catch (e) {
         return invalidSchemaResponseWithError$1(e);
+      } finally {
+        refsForData.delete(schema.$ref);
+        if (refsForData.size === 0) visited.delete(data);
       }
     }
     function validateEnum$1(data, enumValue, path) {
@@ -98880,7 +98996,7 @@
         id: '@salesforce/lds-network-adapter',
         instrument: instrument$2,
     });
-    // version: 1.428.0-dev1-c95a813572
+    // version: 1.428.0-dev11-b4d8cf1aec
 
     const { create: create$2, keys: keys$2 } = Object;
     const { stringify, parse } = JSON;
@@ -98971,6 +99087,9 @@
       return err$4([error]);
     }
     function validateJsonSchema(data, schema, path = "$", document = schema) {
+      return validateJsonSchemaInternal(data, schema, path, document, /* @__PURE__ */ new Map());
+    }
+    function validateJsonSchemaInternal(data, schema, path, document, visited) {
       if (schema === true) return validSchemaResponse();
       if (schema === false)
         return invalidSchemaResponseWithError(
@@ -98979,22 +99098,22 @@
       const dataType = data === null ? "null" : Array.isArray(data) ? "array" : typeof data;
       const errorCollector = new JsonSchemaErrorCollector();
       if ("anyOf" in schema) {
-        errorCollector.append(validateAnyOf(data, schema, path, document));
+        errorCollector.append(validateAnyOf(data, schema, path, document, visited));
       } else if ("oneOf" in schema) {
-        errorCollector.append(validateOneOf(data, schema, path, document));
+        errorCollector.append(validateOneOf(data, schema, path, document, visited));
       } else if ("allOf" in schema) {
-        errorCollector.append(validateAllOf(data, schema, path, document));
+        errorCollector.append(validateAllOf(data, schema, path, document, visited));
       } else if ("not" in schema) {
-        errorCollector.append(validateNot(data, schema, path, document));
+        errorCollector.append(validateNot(data, schema, path, document, visited));
       } else if ("$ref" in schema) {
-        errorCollector.append(validateRef(data, schema, path, document));
+        errorCollector.append(validateRef(data, schema, path, document, visited));
       } else if ("type" in schema) {
         if (schema.type === "object") {
           if (dataType !== "object") {
             errorCollector.add(incorrectTypeError("object", dataType, path));
           } else {
             errorCollector.append(
-              validateObject(data, schema, path, document)
+              validateObject(data, schema, path, document, visited)
             );
           }
         } else if (schema.type === "array") {
@@ -99002,7 +99121,7 @@
             errorCollector.add(incorrectTypeError("array", dataType, path));
           } else {
             errorCollector.append(
-              validateArray(data, schema, path, document)
+              validateArray(data, schema, path, document, visited)
             );
           }
         } else {
@@ -99019,16 +99138,17 @@
       }
       return errorCollector.toValidationResponse();
     }
-    function validateAnyOf(data, schema, path, document) {
+    function validateAnyOf(data, schema, path, document, visited) {
       let isValid = false;
       const errorCollector = new JsonSchemaErrorCollector();
       for (let i = 0, { length } = schema.anyOf; i < length; i++) {
         const element = schema.anyOf[i];
-        const validationResponse = validateJsonSchema(
+        const validationResponse = validateJsonSchemaInternal(
           data,
           element,
           `${path}.anyOf[${i}]`,
-          document
+          document,
+          visited
         );
         if (validationResponse.isOk()) {
           isValid = true;
@@ -99045,13 +99165,22 @@
       }
       return validSchemaResponse();
     }
-    function validateOneOf(data, schema, path, document) {
+    function validateOneOf(data, schema, path, document, visited) {
+      if (schema.discriminator !== void 0) {
+        return validateDiscriminatedOneOf(data, schema.discriminator, path, document, visited);
+      }
       let validSubShemaPaths = [];
       const errorCollector = new JsonSchemaErrorCollector();
       for (let i = 0, { length } = schema.oneOf; i < length; i++) {
         const element = schema.oneOf[i];
         const oneOfPath = `${path}.oneOf[${i}]`;
-        const validationResponse = validateJsonSchema(data, element, oneOfPath, document);
+        const validationResponse = validateJsonSchemaInternal(
+          data,
+          element,
+          oneOfPath,
+          document,
+          visited
+        );
         if (validationResponse.isOk()) {
           validSubShemaPaths.push(oneOfPath);
         } else {
@@ -99073,16 +99202,45 @@
       }
       return validSchemaResponse();
     }
-    function validateAllOf(data, schema, path, document) {
+    function validateDiscriminatedOneOf(data, discriminator, path, document, visited) {
+      if (data === null || typeof data !== "object" || Array.isArray(data)) {
+        return invalidSchemaResponseWithError(incorrectTypeError("object", typeof data, path));
+      }
+      const { propertyName, mapping } = discriminator;
+      const discriminatorValue = data[propertyName];
+      if (discriminatorValue === void 0) {
+        return invalidSchemaResponseWithError(
+          new MissingRequiredPropertyError(
+            `Object at path '${path}' is missing required discriminator property '${propertyName}'.`
+          )
+        );
+      }
+      if (typeof discriminatorValue !== "string") {
+        return invalidSchemaResponseWithError(
+          incorrectTypeError("string", typeof discriminatorValue, `${path}.${propertyName}`)
+        );
+      }
+      const targetRef = mapping[discriminatorValue];
+      if (targetRef === void 0) {
+        return invalidSchemaResponseWithError(
+          new JsonSchemaViolationError(
+            `Discriminator value '${discriminatorValue}' at '${path}.${propertyName}' is not in the mapping. Expected one of: [${Object.keys(mapping).join(", ")}].`
+          )
+        );
+      }
+      return validateJsonSchemaInternal(data, { $ref: targetRef }, path, document, visited);
+    }
+    function validateAllOf(data, schema, path, document, visited) {
       let isValid = true;
       const errorCollector = new JsonSchemaErrorCollector();
       for (let i = 0, { length } = schema.allOf; i < length; i++) {
         const element = schema.allOf[i];
-        const validationResponse = validateJsonSchema(
+        const validationResponse = validateJsonSchemaInternal(
           data,
           element,
           `${path}.allOf[${i}]`,
-          document
+          document,
+          visited
         );
         if (!validationResponse.isOk()) {
           errorCollector.append(validationResponse);
@@ -99096,8 +99254,14 @@
       }
       return errorCollector.toValidationResponse();
     }
-    function validateNot(data, schema, path, document) {
-      const validationResponse = validateJsonSchema(data, schema.not, path, document);
+    function validateNot(data, schema, path, document, visited) {
+      const validationResponse = validateJsonSchemaInternal(
+        data,
+        schema.not,
+        path,
+        document,
+        visited
+      );
       if (validationResponse.isOk()) {
         return invalidSchemaResponseWithError(
           new JsonSchemaViolationError(
@@ -99107,7 +99271,7 @@
       }
       return validSchemaResponse();
     }
-    function validateObject(data, schema, path, document) {
+    function validateObject(data, schema, path, document, visited) {
       const schemaKeys = Object.keys(schema.properties);
       const requiredKeys = new Set(schema.required);
       const schemaKeySet = new Set(schemaKeys);
@@ -99115,11 +99279,12 @@
       Object.keys(data).forEach((key) => {
         if (!schemaKeySet.has(key)) {
           errorCollector.append(
-            validateJsonSchema(
+            validateJsonSchemaInternal(
               data[key],
               schema.additionalProperties,
               `${path}.additionalProperties[${key}]`,
-              document
+              document,
+              visited
             )
           );
         }
@@ -99136,18 +99301,19 @@
         }
         if (keyInData) {
           errorCollector.append(
-            validateJsonSchema(
+            validateJsonSchemaInternal(
               data[key],
               schema.properties[key],
               `${path}.${key}`,
-              document
+              document,
+              visited
             )
           );
         }
       }
       return errorCollector.toValidationResponse();
     }
-    function validateArray(data, schema, path, document) {
+    function validateArray(data, schema, path, document, visited) {
       if (schema.minItems !== void 0 && data.length < schema.minItems) {
         return invalidSchemaResponseWithError(
           new MinItemsViolationError(
@@ -99165,7 +99331,13 @@
       const errorCollector = new JsonSchemaErrorCollector();
       data.forEach(
         (element, index) => errorCollector.append(
-          validateJsonSchema(element, schema.items, `${path}[${index}]`, document)
+          validateJsonSchemaInternal(
+            element,
+            schema.items,
+            `${path}[${index}]`,
+            document,
+            visited
+          )
         )
       );
       return errorCollector.toValidationResponse();
@@ -99200,7 +99372,7 @@
       }
       return validSchemaResponse();
     }
-    function validateRef(data, schema, path, document) {
+    function validateRef(data, schema, path, document, visited) {
       if (!schema.$ref.startsWith("#")) {
         return invalidSchemaResponseWithError(
           new InvalidRefError(
@@ -99208,11 +99380,23 @@
           )
         );
       }
+      let refsForData = visited.get(data);
+      if (refsForData !== void 0 && refsForData.has(schema.$ref)) {
+        return validSchemaResponse();
+      }
+      if (refsForData === void 0) {
+        refsForData = /* @__PURE__ */ new Set();
+        visited.set(data, refsForData);
+      }
+      refsForData.add(schema.$ref);
       try {
         const schemaToValidate = findSchemaAtPath(document, schema.$ref);
-        return validateJsonSchema(data, schemaToValidate, path, document);
+        return validateJsonSchemaInternal(data, schemaToValidate, path, document, visited);
       } catch (e) {
         return invalidSchemaResponseWithError(e);
+      } finally {
+        refsForData.delete(schema.$ref);
+        if (refsForData.size === 0) visited.delete(data);
       }
     }
     function validateEnum(data, enumValue, path) {
@@ -106818,7 +107002,7 @@
             _(config, CONFIG_SCHEMA);
             const baseCommand = new graphql_imperative_ctor(config, documentRootType, services);
             return applyDecorators(baseCommand, [services.fetchNetworkCommandBaseClass.availableDecorators.abortable], options);
-        }, false);
+        }, true);
         graphql_imperative_legacy = services.graphQLLegacyImperativeBindings.bind(({ config, assertIsValid }) => {
             const _ = assertIsValid;
             _(config, CONFIG_SCHEMA);
@@ -106871,7 +107055,7 @@
             cb(graphql_v1_import, graphql_imperative$1, graphql_imperative_legacy_v1_import, graphql_state_manager, useOneStoreGraphQL);
         }
     }
-    // version: 1.428.0-dev1-52205c6c54
+    // version: 1.428.0-dev11-659d2de2fa
 
     function createFragmentMap(documentNode) {
         const fragments = {};
@@ -136108,7 +136292,7 @@
         configuration: { ...configurationForGraphQLAdapters$1 },
         instrument: instrument$1,
     });
-    // version: 1.428.0-dev1-52205c6c54
+    // version: 1.428.0-dev11-659d2de2fa
 
     // On core the unstable adapters are re-exported with different names,
     // we want to match them here.
@@ -136260,7 +136444,7 @@
         unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
         graphQLImperative = ldsAdapter;
     });
-    // version: 1.428.0-dev1-52205c6c54
+    // version: 1.428.0-dev11-659d2de2fa
 
     var gqlApi = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -137059,7 +137243,7 @@
     function register(r) {
         callbacks$1.forEach((callback) => callback(r));
     }
-    // version: 1.428.0-dev1-c95a813572
+    // version: 1.428.0-dev11-b4d8cf1aec
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -138396,4 +138580,4 @@
     exports.subscribeToAdapter = subscribeToAdapter;
 
 }));
-// version: 1.428.0-dev1-c95a813572
+// version: 1.428.0-dev11-b4d8cf1aec