@salesforce/lds-adapters-cms-authoring 1.102.0 → 1.103.0

package/sfdc/index.js

@@ -229,8 +229,8 @@ function deepFreeze$t(input) {
     ObjectFreeze(input);
 }
 
-const TTL$e = 1000;
-const VERSION$e = "ca653daea9600118e6167b9b4ff4d07c";
+const TTL$f = 1000;
+const VERSION$f = "ca653daea9600118e6167b9b4ff4d07c";
 function validate$A(obj, path = 'ManagedContentDeploymentRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -415,28 +415,28 @@ function validate$A(obj, path = 'ManagedContentDeploymentRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$e = 'ManagedContentDeploymentRepresentation';
-function keyBuilder$t(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$e + ':' + config.id;
+const RepresentationType$f = 'ManagedContentDeploymentRepresentation';
+function keyBuilder$w(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$f + ':' + config.id;
 }
-function keyBuilderFromType$8(luvio, object) {
+function keyBuilderFromType$9(luvio, object) {
     const keyParams = {
         id: object.deploymentId
     };
-    return keyBuilder$t(luvio, keyParams);
+    return keyBuilder$w(luvio, keyParams);
 }
-function normalize$e(input, existing, path, luvio, store, timestamp) {
+function normalize$f(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$x = function ManagedContentDeploymentRepresentationSelect() {
+const select$A = function ManagedContentDeploymentRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$e,
+        version: VERSION$f,
         private: [],
         opaque: true
     };
 };
-function equals$e(existing, incoming) {
+function equals$f(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
@@ -451,62 +451,62 @@ function deepFreeze$s(input) {
     ObjectFreeze(input_deploymentItems);
     ObjectFreeze(input);
 }
-const ingest$e = function ManagedContentDeploymentRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$f = function ManagedContentDeploymentRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$A(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$8(luvio, input);
+    const key = keyBuilderFromType$9(luvio, input);
     const existingRecord = store.readEntry(key);
-    const ttlToUse = TTL$e;
-    let incomingRecord = normalize$e(input, store.readEntry(key), {
+    const ttlToUse = TTL$f;
+    let incomingRecord = normalize$f(input, store.readEntry(key), {
         fullPath: key,
         parent: path.parent,
         propertyName: path.propertyName,
         ttl: ttlToUse
     });
     deepFreeze$s(input);
-    if (existingRecord === undefined || equals$e(existingRecord, incomingRecord) === false) {
+    if (existingRecord === undefined || equals$f(existingRecord, incomingRecord) === false) {
         luvio.storePublish(key, incomingRecord);
     }
     {
         const storeMetadataParams = {
             ttl: ttlToUse,
             namespace: "CMSAuthoring",
-            version: VERSION$e,
-            representationName: RepresentationType$e,
+            version: VERSION$f,
+            representationName: RepresentationType$f,
         };
         luvio.publishStoreMetadata(key, storeMetadataParams);
     }
     return createLink(key);
 };
-function getTypeCacheKeys$e(luvio, input, fullPathFactory) {
+function getTypeCacheKeys$f(luvio, input, fullPathFactory) {
     const rootKeySet = new StoreKeyMap();
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$8(luvio, input);
+    const rootKey = keyBuilderFromType$9(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$e,
+        representationName: RepresentationType$f,
         mergeable: false
     });
     return rootKeySet;
 }
 
-function select$w(luvio, params) {
-    return select$x();
+function select$z(luvio, params) {
+    return select$A();
 }
-function getResponseCacheKeys$j(luvio, resourceParams, response) {
-    return getTypeCacheKeys$e(luvio, response);
+function getResponseCacheKeys$l(luvio, resourceParams, response) {
+    return getTypeCacheKeys$f(luvio, response);
 }
-function ingestSuccess$j(luvio, resourceParams, response) {
+function ingestSuccess$l(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$8(luvio, body);
-    luvio.storeIngest(key, ingest$e, body);
+    const key = keyBuilderFromType$9(luvio, body);
+    luvio.storeIngest(key, ingest$f, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$w(),
+        node: select$z(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -516,7 +516,7 @@ function ingestSuccess$j(luvio, resourceParams, response) {
     }
     return snapshot;
 }
-function createResourceRequest$j(config) {
+function createResourceRequest$l(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -537,7 +537,7 @@ const createDeployment_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$j(config) {
+function createResourceParams$l(config) {
     const resourceParams = {
         body: {
             DeploymentInput: config.DeploymentInput
@@ -545,7 +545,7 @@ function createResourceParams$j(config) {
     };
     return resourceParams;
 }
-function typeCheckConfig$j(untrustedConfig) {
+function typeCheckConfig$l(untrustedConfig) {
     const config = {};
     const untrustedConfig_DeploymentInput = untrustedConfig.DeploymentInput;
     const referenceManagedContentDeploymentInputRepresentationValidationError = validate$C(untrustedConfig_DeploymentInput);
@@ -554,28 +554,28 @@ function typeCheckConfig$j(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$j(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$l(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$j(untrustedConfig);
+    const config = typeCheckConfig$l(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$j(luvio, config, options) {
-    const resourceParams = createResourceParams$j(config);
-    const request = createResourceRequest$j(resourceParams);
+function buildNetworkSnapshot$l(luvio, config, options) {
+    const resourceParams = createResourceParams$l(config);
+    const request = createResourceRequest$l(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$j(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$l(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
-        }, () => getResponseCacheKeys$j(luvio, resourceParams, response.body));
+        }, () => getResponseCacheKeys$l(luvio, resourceParams, response.body));
     }, (response) => {
         deepFreeze$u(response);
         throw response;
@@ -583,12 +583,12 @@ function buildNetworkSnapshot$j(luvio, config, options) {
 }
 const createDeploymentAdapterFactory = (luvio) => {
     return function createDeployment(untrustedConfig) {
-        const config = validateAdapterConfig$j(untrustedConfig, createDeployment_ConfigPropertyNames);
+        const config = validateAdapterConfig$l(untrustedConfig, createDeployment_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createDeployment"');
         }
-        return buildNetworkSnapshot$j(luvio, config);
+        return buildNetworkSnapshot$l(luvio, config);
     };
 };
 
@@ -754,8 +754,8 @@ function deepFreeze$n(input) {
     ObjectFreeze(input);
 }
 
-const TTL$d = 100;
-const VERSION$d = "c04d826180efa7be6ad6764b5928469e";
+const TTL$e = 100;
+const VERSION$e = "c04d826180efa7be6ad6764b5928469e";
 function validate$t(obj, path = 'ManagedContentDocumentRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -930,30 +930,30 @@ function validate$t(obj, path = 'ManagedContentDocumentRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$d = 'ManagedContentDocumentRepresentation';
-function keyBuilder$s(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$d + ':' + config.content_key + ':' + config.language + ':' + config.version;
+const RepresentationType$e = 'ManagedContentDocumentRepresentation';
+function keyBuilder$v(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$e + ':' + config.content_key + ':' + config.language + ':' + config.version;
 }
-function keyBuilderFromType$7(luvio, object) {
+function keyBuilderFromType$8(luvio, object) {
     const keyParams = {
         content_key: object.contentKey,
         language: object.language,
         version: object.version
     };
-    return keyBuilder$s(luvio, keyParams);
+    return keyBuilder$v(luvio, keyParams);
 }
-function normalize$d(input, existing, path, luvio, store, timestamp) {
+function normalize$e(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$v = function ManagedContentDocumentRepresentationSelect() {
+const select$y = function ManagedContentDocumentRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$d,
+        version: VERSION$e,
         private: [],
         opaque: true
     };
 };
-function equals$d(existing, incoming) {
+function equals$e(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
@@ -987,62 +987,62 @@ function deepFreeze$m(input) {
     }
     ObjectFreeze(input);
 }
-const ingest$d = function ManagedContentDocumentRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$e = function ManagedContentDocumentRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$t(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$7(luvio, input);
+    const key = keyBuilderFromType$8(luvio, input);
     const existingRecord = store.readEntry(key);
-    const ttlToUse = TTL$d;
-    let incomingRecord = normalize$d(input, store.readEntry(key), {
+    const ttlToUse = TTL$e;
+    let incomingRecord = normalize$e(input, store.readEntry(key), {
         fullPath: key,
         parent: path.parent,
         propertyName: path.propertyName,
         ttl: ttlToUse
     });
     deepFreeze$m(input);
-    if (existingRecord === undefined || equals$d(existingRecord, incomingRecord) === false) {
+    if (existingRecord === undefined || equals$e(existingRecord, incomingRecord) === false) {
         luvio.storePublish(key, incomingRecord);
     }
     {
         const storeMetadataParams = {
             ttl: ttlToUse,
             namespace: "CMSAuthoring",
-            version: VERSION$d,
-            representationName: RepresentationType$d,
+            version: VERSION$e,
+            representationName: RepresentationType$e,
         };
         luvio.publishStoreMetadata(key, storeMetadataParams);
     }
     return createLink(key);
 };
-function getTypeCacheKeys$d(luvio, input, fullPathFactory) {
+function getTypeCacheKeys$e(luvio, input, fullPathFactory) {
     const rootKeySet = new StoreKeyMap();
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$7(luvio, input);
+    const rootKey = keyBuilderFromType$8(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$d,
+        representationName: RepresentationType$e,
         mergeable: false
     });
     return rootKeySet;
 }
 
-function select$u(luvio, params) {
-    return select$v();
+function select$x(luvio, params) {
+    return select$y();
 }
-function getResponseCacheKeys$i(luvio, resourceParams, response) {
-    return getTypeCacheKeys$d(luvio, response);
+function getResponseCacheKeys$k(luvio, resourceParams, response) {
+    return getTypeCacheKeys$e(luvio, response);
 }
-function ingestSuccess$i(luvio, resourceParams, response) {
+function ingestSuccess$k(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$7(luvio, body);
-    luvio.storeIngest(key, ingest$d, body);
+    const key = keyBuilderFromType$8(luvio, body);
+    luvio.storeIngest(key, ingest$e, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$u(),
+        node: select$x(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -1052,7 +1052,7 @@ function ingestSuccess$i(luvio, resourceParams, response) {
     }
     return snapshot;
 }
-function createResourceRequest$i(config) {
+function createResourceRequest$k(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -1066,11 +1066,11 @@ function createResourceRequest$i(config) {
     };
 }
 
-function ingestSuccess$h(luvio, resourceParams, response) {
+function ingestSuccess$j(luvio, resourceParams, response) {
     // Version can come either from versionNumber field in case of v2 content, or managedContentVersionId field in case of v1 content.
     response.body.version = (response.body.versionNumber ||
         response.body.managedContentVersionId);
-    return ingestSuccess$i(luvio, resourceParams, response);
+    return ingestSuccess$k(luvio, resourceParams, response);
 }
 
 const createManagedContent_ConfigPropertyNames = {
@@ -1080,7 +1080,7 @@ const createManagedContent_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$i(config) {
+function createResourceParams$k(config) {
     const resourceParams = {
         body: {
             ManagedContentInputParam: config.ManagedContentInputParam
@@ -1088,7 +1088,7 @@ function createResourceParams$i(config) {
     };
     return resourceParams;
 }
-function typeCheckConfig$i(untrustedConfig) {
+function typeCheckConfig$k(untrustedConfig) {
     const config = {};
     const untrustedConfig_ManagedContentInputParam = untrustedConfig.ManagedContentInputParam;
     const referenceManagedContentInputRepresentationValidationError = validate$z(untrustedConfig_ManagedContentInputParam);
@@ -1097,28 +1097,28 @@ function typeCheckConfig$i(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$i(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$k(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$i(untrustedConfig);
+    const config = typeCheckConfig$k(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$i(luvio, config, options) {
-    const resourceParams = createResourceParams$i(config);
-    const request = createResourceRequest$i(resourceParams);
+function buildNetworkSnapshot$k(luvio, config, options) {
+    const resourceParams = createResourceParams$k(config);
+    const request = createResourceRequest$k(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$h(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$j(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
-        }, () => getResponseCacheKeys$i(luvio, resourceParams, response.body));
+        }, () => getResponseCacheKeys$k(luvio, resourceParams, response.body));
     }, (response) => {
         deepFreeze$u(response);
         throw response;
@@ -1126,12 +1126,12 @@ function buildNetworkSnapshot$i(luvio, config, options) {
 }
 const createManagedContentAdapterFactory = (luvio) => {
     return function createManagedContent(untrustedConfig) {
-        const config = validateAdapterConfig$i(untrustedConfig, createManagedContent_ConfigPropertyNames);
+        const config = validateAdapterConfig$k(untrustedConfig, createManagedContent_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createManagedContent"');
         }
-        return buildNetworkSnapshot$i(luvio, config);
+        return buildNetworkSnapshot$k(luvio, config);
     };
 };
 
@@ -1183,8 +1183,8 @@ function validate$s(obj, path = 'ManagedContentExportContentV2JobRequestInputRep
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$c = 100;
-const VERSION$c = "9ae4bb8336d074517f1c980f5f3f7d82";
+const TTL$d = 100;
+const VERSION$d = "9ae4bb8336d074517f1c980f5f3f7d82";
 function validate$r(obj, path = 'ManagedContentV2JobRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -1342,28 +1342,28 @@ function validate$r(obj, path = 'ManagedContentV2JobRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$c = 'ManagedContentV2JobRepresentation';
-function keyBuilder$r(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$c + ':' + config.id;
+const RepresentationType$d = 'ManagedContentV2JobRepresentation';
+function keyBuilder$u(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$d + ':' + config.id;
 }
-function keyBuilderFromType$6(luvio, object) {
+function keyBuilderFromType$7(luvio, object) {
     const keyParams = {
         id: object.id
     };
-    return keyBuilder$r(luvio, keyParams);
+    return keyBuilder$u(luvio, keyParams);
 }
-function normalize$c(input, existing, path, luvio, store, timestamp) {
+function normalize$d(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$t = function ManagedContentV2JobRepresentationSelect() {
+const select$w = function ManagedContentV2JobRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$c,
+        version: VERSION$d,
         private: [],
         opaque: true
     };
 };
-function equals$c(existing, incoming) {
+function equals$d(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
@@ -1372,62 +1372,62 @@ function equals$c(existing, incoming) {
 function deepFreeze$l(input) {
     ObjectFreeze(input);
 }
-const ingest$c = function ManagedContentV2JobRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$d = function ManagedContentV2JobRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$r(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$6(luvio, input);
+    const key = keyBuilderFromType$7(luvio, input);
     const existingRecord = store.readEntry(key);
-    const ttlToUse = TTL$c;
-    let incomingRecord = normalize$c(input, store.readEntry(key), {
+    const ttlToUse = TTL$d;
+    let incomingRecord = normalize$d(input, store.readEntry(key), {
         fullPath: key,
         parent: path.parent,
         propertyName: path.propertyName,
         ttl: ttlToUse
     });
     deepFreeze$l(input);
-    if (existingRecord === undefined || equals$c(existingRecord, incomingRecord) === false) {
+    if (existingRecord === undefined || equals$d(existingRecord, incomingRecord) === false) {
         luvio.storePublish(key, incomingRecord);
     }
     {
         const storeMetadataParams = {
             ttl: ttlToUse,
             namespace: "CMSAuthoring",
-            version: VERSION$c,
-            representationName: RepresentationType$c,
+            version: VERSION$d,
+            representationName: RepresentationType$d,
         };
         luvio.publishStoreMetadata(key, storeMetadataParams);
     }
     return createLink(key);
 };
-function getTypeCacheKeys$c(luvio, input, fullPathFactory) {
+function getTypeCacheKeys$d(luvio, input, fullPathFactory) {
     const rootKeySet = new StoreKeyMap();
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$6(luvio, input);
+    const rootKey = keyBuilderFromType$7(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$c,
+        representationName: RepresentationType$d,
         mergeable: false
     });
     return rootKeySet;
 }
 
-function select$s(luvio, params) {
-    return select$t();
+function select$v(luvio, params) {
+    return select$w();
 }
-function getResponseCacheKeys$h(luvio, resourceParams, response) {
-    return getTypeCacheKeys$c(luvio, response);
+function getResponseCacheKeys$j(luvio, resourceParams, response) {
+    return getTypeCacheKeys$d(luvio, response);
 }
-function ingestSuccess$g(luvio, resourceParams, response) {
+function ingestSuccess$i(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$6(luvio, body);
-    luvio.storeIngest(key, ingest$c, body);
+    const key = keyBuilderFromType$7(luvio, body);
+    luvio.storeIngest(key, ingest$d, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$s(),
+        node: select$v(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -1437,7 +1437,7 @@ function ingestSuccess$g(luvio, resourceParams, response) {
     }
     return snapshot;
 }
-function createResourceRequest$h(config) {
+function createResourceRequest$j(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -1458,7 +1458,7 @@ const createManagedContentExportV2Job_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$h(config) {
+function createResourceParams$j(config) {
     const resourceParams = {
         urlParams: {
             contentSpaceId: config.contentSpaceId
@@ -1469,7 +1469,7 @@ function createResourceParams$h(config) {
     };
     return resourceParams;
 }
-function typeCheckConfig$h(untrustedConfig) {
+function typeCheckConfig$j(untrustedConfig) {
     const config = {};
     const untrustedConfig_contentSpaceId = untrustedConfig.contentSpaceId;
     if (typeof untrustedConfig_contentSpaceId === 'string') {
@@ -1482,28 +1482,28 @@ function typeCheckConfig$h(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$h(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$j(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$h(untrustedConfig);
+    const config = typeCheckConfig$j(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$h(luvio, config, options) {
-    const resourceParams = createResourceParams$h(config);
-    const request = createResourceRequest$h(resourceParams);
+function buildNetworkSnapshot$j(luvio, config, options) {
+    const resourceParams = createResourceParams$j(config);
+    const request = createResourceRequest$j(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$g(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$i(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
-        }, () => getResponseCacheKeys$h(luvio, resourceParams, response.body));
+        }, () => getResponseCacheKeys$j(luvio, resourceParams, response.body));
     }, (response) => {
         deepFreeze$u(response);
         throw response;
@@ -1511,12 +1511,12 @@ function buildNetworkSnapshot$h(luvio, config, options) {
 }
 const createManagedContentExportV2JobAdapterFactory = (luvio) => {
     return function createManagedContentExportV2Job(untrustedConfig) {
-        const config = validateAdapterConfig$h(untrustedConfig, createManagedContentExportV2Job_ConfigPropertyNames);
+        const config = validateAdapterConfig$j(untrustedConfig, createManagedContentExportV2Job_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createManagedContentExportV2Job"');
         }
-        return buildNetworkSnapshot$h(luvio, config);
+        return buildNetworkSnapshot$j(luvio, config);
     };
 };
 
@@ -1544,19 +1544,19 @@ function validate$q(obj, path = 'ManagedContentV2JobRequestInputRepresentation')
     return v_error === undefined ? null : v_error;
 }
 
-function select$r(luvio, params) {
-    return select$t();
+function select$u(luvio, params) {
+    return select$w();
 }
-function getResponseCacheKeys$g(luvio, resourceParams, response) {
-    return getTypeCacheKeys$c(luvio, response);
+function getResponseCacheKeys$i(luvio, resourceParams, response) {
+    return getTypeCacheKeys$d(luvio, response);
 }
-function ingestSuccess$f(luvio, resourceParams, response) {
+function ingestSuccess$h(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$6(luvio, body);
-    luvio.storeIngest(key, ingest$c, body);
+    const key = keyBuilderFromType$7(luvio, body);
+    luvio.storeIngest(key, ingest$d, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$r(),
+        node: select$u(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -1566,7 +1566,7 @@ function ingestSuccess$f(luvio, resourceParams, response) {
     }
     return snapshot;
 }
-function createResourceRequest$g(config) {
+function createResourceRequest$i(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -1587,7 +1587,7 @@ const createManagedContentImportV2Job_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$g(config) {
+function createResourceParams$i(config) {
     const resourceParams = {
         urlParams: {
             contentSpaceId: config.contentSpaceId
@@ -1598,7 +1598,7 @@ function createResourceParams$g(config) {
     };
     return resourceParams;
 }
-function typeCheckConfig$g(untrustedConfig) {
+function typeCheckConfig$i(untrustedConfig) {
     const config = {};
     const untrustedConfig_contentSpaceId = untrustedConfig.contentSpaceId;
     if (typeof untrustedConfig_contentSpaceId === 'string') {
@@ -1611,28 +1611,28 @@ function typeCheckConfig$g(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$g(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$i(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$g(untrustedConfig);
+    const config = typeCheckConfig$i(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$g(luvio, config, options) {
-    const resourceParams = createResourceParams$g(config);
-    const request = createResourceRequest$g(resourceParams);
+function buildNetworkSnapshot$i(luvio, config, options) {
+    const resourceParams = createResourceParams$i(config);
+    const request = createResourceRequest$i(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$f(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$h(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
-        }, () => getResponseCacheKeys$g(luvio, resourceParams, response.body));
+        }, () => getResponseCacheKeys$i(luvio, resourceParams, response.body));
     }, (response) => {
         deepFreeze$u(response);
         throw response;
@@ -1640,12 +1640,12 @@ function buildNetworkSnapshot$g(luvio, config, options) {
 }
 const createManagedContentImportV2JobAdapterFactory = (luvio) => {
     return function createManagedContentImportV2Job(untrustedConfig) {
-        const config = validateAdapterConfig$g(untrustedConfig, createManagedContentImportV2Job_ConfigPropertyNames);
+        const config = validateAdapterConfig$i(untrustedConfig, createManagedContentImportV2Job_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createManagedContentImportV2Job"');
         }
-        return buildNetworkSnapshot$g(luvio, config);
+        return buildNetworkSnapshot$i(luvio, config);
     };
 };
 
@@ -1696,8 +1696,8 @@ function validate$p(obj, path = 'ManagedContentVariantInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$b = 3600000;
-const VERSION$b = "7752c6a8bb6b113a02bfde83f39e5957";
+const TTL$c = 3600000;
+const VERSION$c = "7752c6a8bb6b113a02bfde83f39e5957";
 function validate$o(obj, path = 'ManagedContentVariantRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -1818,28 +1818,28 @@ function validate$o(obj, path = 'ManagedContentVariantRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$b = 'ManagedContentVariantRepresentation';
-function keyBuilder$q(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$b + ':' + config.id;
+const RepresentationType$c = 'ManagedContentVariantRepresentation';
+function keyBuilder$t(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$c + ':' + config.id;
 }
-function keyBuilderFromType$5(luvio, object) {
+function keyBuilderFromType$6(luvio, object) {
     const keyParams = {
         id: object.managedContentVariantId
     };
-    return keyBuilder$q(luvio, keyParams);
+    return keyBuilder$t(luvio, keyParams);
 }
-function normalize$b(input, existing, path, luvio, store, timestamp) {
+function normalize$c(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$q = function ManagedContentVariantRepresentationSelect() {
+const select$t = function ManagedContentVariantRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$b,
+        version: VERSION$c,
         private: [],
         opaque: true
     };
 };
-function equals$b(existing, incoming) {
+function equals$c(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
@@ -1869,62 +1869,62 @@ function deepFreeze$k(input) {
     deepFreeze$n(input_status);
     ObjectFreeze(input);
 }
-const ingest$b = function ManagedContentVariantRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$c = function ManagedContentVariantRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$o(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$5(luvio, input);
+    const key = keyBuilderFromType$6(luvio, input);
     const existingRecord = store.readEntry(key);
-    const ttlToUse = TTL$b;
-    let incomingRecord = normalize$b(input, store.readEntry(key), {
+    const ttlToUse = TTL$c;
+    let incomingRecord = normalize$c(input, store.readEntry(key), {
         fullPath: key,
         parent: path.parent,
         propertyName: path.propertyName,
         ttl: ttlToUse
     });
     deepFreeze$k(input);
-    if (existingRecord === undefined || equals$b(existingRecord, incomingRecord) === false) {
+    if (existingRecord === undefined || equals$c(existingRecord, incomingRecord) === false) {
         luvio.storePublish(key, incomingRecord);
     }
     {
         const storeMetadataParams = {
             ttl: ttlToUse,
             namespace: "CMSAuthoring",
-            version: VERSION$b,
-            representationName: RepresentationType$b,
+            version: VERSION$c,
+            representationName: RepresentationType$c,
         };
         luvio.publishStoreMetadata(key, storeMetadataParams);
     }
     return createLink(key);
 };
-function getTypeCacheKeys$b(luvio, input, fullPathFactory) {
+function getTypeCacheKeys$c(luvio, input, fullPathFactory) {
     const rootKeySet = new StoreKeyMap();
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$5(luvio, input);
+    const rootKey = keyBuilderFromType$6(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$b,
+        representationName: RepresentationType$c,
         mergeable: false
     });
     return rootKeySet;
 }
 
-function select$p(luvio, params) {
-    return select$q();
+function select$s(luvio, params) {
+    return select$t();
 }
-function getResponseCacheKeys$f(luvio, resourceParams, response) {
-    return getTypeCacheKeys$b(luvio, response);
+function getResponseCacheKeys$h(luvio, resourceParams, response) {
+    return getTypeCacheKeys$c(luvio, response);
 }
-function ingestSuccess$e(luvio, resourceParams, response) {
+function ingestSuccess$g(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$5(luvio, body);
-    luvio.storeIngest(key, ingest$b, body);
+    const key = keyBuilderFromType$6(luvio, body);
+    luvio.storeIngest(key, ingest$c, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$p(),
+        node: select$s(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -1934,7 +1934,7 @@ function ingestSuccess$e(luvio, resourceParams, response) {
     }
     return snapshot;
 }
-function createResourceRequest$f(config) {
+function createResourceRequest$h(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -1955,7 +1955,7 @@ const createManagedContentVariant_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$f(config) {
+function createResourceParams$h(config) {
     const resourceParams = {
         body: {
             managedContentVariantInputParam: config.managedContentVariantInputParam
@@ -1963,7 +1963,7 @@ function createResourceParams$f(config) {
     };
     return resourceParams;
 }
-function typeCheckConfig$f(untrustedConfig) {
+function typeCheckConfig$h(untrustedConfig) {
     const config = {};
     const untrustedConfig_managedContentVariantInputParam = untrustedConfig.managedContentVariantInputParam;
     const referenceManagedContentVariantInputRepresentationValidationError = validate$p(untrustedConfig_managedContentVariantInputParam);
@@ -1972,28 +1972,28 @@ function typeCheckConfig$f(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$f(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$h(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$f(untrustedConfig);
+    const config = typeCheckConfig$h(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$f(luvio, config, options) {
-    const resourceParams = createResourceParams$f(config);
-    const request = createResourceRequest$f(resourceParams);
+function buildNetworkSnapshot$h(luvio, config, options) {
+    const resourceParams = createResourceParams$h(config);
+    const request = createResourceRequest$h(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$e(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$g(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
-        }, () => getResponseCacheKeys$f(luvio, resourceParams, response.body));
+        }, () => getResponseCacheKeys$h(luvio, resourceParams, response.body));
     }, (response) => {
         deepFreeze$u(response);
         throw response;
@@ -2001,12 +2001,12 @@ function buildNetworkSnapshot$f(luvio, config, options) {
 }
 const createManagedContentVariantAdapterFactory = (luvio) => {
     return function createManagedContentVariant(untrustedConfig) {
-        const config = validateAdapterConfig$f(untrustedConfig, createManagedContentVariant_ConfigPropertyNames);
+        const config = validateAdapterConfig$h(untrustedConfig, createManagedContentVariant_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createManagedContentVariant"');
         }
-        return buildNetworkSnapshot$f(luvio, config);
+        return buildNetworkSnapshot$h(luvio, config);
     };
 };
 
@@ -2080,8 +2080,8 @@ function validate$n(obj, path = 'ManagedContentTranslationV2RequestInputRep') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$a = 100;
-const VERSION$a = "52e643b998d6763482c6d74542b38408";
+const TTL$b = 100;
+const VERSION$b = "52e643b998d6763482c6d74542b38408";
 function validate$m(obj, path = 'ManagedContentTranslationV2Representation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -2239,28 +2239,28 @@ function validate$m(obj, path = 'ManagedContentTranslationV2Representation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$a = 'ManagedContentTranslationV2Representation';
-function keyBuilder$p(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$a + ':' + config.id;
+const RepresentationType$b = 'ManagedContentTranslationV2Representation';
+function keyBuilder$s(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$b + ':' + config.id;
 }
-function keyBuilderFromType$4(luvio, object) {
+function keyBuilderFromType$5(luvio, object) {
     const keyParams = {
         id: object.id
     };
-    return keyBuilder$p(luvio, keyParams);
+    return keyBuilder$s(luvio, keyParams);
 }
-function normalize$a(input, existing, path, luvio, store, timestamp) {
+function normalize$b(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$o = function ManagedContentTranslationV2RepresentationSelect() {
+const select$r = function ManagedContentTranslationV2RepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$a,
+        version: VERSION$b,
         private: [],
         opaque: true
     };
 };
-function equals$a(existing, incoming) {
+function equals$b(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
@@ -2269,62 +2269,62 @@ function equals$a(existing, incoming) {
 function deepFreeze$j(input) {
     ObjectFreeze(input);
 }
-const ingest$a = function ManagedContentTranslationV2RepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$b = function ManagedContentTranslationV2RepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$m(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$4(luvio, input);
+    const key = keyBuilderFromType$5(luvio, input);
     const existingRecord = store.readEntry(key);
-    const ttlToUse = TTL$a;
-    let incomingRecord = normalize$a(input, store.readEntry(key), {
+    const ttlToUse = TTL$b;
+    let incomingRecord = normalize$b(input, store.readEntry(key), {
         fullPath: key,
         parent: path.parent,
         propertyName: path.propertyName,
         ttl: ttlToUse
     });
     deepFreeze$j(input);
-    if (existingRecord === undefined || equals$a(existingRecord, incomingRecord) === false) {
+    if (existingRecord === undefined || equals$b(existingRecord, incomingRecord) === false) {
         luvio.storePublish(key, incomingRecord);
     }
     {
         const storeMetadataParams = {
             ttl: ttlToUse,
             namespace: "CMSAuthoring",
-            version: VERSION$a,
-            representationName: RepresentationType$a,
+            version: VERSION$b,
+            representationName: RepresentationType$b,
         };
         luvio.publishStoreMetadata(key, storeMetadataParams);
     }
     return createLink(key);
 };
-function getTypeCacheKeys$a(luvio, input, fullPathFactory) {
+function getTypeCacheKeys$b(luvio, input, fullPathFactory) {
     const rootKeySet = new StoreKeyMap();
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$4(luvio, input);
+    const rootKey = keyBuilderFromType$5(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$a,
+        representationName: RepresentationType$b,
         mergeable: false
     });
     return rootKeySet;
 }
 
-function select$n(luvio, params) {
-    return select$o();
+function select$q(luvio, params) {
+    return select$r();
 }
-function getResponseCacheKeys$e(luvio, resourceParams, response) {
-    return getTypeCacheKeys$a(luvio, response);
+function getResponseCacheKeys$g(luvio, resourceParams, response) {
+    return getTypeCacheKeys$b(luvio, response);
 }
-function ingestSuccess$d(luvio, resourceParams, response) {
+function ingestSuccess$f(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$4(luvio, body);
-    luvio.storeIngest(key, ingest$a, body);
+    const key = keyBuilderFromType$5(luvio, body);
+    luvio.storeIngest(key, ingest$b, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$n(),
+        node: select$q(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -2334,7 +2334,7 @@ function ingestSuccess$d(luvio, resourceParams, response) {
     }
     return snapshot;
 }
-function createResourceRequest$e(config) {
+function createResourceRequest$g(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -2355,7 +2355,7 @@ const createTranslationV2Job_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$e(config) {
+function createResourceParams$g(config) {
     const resourceParams = {
         urlParams: {
             contentSpaceId: config.contentSpaceId
@@ -2366,7 +2366,7 @@ function createResourceParams$e(config) {
     };
     return resourceParams;
 }
-function typeCheckConfig$e(untrustedConfig) {
+function typeCheckConfig$g(untrustedConfig) {
     const config = {};
     const untrustedConfig_contentSpaceId = untrustedConfig.contentSpaceId;
     if (typeof untrustedConfig_contentSpaceId === 'string') {
@@ -2379,28 +2379,28 @@ function typeCheckConfig$e(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$e(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$g(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$e(untrustedConfig);
+    const config = typeCheckConfig$g(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$e(luvio, config, options) {
-    const resourceParams = createResourceParams$e(config);
-    const request = createResourceRequest$e(resourceParams);
+function buildNetworkSnapshot$g(luvio, config, options) {
+    const resourceParams = createResourceParams$g(config);
+    const request = createResourceRequest$g(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$d(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$f(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
-        }, () => getResponseCacheKeys$e(luvio, resourceParams, response.body));
+        }, () => getResponseCacheKeys$g(luvio, resourceParams, response.body));
     }, (response) => {
         deepFreeze$u(response);
         throw response;
@@ -2408,35 +2408,35 @@ function buildNetworkSnapshot$e(luvio, config, options) {
 }
 const createTranslationV2JobAdapterFactory = (luvio) => {
     return function createTranslationV2Job(untrustedConfig) {
-        const config = validateAdapterConfig$e(untrustedConfig, createTranslationV2Job_ConfigPropertyNames);
+        const config = validateAdapterConfig$g(untrustedConfig, createTranslationV2Job_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createTranslationV2Job"');
         }
-        return buildNetworkSnapshot$e(luvio, config);
+        return buildNetworkSnapshot$g(luvio, config);
     };
 };
 
-function keyBuilder$o(luvio, params) {
-    return keyBuilder$q(luvio, {
+function keyBuilder$r(luvio, params) {
+    return keyBuilder$t(luvio, {
         id: params.urlParams.variantId
     });
 }
-function getResponseCacheKeys$d(luvio, resourceParams) {
-    const key = keyBuilder$o(luvio, resourceParams);
+function getResponseCacheKeys$f(luvio, resourceParams) {
+    const key = keyBuilder$r(luvio, resourceParams);
     const cacheKeyMap = new StoreKeyMap();
     cacheKeyMap.set(key, {
         namespace: keyPrefix,
-        representationName: RepresentationType$b,
+        representationName: RepresentationType$c,
         mergeable: false
     });
     return cacheKeyMap;
 }
 function evictSuccess(luvio, resourceParams) {
-    const key = keyBuilder$o(luvio, resourceParams);
+    const key = keyBuilder$r(luvio, resourceParams);
     luvio.storeEvict(key);
 }
-function createResourceRequest$d(config) {
+function createResourceRequest$f(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -2458,7 +2458,7 @@ const deleteManagedContentVariant_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$d(config) {
+function createResourceParams$f(config) {
     const resourceParams = {
         urlParams: {
             variantId: config.variantId
@@ -2466,7 +2466,7 @@ function createResourceParams$d(config) {
     };
     return resourceParams;
 }
-function typeCheckConfig$d(untrustedConfig) {
+function typeCheckConfig$f(untrustedConfig) {
     const config = {};
     const untrustedConfig_variantId = untrustedConfig.variantId;
     if (typeof untrustedConfig_variantId === 'string') {
@@ -2474,28 +2474,28 @@ function typeCheckConfig$d(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$d(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$f(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$d(untrustedConfig);
+    const config = typeCheckConfig$f(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$d(luvio, config, options) {
-    const resourceParams = createResourceParams$d(config);
-    const request = createResourceRequest$d(resourceParams);
+function buildNetworkSnapshot$f(luvio, config, options) {
+    const resourceParams = createResourceParams$f(config);
+    const request = createResourceRequest$f(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then(() => {
         return luvio.handleSuccessResponse(() => {
             evictSuccess(luvio, resourceParams);
             return luvio.storeBroadcast();
-        }, () => getResponseCacheKeys$d(luvio, resourceParams));
+        }, () => getResponseCacheKeys$f(luvio, resourceParams));
     }, (response) => {
         deepFreeze$u(response);
         throw response;
@@ -2503,12 +2503,12 @@ function buildNetworkSnapshot$d(luvio, config, options) {
 }
 const deleteManagedContentVariantAdapterFactory = (luvio) => {
     return function CMSAuthoringdeleteManagedContentVariant(untrustedConfig) {
-        const config = validateAdapterConfig$d(untrustedConfig, deleteManagedContentVariant_ConfigPropertyNames);
+        const config = validateAdapterConfig$f(untrustedConfig, deleteManagedContentVariant_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error(`Invalid config for "${adapterName}"`);
         }
-        return buildNetworkSnapshot$d(luvio, config);
+        return buildNetworkSnapshot$f(luvio, config);
     };
 };
 
@@ -2589,8 +2589,8 @@ function deepFreeze$h(input) {
     ObjectFreeze(input);
 }
 
-const TTL$9 = 100;
-const VERSION$9 = "eeea454f1268ece5c3e24c986688b876";
+const TTL$a = 100;
+const VERSION$a = "eeea454f1268ece5c3e24c986688b876";
 function validate$j(obj, path = 'ManagedContentCollectionDetailRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -2662,30 +2662,30 @@ function validate$j(obj, path = 'ManagedContentCollectionDetailRepresentation')
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$9 = 'ManagedContentCollectionDetailRepresentation';
-function keyBuilder$n(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$9 + ':' + config.collection_key + ':' + config.language + ':' + config.version;
+const RepresentationType$a = 'ManagedContentCollectionDetailRepresentation';
+function keyBuilder$q(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$a + ':' + config.collection_key + ':' + config.language + ':' + config.version;
 }
-function keyBuilderFromType$3(luvio, object) {
+function keyBuilderFromType$4(luvio, object) {
     const keyParams = {
         collection_key: object.collectionKey,
         language: object.language,
         version: object.versionNumber
     };
-    return keyBuilder$n(luvio, keyParams);
+    return keyBuilder$q(luvio, keyParams);
 }
-function normalize$9(input, existing, path, luvio, store, timestamp) {
+function normalize$a(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$m = function ManagedContentCollectionDetailRepresentationSelect() {
+const select$p = function ManagedContentCollectionDetailRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$9,
+        version: VERSION$a,
         private: [],
         opaque: true
     };
 };
-function equals$9(existing, incoming) {
+function equals$a(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
@@ -2702,69 +2702,69 @@ function deepFreeze$g(input) {
     ObjectFreeze(input_items);
     ObjectFreeze(input);
 }
-const ingest$9 = function ManagedContentCollectionDetailRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$a = function ManagedContentCollectionDetailRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$j(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$3(luvio, input);
+    const key = keyBuilderFromType$4(luvio, input);
     const existingRecord = store.readEntry(key);
-    const ttlToUse = TTL$9;
-    let incomingRecord = normalize$9(input, store.readEntry(key), {
+    const ttlToUse = TTL$a;
+    let incomingRecord = normalize$a(input, store.readEntry(key), {
         fullPath: key,
         parent: path.parent,
         propertyName: path.propertyName,
         ttl: ttlToUse
     });
     deepFreeze$g(input);
-    if (existingRecord === undefined || equals$9(existingRecord, incomingRecord) === false) {
+    if (existingRecord === undefined || equals$a(existingRecord, incomingRecord) === false) {
         luvio.storePublish(key, incomingRecord);
     }
     {
         const storeMetadataParams = {
             ttl: ttlToUse,
             namespace: "CMSAuthoring",
-            version: VERSION$9,
-            representationName: RepresentationType$9,
+            version: VERSION$a,
+            representationName: RepresentationType$a,
         };
         luvio.publishStoreMetadata(key, storeMetadataParams);
     }
     return createLink(key);
 };
-function getTypeCacheKeys$9(luvio, input, fullPathFactory) {
+function getTypeCacheKeys$a(luvio, input, fullPathFactory) {
     const rootKeySet = new StoreKeyMap();
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$3(luvio, input);
+    const rootKey = keyBuilderFromType$4(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$9,
+        representationName: RepresentationType$a,
         mergeable: false
     });
     return rootKeySet;
 }
 
-function select$l(luvio, params) {
-    return select$m();
+function select$o(luvio, params) {
+    return select$p();
 }
-function keyBuilder$m(luvio, params) {
-    return keyBuilder$n(luvio, {
+function keyBuilder$p(luvio, params) {
+    return keyBuilder$q(luvio, {
         collection_key: params.urlParams.collectionKeyOrId,
         language: params.queryParams.language || '',
         version: params.queryParams.version || ''
     });
 }
-function getResponseCacheKeys$c(luvio, resourceParams, response) {
-    return getTypeCacheKeys$9(luvio, response);
+function getResponseCacheKeys$e(luvio, resourceParams, response) {
+    return getTypeCacheKeys$a(luvio, response);
 }
-function ingestSuccess$c(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$e(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$m(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$9, body);
+    const key = keyBuilder$p(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$a, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$l(),
+        node: select$o(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -2774,19 +2774,19 @@ function ingestSuccess$c(luvio, resourceParams, response, snapshotRefresh) {
     }
     return snapshot;
 }
-function ingestError$9(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$m(luvio, params);
+function ingestError$a(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$p(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$9,
+        ttl: TTL$a,
         namespace: keyPrefix,
-        version: VERSION$9,
-        representationName: RepresentationType$9
+        version: VERSION$a,
+        representationName: RepresentationType$a
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$c(config) {
+function createResourceRequest$e(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -2800,7 +2800,7 @@ function createResourceRequest$c(config) {
     };
 }
 
-function onFetchResponseSuccess$b(luvio, config, resourceParams, response) {
+function onFetchResponseSuccess$c(luvio, config, resourceParams, response) {
     let updatedResourceParams = resourceParams;
     // If language is not provided in request resource params, use language from the response
     // and update the response params. As this resource params will be used to build a cache key.
@@ -2812,7 +2812,7 @@ function onFetchResponseSuccess$b(luvio, config, resourceParams, response) {
     if (updatedResourceParams.queryParams.version === undefined) {
         updatedResourceParams.queryParams.version = response.body.versionNumber;
     }
-    return onFetchResponseSuccess$a(luvio, config, updatedResourceParams, response);
+    return onFetchResponseSuccess$b(luvio, config, updatedResourceParams, response);
 }
 
 const getCollectionItems_ConfigPropertyNames = {
@@ -2822,7 +2822,7 @@ const getCollectionItems_ConfigPropertyNames = {
         optional: ['language', 'version']
     }
 };
-function createResourceParams$c(config) {
+function createResourceParams$e(config) {
     const resourceParams = {
         urlParams: {
             collectionKeyOrId: config.collectionKeyOrId
@@ -2833,11 +2833,11 @@ function createResourceParams$c(config) {
     };
     return resourceParams;
 }
-function keyBuilder$l(luvio, config) {
-    const resourceParams = createResourceParams$c(config);
-    return keyBuilder$m(luvio, resourceParams);
+function keyBuilder$o(luvio, config) {
+    const resourceParams = createResourceParams$e(config);
+    return keyBuilder$p(luvio, resourceParams);
 }
-function typeCheckConfig$c(untrustedConfig) {
+function typeCheckConfig$e(untrustedConfig) {
     const config = {};
     const untrustedConfig_collectionKeyOrId = untrustedConfig.collectionKeyOrId;
     if (typeof untrustedConfig_collectionKeyOrId === 'string') {
@@ -2853,48 +2853,48 @@ function typeCheckConfig$c(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$c(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$e(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$c(untrustedConfig);
+    const config = typeCheckConfig$e(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$9(luvio, config) {
-    createResourceParams$c(config);
-    return select$l();
+function adapterFragment$a(luvio, config) {
+    createResourceParams$e(config);
+    return select$o();
 }
-function onFetchResponseSuccess$a(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$c(luvio, resourceParams, response, {
+function onFetchResponseSuccess$b(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$e(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$c(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$e(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$9(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$9(luvio, resourceParams, response, {
+function onFetchResponseError$a(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$a(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$c(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$e(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$c(luvio, config, options) {
-    const resourceParams = createResourceParams$c(config);
-    const request = createResourceRequest$c(resourceParams);
+function buildNetworkSnapshot$e(luvio, config, options) {
+    const resourceParams = createResourceParams$e(config);
+    const request = createResourceRequest$e(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$b(luvio, config, resourceParams, response), () => getResponseCacheKeys$c(luvio, resourceParams, response.body));
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$c(luvio, config, resourceParams, response), () => getResponseCacheKeys$e(luvio, resourceParams, response.body));
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$9(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$a(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext) {
+function buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext) {
     const { luvio, config } = context;
     const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
     const dispatchOptions = {
@@ -2909,51 +2909,51 @@ function buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext
             priority: networkPriority
         };
     }
-    return buildNetworkSnapshot$c(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$e(luvio, config, dispatchOptions);
 }
-function buildCachedSnapshotCachePolicy$9(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$a(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$l(luvio, config),
-        node: adapterFragment$9(luvio, config),
+        recordId: keyBuilder$o(luvio, config),
+        node: adapterFragment$a(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$c(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$e(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getCollectionItemsAdapterFactory = (luvio) => function CMSAuthoring__getCollectionItems(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$c(untrustedConfig, getCollectionItems_ConfigPropertyNames);
+    const config = validateAdapterConfig$e(untrustedConfig, getCollectionItems_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$9, buildNetworkSnapshotCachePolicy$9);
+    buildCachedSnapshotCachePolicy$a, buildNetworkSnapshotCachePolicy$a);
 };
 
-function select$k(luvio, params) {
-    return select$v();
+function select$n(luvio, params) {
+    return select$y();
 }
-function keyBuilder$k(luvio, params) {
-    return keyBuilder$s(luvio, {
+function keyBuilder$n(luvio, params) {
+    return keyBuilder$v(luvio, {
         content_key: params.urlParams.contentKeyOrId,
         language: params.queryParams.language || '',
         version: params.queryParams.version || ''
     });
 }
-function getResponseCacheKeys$b(luvio, resourceParams, response) {
-    return getTypeCacheKeys$d(luvio, response);
+function getResponseCacheKeys$d(luvio, resourceParams, response) {
+    return getTypeCacheKeys$e(luvio, response);
 }
-function ingestSuccess$b(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$d(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$k(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$d, body);
+    const key = keyBuilder$n(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$e, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$k(),
+        node: select$n(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -2963,19 +2963,19 @@ function ingestSuccess$b(luvio, resourceParams, response, snapshotRefresh) {
     }
     return snapshot;
 }
-function ingestError$8(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$k(luvio, params);
+function ingestError$9(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$n(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$d,
+        ttl: TTL$e,
         namespace: keyPrefix,
-        version: VERSION$d,
-        representationName: RepresentationType$d
+        version: VERSION$e,
+        representationName: RepresentationType$e
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$b(config) {
+function createResourceRequest$d(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -2989,7 +2989,7 @@ function createResourceRequest$b(config) {
     };
 }
 
-function onFetchResponseSuccess$9(luvio, config, resourceParams, response) {
+function onFetchResponseSuccess$a(luvio, config, resourceParams, response) {
     var _a;
     // Version can come either from versionNumber field in case of v2 content,
     // or managedContentVersionId field in case of v1 content.
@@ -3038,7 +3038,7 @@ function onFetchResponseSuccess$9(luvio, config, resourceParams, response) {
     // since this resource params are used to build a cache key to verify that
     // data was ingested into cache.
     (_a = resourceParams.queryParams).version || (_a.version = response.body.version);
-    return onFetchResponseSuccess$8(luvio, config, resourceParams, response);
+    return onFetchResponseSuccess$9(luvio, config, resourceParams, response);
 }
 
 const getManagedContent_ConfigPropertyNames = {
@@ -3048,7 +3048,7 @@ const getManagedContent_ConfigPropertyNames = {
         optional: ['language', 'version']
     }
 };
-function createResourceParams$b(config) {
+function createResourceParams$d(config) {
     const resourceParams = {
         urlParams: {
             contentKeyOrId: config.contentKeyOrId
@@ -3059,11 +3059,11 @@ function createResourceParams$b(config) {
     };
     return resourceParams;
 }
-function keyBuilder$j(luvio, config) {
-    const resourceParams = createResourceParams$b(config);
-    return keyBuilder$k(luvio, resourceParams);
+function keyBuilder$m(luvio, config) {
+    const resourceParams = createResourceParams$d(config);
+    return keyBuilder$n(luvio, resourceParams);
 }
-function typeCheckConfig$b(untrustedConfig) {
+function typeCheckConfig$d(untrustedConfig) {
     const config = {};
     const untrustedConfig_contentKeyOrId = untrustedConfig.contentKeyOrId;
     if (typeof untrustedConfig_contentKeyOrId === 'string') {
@@ -3079,48 +3079,48 @@ function typeCheckConfig$b(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$b(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$d(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$b(untrustedConfig);
+    const config = typeCheckConfig$d(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$8(luvio, config) {
-    createResourceParams$b(config);
-    return select$k();
+function adapterFragment$9(luvio, config) {
+    createResourceParams$d(config);
+    return select$n();
 }
-function onFetchResponseSuccess$8(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$b(luvio, resourceParams, response, {
+function onFetchResponseSuccess$9(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$d(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$b(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$d(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$8(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$8(luvio, resourceParams, response, {
+function onFetchResponseError$9(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$9(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$b(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$d(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$b(luvio, config, options) {
-    const resourceParams = createResourceParams$b(config);
-    const request = createResourceRequest$b(resourceParams);
+function buildNetworkSnapshot$d(luvio, config, options) {
+    const resourceParams = createResourceParams$d(config);
+    const request = createResourceRequest$d(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$9(luvio, config, resourceParams, response), () => getResponseCacheKeys$b(luvio, resourceParams, response.body));
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$a(luvio, config, resourceParams, response), () => getResponseCacheKeys$d(luvio, resourceParams, response.body));
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$8(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$9(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext) {
+function buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext) {
     const { luvio, config } = context;
     const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
     const dispatchOptions = {
@@ -3135,29 +3135,29 @@ function buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext
             priority: networkPriority
         };
     }
-    return buildNetworkSnapshot$b(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$d(luvio, config, dispatchOptions);
 }
-function buildCachedSnapshotCachePolicy$8(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$9(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$j(luvio, config),
-        node: adapterFragment$8(luvio, config),
+        recordId: keyBuilder$m(luvio, config),
+        node: adapterFragment$9(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$b(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$d(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getManagedContentAdapterFactory = (luvio) => function CMSAuthoring__getManagedContent(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$b(untrustedConfig, getManagedContent_ConfigPropertyNames);
+    const config = validateAdapterConfig$d(untrustedConfig, getManagedContent_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$8, buildNetworkSnapshotCachePolicy$8);
+    buildCachedSnapshotCachePolicy$9, buildNetworkSnapshotCachePolicy$9);
 };
 
 function validate$i(obj, path = 'ManagedContentLanguageSummaryRepresentation') {
@@ -3302,8 +3302,8 @@ function deepFreeze$e(input) {
     ObjectFreeze(input);
 }
 
-const TTL$8 = 100;
-const VERSION$8 = "e85b8f02eca0f2e88859e6f3a061e56b";
+const TTL$9 = 100;
+const VERSION$9 = "e85b8f02eca0f2e88859e6f3a061e56b";
 function validate$g(obj, path = 'ManagedContentSpaceFolderItemCollectionRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -3358,19 +3358,19 @@ function validate$g(obj, path = 'ManagedContentSpaceFolderItemCollectionRepresen
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$8 = 'ManagedContentSpaceFolderItemCollectionRepresentation';
-function normalize$8(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$9 = 'ManagedContentSpaceFolderItemCollectionRepresentation';
+function normalize$9(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$j = function ManagedContentSpaceFolderItemCollectionRepresentationSelect() {
+const select$m = function ManagedContentSpaceFolderItemCollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$8,
+        version: VERSION$9,
         private: [],
         opaque: true
     };
 };
-function equals$8(existing, incoming) {
+function equals$9(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
@@ -3385,7 +3385,7 @@ function deepFreeze$d(input) {
     ObjectFreeze(input_folderItems);
     ObjectFreeze(input);
 }
-const ingest$8 = function ManagedContentSpaceFolderItemCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$9 = function ManagedContentSpaceFolderItemCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$g(input);
         if (validateError !== null) {
@@ -3394,56 +3394,56 @@ const ingest$8 = function ManagedContentSpaceFolderItemCollectionRepresentationI
     }
     const key = path.fullPath;
     const existingRecord = store.readEntry(key);
-    const ttlToUse = TTL$8;
-    let incomingRecord = normalize$8(input, store.readEntry(key), {
+    const ttlToUse = TTL$9;
+    let incomingRecord = normalize$9(input, store.readEntry(key), {
         fullPath: key,
         parent: path.parent,
         propertyName: path.propertyName,
         ttl: ttlToUse
     });
     deepFreeze$d(input);
-    if (existingRecord === undefined || equals$8(existingRecord, incomingRecord) === false) {
+    if (existingRecord === undefined || equals$9(existingRecord, incomingRecord) === false) {
         luvio.storePublish(key, incomingRecord);
     }
     {
         const storeMetadataParams = {
             ttl: ttlToUse,
             namespace: "CMSAuthoring",
-            version: VERSION$8,
-            representationName: RepresentationType$8,
+            version: VERSION$9,
+            representationName: RepresentationType$9,
         };
         luvio.publishStoreMetadata(key, storeMetadataParams);
     }
     return createLink(key);
 };
-function getTypeCacheKeys$8(luvio, input, fullPathFactory) {
+function getTypeCacheKeys$9(luvio, input, fullPathFactory) {
     const rootKeySet = new StoreKeyMap();
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$8,
+        representationName: RepresentationType$9,
         mergeable: false
     });
     return rootKeySet;
 }
 
-function select$i(luvio, params) {
-    return select$j();
+function select$l(luvio, params) {
+    return select$m();
 }
-function keyBuilder$i(luvio, params) {
+function keyBuilder$l(luvio, params) {
     return keyPrefix + '::ManagedContentSpaceFolderItemCollectionRepresentation:(' + 'contentType:' + params.queryParams.contentType + ',' + 'contentTypeFilter:' + params.queryParams.contentTypeFilter + ',' + 'contentTypes:' + params.queryParams.contentTypes + ',' + 'filter:' + params.queryParams.filter + ',' + 'page:' + params.queryParams.page + ',' + 'pageSize:' + params.queryParams.pageSize + ',' + 'queryTerm:' + params.queryParams.queryTerm + ',' + 'showPublishedOnly:' + params.queryParams.showPublishedOnly + ',' + 'sortBy:' + params.queryParams.sortBy + ',' + 'sortOrder:' + params.queryParams.sortOrder + ',' + 'folderId:' + params.urlParams.folderId + ')';
 }
-function getResponseCacheKeys$a(luvio, resourceParams, response) {
-    return getTypeCacheKeys$8(luvio, response, () => keyBuilder$i(luvio, resourceParams));
+function getResponseCacheKeys$c(luvio, resourceParams, response) {
+    return getTypeCacheKeys$9(luvio, response, () => keyBuilder$l(luvio, resourceParams));
 }
-function ingestSuccess$a(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$c(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$i(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$8, body);
+    const key = keyBuilder$l(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$9, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$i(),
+        node: select$l(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -3453,19 +3453,19 @@ function ingestSuccess$a(luvio, resourceParams, response, snapshotRefresh) {
     }
     return snapshot;
 }
-function ingestError$7(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$i(luvio, params);
+function ingestError$8(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$l(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$8,
+        ttl: TTL$9,
         namespace: keyPrefix,
-        version: VERSION$8,
-        representationName: RepresentationType$8
+        version: VERSION$9,
+        representationName: RepresentationType$9
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$a(config) {
+function createResourceRequest$c(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -3486,7 +3486,7 @@ const getManagedContentByFolderId_ConfigPropertyNames = {
         optional: ['contentType', 'contentTypeFilter', 'contentTypes', 'filter', 'page', 'pageSize', 'queryTerm', 'showPublishedOnly', 'sortBy', 'sortOrder']
     }
 };
-function createResourceParams$a(config) {
+function createResourceParams$c(config) {
     const resourceParams = {
         urlParams: {
             folderId: config.folderId
@@ -3497,11 +3497,11 @@ function createResourceParams$a(config) {
     };
     return resourceParams;
 }
-function keyBuilder$h(luvio, config) {
-    const resourceParams = createResourceParams$a(config);
-    return keyBuilder$i(luvio, resourceParams);
+function keyBuilder$k(luvio, config) {
+    const resourceParams = createResourceParams$c(config);
+    return keyBuilder$l(luvio, resourceParams);
 }
-function typeCheckConfig$a(untrustedConfig) {
+function typeCheckConfig$c(untrustedConfig) {
     const config = {};
     const untrustedConfig_folderId = untrustedConfig.folderId;
     if (typeof untrustedConfig_folderId === 'string') {
@@ -3556,48 +3556,48 @@ function typeCheckConfig$a(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$a(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$c(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$a(untrustedConfig);
+    const config = typeCheckConfig$c(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$7(luvio, config) {
-    createResourceParams$a(config);
-    return select$i();
+function adapterFragment$8(luvio, config) {
+    createResourceParams$c(config);
+    return select$l();
 }
-function onFetchResponseSuccess$7(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$a(luvio, resourceParams, response, {
+function onFetchResponseSuccess$8(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$c(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$c(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$7(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$7(luvio, resourceParams, response, {
+function onFetchResponseError$8(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$8(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$c(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$a(luvio, config, options) {
-    const resourceParams = createResourceParams$a(config);
-    const request = createResourceRequest$a(resourceParams);
+function buildNetworkSnapshot$c(luvio, config, options) {
+    const resourceParams = createResourceParams$c(config);
+    const request = createResourceRequest$c(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$7(luvio, config, resourceParams, response), () => getResponseCacheKeys$a(luvio, resourceParams, response.body));
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$8(luvio, config, resourceParams, response), () => getResponseCacheKeys$c(luvio, resourceParams, response.body));
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$7(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$8(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext) {
+function buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext) {
     const { luvio, config } = context;
     const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
     const dispatchOptions = {
@@ -3612,29 +3612,29 @@ function buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext
             priority: networkPriority
         };
     }
-    return buildNetworkSnapshot$a(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$c(luvio, config, dispatchOptions);
 }
-function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$8(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$h(luvio, config),
-        node: adapterFragment$7(luvio, config),
+        recordId: keyBuilder$k(luvio, config),
+        node: adapterFragment$8(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$c(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getManagedContentByFolderIdAdapterFactory = (luvio) => function CMSAuthoring__getManagedContentByFolderId(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$a(untrustedConfig, getManagedContentByFolderId_ConfigPropertyNames);
+    const config = validateAdapterConfig$c(untrustedConfig, getManagedContentByFolderId_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$7, buildNetworkSnapshotCachePolicy$7);
+    buildCachedSnapshotCachePolicy$8, buildNetworkSnapshotCachePolicy$8);
 };
 
 function validate$f(obj, path = 'AbstractManagedContentReferencedByItemRepresentation') {
@@ -3709,8 +3709,8 @@ function deepFreeze$c(input) {
     ObjectFreeze(input);
 }
 
-const TTL$7 = 100;
-const VERSION$7 = "c297f5edbe1b51eadd89e68f176520ba";
+const TTL$8 = 100;
+const VERSION$8 = "c297f5edbe1b51eadd89e68f176520ba";
 function validate$e(obj, path = 'ManagedContentReferencedByCollectionRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -3770,19 +3770,19 @@ function validate$e(obj, path = 'ManagedContentReferencedByCollectionRepresentat
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$7 = 'ManagedContentReferencedByCollectionRepresentation';
-function normalize$7(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$8 = 'ManagedContentReferencedByCollectionRepresentation';
+function normalize$8(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$h = function ManagedContentReferencedByCollectionRepresentationSelect() {
+const select$k = function ManagedContentReferencedByCollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$7,
+        version: VERSION$8,
         private: [],
         opaque: true
     };
 };
-function equals$7(existing, incoming) {
+function equals$8(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
@@ -3797,7 +3797,7 @@ function deepFreeze$b(input) {
     ObjectFreeze(input_referencedBy);
     ObjectFreeze(input);
 }
-const ingest$7 = function ManagedContentReferencedByCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$8 = function ManagedContentReferencedByCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$e(input);
         if (validateError !== null) {
@@ -3806,56 +3806,56 @@ const ingest$7 = function ManagedContentReferencedByCollectionRepresentationInge
     }
     const key = path.fullPath;
     const existingRecord = store.readEntry(key);
-    const ttlToUse = TTL$7;
-    let incomingRecord = normalize$7(input, store.readEntry(key), {
+    const ttlToUse = TTL$8;
+    let incomingRecord = normalize$8(input, store.readEntry(key), {
         fullPath: key,
         parent: path.parent,
         propertyName: path.propertyName,
         ttl: ttlToUse
     });
     deepFreeze$b(input);
-    if (existingRecord === undefined || equals$7(existingRecord, incomingRecord) === false) {
+    if (existingRecord === undefined || equals$8(existingRecord, incomingRecord) === false) {
         luvio.storePublish(key, incomingRecord);
     }
     {
         const storeMetadataParams = {
             ttl: ttlToUse,
             namespace: "CMSAuthoring",
-            version: VERSION$7,
-            representationName: RepresentationType$7,
+            version: VERSION$8,
+            representationName: RepresentationType$8,
         };
         luvio.publishStoreMetadata(key, storeMetadataParams);
     }
     return createLink(key);
 };
-function getTypeCacheKeys$7(luvio, input, fullPathFactory) {
+function getTypeCacheKeys$8(luvio, input, fullPathFactory) {
     const rootKeySet = new StoreKeyMap();
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$7,
+        representationName: RepresentationType$8,
         mergeable: false
     });
     return rootKeySet;
 }
 
-function select$g(luvio, params) {
-    return select$h();
+function select$j(luvio, params) {
+    return select$k();
 }
-function keyBuilder$g(luvio, params) {
+function keyBuilder$j(luvio, params) {
     return keyPrefix + '::ManagedContentReferencedByCollectionRepresentation:(' + 'includeReferenceDetails:' + params.queryParams.includeReferenceDetails + ',' + 'page:' + params.queryParams.page + ',' + 'pageSize:' + params.queryParams.pageSize + ',' + 'referenceType:' + params.queryParams.referenceType + ',' + 'contentKeyOrId:' + params.urlParams.contentKeyOrId + ')';
 }
-function getResponseCacheKeys$9(luvio, resourceParams, response) {
-    return getTypeCacheKeys$7(luvio, response, () => keyBuilder$g(luvio, resourceParams));
+function getResponseCacheKeys$b(luvio, resourceParams, response) {
+    return getTypeCacheKeys$8(luvio, response, () => keyBuilder$j(luvio, resourceParams));
 }
-function ingestSuccess$9(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$b(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$g(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$7, body);
+    const key = keyBuilder$j(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$8, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$g(),
+        node: select$j(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -3865,19 +3865,19 @@ function ingestSuccess$9(luvio, resourceParams, response, snapshotRefresh) {
     }
     return snapshot;
 }
-function ingestError$6(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$g(luvio, params);
+function ingestError$7(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$j(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$7,
+        ttl: TTL$8,
         namespace: keyPrefix,
-        version: VERSION$7,
-        representationName: RepresentationType$7
+        version: VERSION$8,
+        representationName: RepresentationType$8
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$9(config) {
+function createResourceRequest$b(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -3898,7 +3898,7 @@ const getManagedContentReferencedBy_ConfigPropertyNames = {
         optional: ['includeReferenceDetails', 'page', 'pageSize', 'referenceType']
     }
 };
-function createResourceParams$9(config) {
+function createResourceParams$b(config) {
     const resourceParams = {
         urlParams: {
             contentKeyOrId: config.contentKeyOrId
@@ -3909,11 +3909,11 @@ function createResourceParams$9(config) {
     };
     return resourceParams;
 }
-function keyBuilder$f(luvio, config) {
-    const resourceParams = createResourceParams$9(config);
-    return keyBuilder$g(luvio, resourceParams);
+function keyBuilder$i(luvio, config) {
+    const resourceParams = createResourceParams$b(config);
+    return keyBuilder$j(luvio, resourceParams);
 }
-function typeCheckConfig$9(untrustedConfig) {
+function typeCheckConfig$b(untrustedConfig) {
     const config = {};
     const untrustedConfig_contentKeyOrId = untrustedConfig.contentKeyOrId;
     if (typeof untrustedConfig_contentKeyOrId === 'string') {
@@ -3937,48 +3937,48 @@ function typeCheckConfig$9(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$b(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$9(untrustedConfig);
+    const config = typeCheckConfig$b(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$6(luvio, config) {
-    createResourceParams$9(config);
-    return select$g();
+function adapterFragment$7(luvio, config) {
+    createResourceParams$b(config);
+    return select$j();
 }
-function onFetchResponseSuccess$6(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$9(luvio, resourceParams, response, {
+function onFetchResponseSuccess$7(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$b(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$b(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$6(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$6(luvio, resourceParams, response, {
+function onFetchResponseError$7(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$7(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$b(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$9(luvio, config, options) {
-    const resourceParams = createResourceParams$9(config);
-    const request = createResourceRequest$9(resourceParams);
+function buildNetworkSnapshot$b(luvio, config, options) {
+    const resourceParams = createResourceParams$b(config);
+    const request = createResourceRequest$b(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$6(luvio, config, resourceParams, response), () => getResponseCacheKeys$9(luvio, resourceParams, response.body));
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$7(luvio, config, resourceParams, response), () => getResponseCacheKeys$b(luvio, resourceParams, response.body));
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$6(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$7(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext) {
+function buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext) {
     const { luvio, config } = context;
     const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
     const dispatchOptions = {
@@ -3993,31 +3993,33 @@ function buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext
             priority: networkPriority
         };
     }
-    return buildNetworkSnapshot$9(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$b(luvio, config, dispatchOptions);
 }
-function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$f(luvio, config),
-        node: adapterFragment$6(luvio, config),
+        recordId: keyBuilder$i(luvio, config),
+        node: adapterFragment$7(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$b(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getManagedContentReferencedByAdapterFactory = (luvio) => function CMSAuthoring__getManagedContentReferencedBy(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$9(untrustedConfig, getManagedContentReferencedBy_ConfigPropertyNames);
+    const config = validateAdapterConfig$b(untrustedConfig, getManagedContentReferencedBy_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$6, buildNetworkSnapshotCachePolicy$6);
+    buildCachedSnapshotCachePolicy$7, buildNetworkSnapshotCachePolicy$7);
 };
 
+const TTL$7 = 100;
+const VERSION$7 = "72679343637cbdd587e2f087852030d7";
 function validate$d(obj, path = 'ManagedContentSpaceRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -4048,6 +4050,32 @@ function validate$d(obj, path = 'ManagedContentSpaceRepresentation') {
         if (typeof obj_id !== 'string') {
             return new TypeError('Expected "string" but received "' + typeof obj_id + '" (at "' + path_id + '")');
         }
+        const obj_isOrchestratorModuleInstalled = obj.isOrchestratorModuleInstalled;
+        const path_isOrchestratorModuleInstalled = path + '.isOrchestratorModuleInstalled';
+        let obj_isOrchestratorModuleInstalled_union0 = null;
+        const obj_isOrchestratorModuleInstalled_union0_error = (() => {
+            if (typeof obj_isOrchestratorModuleInstalled !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isOrchestratorModuleInstalled + '" (at "' + path_isOrchestratorModuleInstalled + '")');
+            }
+        })();
+        if (obj_isOrchestratorModuleInstalled_union0_error != null) {
+            obj_isOrchestratorModuleInstalled_union0 = obj_isOrchestratorModuleInstalled_union0_error.message;
+        }
+        let obj_isOrchestratorModuleInstalled_union1 = null;
+        const obj_isOrchestratorModuleInstalled_union1_error = (() => {
+            if (obj_isOrchestratorModuleInstalled !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_isOrchestratorModuleInstalled + '" (at "' + path_isOrchestratorModuleInstalled + '")');
+            }
+        })();
+        if (obj_isOrchestratorModuleInstalled_union1_error != null) {
+            obj_isOrchestratorModuleInstalled_union1 = obj_isOrchestratorModuleInstalled_union1_error.message;
+        }
+        if (obj_isOrchestratorModuleInstalled_union0 && obj_isOrchestratorModuleInstalled_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_isOrchestratorModuleInstalled + '")';
+            message += '\n' + obj_isOrchestratorModuleInstalled_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_isOrchestratorModuleInstalled_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
         if (obj.isSpaceV2 !== undefined) {
             const obj_isSpaceV2 = obj.isSpaceV2;
             const path_isSpaceV2 = path + '.isSpaceV2';
@@ -4092,16 +4120,283 @@ function validate$d(obj, path = 'ManagedContentSpaceRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
+const RepresentationType$7 = 'ManagedContentSpaceRepresentation';
+function keyBuilder$h(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$7 + ':' + config.id;
+}
+function keyBuilderFromType$3(luvio, object) {
+    const keyParams = {
+        id: object.id
+    };
+    return keyBuilder$h(luvio, keyParams);
+}
+function normalize$7(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$i = function ManagedContentSpaceRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$7,
+        private: [],
+        opaque: true
+    };
+};
+function equals$7(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
 function deepFreeze$a(input) {
     const input_supportedLanguages = input.supportedLanguages;
     if (input_supportedLanguages !== undefined) {
         ObjectFreeze(input_supportedLanguages);
     }
     ObjectFreeze(input);
+}
+const ingest$7 = function ManagedContentSpaceRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$d(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$3(luvio, input);
+    const existingRecord = store.readEntry(key);
+    const ttlToUse = TTL$7;
+    let incomingRecord = normalize$7(input, store.readEntry(key), {
+        fullPath: key,
+        parent: path.parent,
+        propertyName: path.propertyName,
+        ttl: ttlToUse
+    });
+    deepFreeze$a(input);
+    if (existingRecord === undefined || equals$7(existingRecord, incomingRecord) === false) {
+        luvio.storePublish(key, incomingRecord);
+    }
+    {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "CMSAuthoring",
+            version: VERSION$7,
+            representationName: RepresentationType$7,
+        };
+        luvio.publishStoreMetadata(key, storeMetadataParams);
+    }
+    return createLink(key);
+};
+function getTypeCacheKeys$7(luvio, input, fullPathFactory) {
+    const rootKeySet = new StoreKeyMap();
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$3(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$7,
+        mergeable: false
+    });
+    return rootKeySet;
+}
+
+function select$h(luvio, params) {
+    return select$i();
+}
+function keyBuilder$g(luvio, params) {
+    return keyBuilder$h(luvio, {
+        id: params.urlParams.contentSpaceId
+    });
+}
+function getResponseCacheKeys$a(luvio, resourceParams, response) {
+    return getTypeCacheKeys$7(luvio, response);
+}
+function ingestSuccess$a(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$g(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$7, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$h(),
+        variables: {},
+    }, snapshotRefresh);
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    return snapshot;
+}
+function ingestError$6(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$g(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    const storeMetadataParams = {
+        ttl: TTL$7,
+        namespace: keyPrefix,
+        version: VERSION$7,
+        representationName: RepresentationType$7
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
+function createResourceRequest$a(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/cms/spaces/' + config.urlParams.contentSpaceId + '',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+function createResourceRequestFromRepresentation$2(representation) {
+    const config = {
+        urlParams: {},
+    };
+    config.urlParams.contentSpaceId = representation.id;
+    return createResourceRequest$a(config);
 }
 
+const getManagedContentSpace_ConfigPropertyNames = {
+    displayName: 'getManagedContentSpace',
+    parameters: {
+        required: ['contentSpaceId'],
+        optional: []
+    }
+};
+function createResourceParams$a(config) {
+    const resourceParams = {
+        urlParams: {
+            contentSpaceId: config.contentSpaceId
+        }
+    };
+    return resourceParams;
+}
+function keyBuilder$f(luvio, config) {
+    const resourceParams = createResourceParams$a(config);
+    return keyBuilder$g(luvio, resourceParams);
+}
+function typeCheckConfig$a(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contentSpaceId = untrustedConfig.contentSpaceId;
+    if (typeof untrustedConfig_contentSpaceId === 'string') {
+        config.contentSpaceId = untrustedConfig_contentSpaceId;
+    }
+    return config;
+}
+function validateAdapterConfig$a(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$a(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment$6(luvio, config) {
+    createResourceParams$a(config);
+    return select$h();
+}
+function onFetchResponseSuccess$6(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$a(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError$6(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$6(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$a(luvio, config, options) {
+    const resourceParams = createResourceParams$a(config);
+    const request = createResourceRequest$a(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$6(luvio, config, resourceParams, response), () => getResponseCacheKeys$a(luvio, resourceParams, response.body));
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$6(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext) {
+    const { luvio, config } = context;
+    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
+    const dispatchOptions = {
+        resourceRequestContext: {
+            requestCorrelator,
+            luvioRequestMethod: undefined,
+        },
+        eventObservers
+    };
+    if (networkPriority !== 'normal') {
+        dispatchOptions.overrides = {
+            priority: networkPriority
+        };
+    }
+    return buildNetworkSnapshot$a(luvio, config, dispatchOptions);
+}
+function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$f(luvio, config),
+        node: adapterFragment$6(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getManagedContentSpaceAdapterFactory = (luvio) => function CMSAuthoring__getManagedContentSpace(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$a(untrustedConfig, getManagedContentSpace_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$6, buildNetworkSnapshotCachePolicy$6);
+};
+const notifyChangeFactory$2 = (luvio, options) => {
+    return function getConnectCmsSpacesByContentSpaceIdNotifyChange(configs) {
+        const keys = configs.map(c => keyBuilder$h(luvio, c));
+        luvio.getNotifyChangeStoreEntries(keys).then(entries => {
+            for (let i = 0, len = entries.length; i < len; i++) {
+                const { key, record: val } = entries[i];
+                const refreshRequest = createResourceRequestFromRepresentation$2(val);
+                luvio.dispatchResourceRequest(refreshRequest, options)
+                    .then((response) => {
+                    return luvio.handleSuccessResponse(() => {
+                        const { body } = response;
+                        luvio.storeIngest(key, ingest$7, body);
+                        return luvio.storeBroadcast();
+                    }, () => getTypeCacheKeys$7(luvio, response.body));
+                }, (error) => {
+                    return luvio.handleErrorResponse(() => {
+                        const errorSnapshot = luvio.errorSnapshot(error);
+                        luvio.storeIngestError(key, errorSnapshot, {
+                            ttl: TTL$7,
+                            namespace: keyPrefix,
+                            version: VERSION$7,
+                            representationName: RepresentationType$7
+                        });
+                        return luvio.storeBroadcast().then(() => errorSnapshot);
+                    });
+                });
+            }
+        });
+    };
+};
+
 const TTL$6 = 100;
-const VERSION$6 = "8bf10074a521799f8a3f77915051deb0";
+const VERSION$6 = "292efba3a426b62d2af39a38fd3464b0";
 function validate$c(obj, path = 'ManagedContentSpaceCollectionRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -4129,7 +4424,7 @@ const RepresentationType$6 = 'ManagedContentSpaceCollectionRepresentation';
 function normalize$6(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$f = function ManagedContentSpaceCollectionRepresentationSelect() {
+const select$g = function ManagedContentSpaceCollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$6,
@@ -4195,22 +4490,22 @@ function getTypeCacheKeys$6(luvio, input, fullPathFactory) {
     return rootKeySet;
 }
 
-function select$e(luvio, params) {
-    return select$f();
+function select$f(luvio, params) {
+    return select$g();
 }
 function keyBuilder$e(luvio, params) {
     return keyPrefix + '::ManagedContentSpaceCollectionRepresentation:(' + 'page:' + params.queryParams.page + ',' + 'pageSize:' + params.queryParams.pageSize + ')';
 }
-function getResponseCacheKeys$8(luvio, resourceParams, response) {
+function getResponseCacheKeys$9(luvio, resourceParams, response) {
     return getTypeCacheKeys$6(luvio, response, () => keyBuilder$e(luvio, resourceParams));
 }
-function ingestSuccess$8(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$9(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
     const key = keyBuilder$e(luvio, resourceParams);
     luvio.storeIngest(key, ingest$6, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$e(),
+        node: select$f(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -4232,7 +4527,7 @@ function ingestError$5(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$8(config) {
+function createResourceRequest$9(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -4253,7 +4548,7 @@ const getManagedContentSpaces_ConfigPropertyNames = {
         optional: ['page', 'pageSize']
     }
 };
-function createResourceParams$8(config) {
+function createResourceParams$9(config) {
     const resourceParams = {
         queryParams: {
             page: config.page, pageSize: config.pageSize
@@ -4262,10 +4557,10 @@ function createResourceParams$8(config) {
     return resourceParams;
 }
 function keyBuilder$d(luvio, config) {
-    const resourceParams = createResourceParams$8(config);
+    const resourceParams = createResourceParams$9(config);
     return keyBuilder$e(luvio, resourceParams);
 }
-function typeCheckConfig$8(untrustedConfig) {
+function typeCheckConfig$9(untrustedConfig) {
     const config = {};
     const untrustedConfig_page = untrustedConfig.page;
     if (typeof untrustedConfig_page === 'number' && Math.floor(untrustedConfig_page) === untrustedConfig_page) {
@@ -4277,43 +4572,43 @@ function typeCheckConfig$8(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$8(untrustedConfig);
+    const config = typeCheckConfig$9(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$5(luvio, config) {
-    createResourceParams$8(config);
-    return select$e();
+    createResourceParams$9(config);
+    return select$f();
 }
 function onFetchResponseSuccess$5(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$8(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$9(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$5(luvio, config, resourceParams, response) {
     const snapshot = ingestError$5(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$8(luvio, config, options) {
-    const resourceParams = createResourceParams$8(config);
-    const request = createResourceRequest$8(resourceParams);
+function buildNetworkSnapshot$9(luvio, config, options) {
+    const resourceParams = createResourceParams$9(config);
+    const request = createResourceRequest$9(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$5(luvio, config, resourceParams, response), () => getResponseCacheKeys$8(luvio, resourceParams, response.body));
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$5(luvio, config, resourceParams, response), () => getResponseCacheKeys$9(luvio, resourceParams, response.body));
     }, (response) => {
         return luvio.handleErrorResponse(() => onFetchResponseError$5(luvio, config, resourceParams, response));
     });
@@ -4333,7 +4628,7 @@ function buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext
             priority: networkPriority
         };
     }
-    return buildNetworkSnapshot$8(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$9(luvio, config, dispatchOptions);
 }
 function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
     const { luvio, config } = context;
@@ -4344,12 +4639,12 @@ function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getManagedContentSpacesAdapterFactory = (luvio) => function CMSAuthoring__getManagedContentSpaces(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$8(untrustedConfig, getManagedContentSpaces_ConfigPropertyNames);
+    const config = validateAdapterConfig$9(untrustedConfig, getManagedContentSpaces_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -4358,24 +4653,24 @@ const getManagedContentSpacesAdapterFactory = (luvio) => function CMSAuthoring__
     buildCachedSnapshotCachePolicy$5, buildNetworkSnapshotCachePolicy$5);
 };
 
-function select$d(luvio, params) {
-    return select$q();
+function select$e(luvio, params) {
+    return select$t();
 }
 function keyBuilder$c(luvio, params) {
-    return keyBuilder$q(luvio, {
+    return keyBuilder$t(luvio, {
         id: params.urlParams.variantId
     });
 }
-function getResponseCacheKeys$7(luvio, resourceParams, response) {
-    return getTypeCacheKeys$b(luvio, response);
+function getResponseCacheKeys$8(luvio, resourceParams, response) {
+    return getTypeCacheKeys$c(luvio, response);
 }
-function ingestSuccess$7(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$8(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
     const key = keyBuilder$c(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$b, body);
+    luvio.storeIngest(key, ingest$c, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$d(),
+        node: select$e(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -4389,15 +4684,15 @@ function ingestError$4(luvio, params, error, snapshotRefresh) {
     const key = keyBuilder$c(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$b,
+        ttl: TTL$c,
         namespace: keyPrefix,
-        version: VERSION$b,
-        representationName: RepresentationType$b
+        version: VERSION$c,
+        representationName: RepresentationType$c
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$7(config) {
+function createResourceRequest$8(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -4415,7 +4710,7 @@ function createResourceRequestFromRepresentation$1(representation) {
         urlParams: {},
     };
     config.urlParams.variantId = representation.managedContentVariantId;
-    return createResourceRequest$7(config);
+    return createResourceRequest$8(config);
 }
 
 const getManagedContentVariant_ConfigPropertyNames = {
@@ -4425,7 +4720,7 @@ const getManagedContentVariant_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$7(config) {
+function createResourceParams$8(config) {
     const resourceParams = {
         urlParams: {
             variantId: config.variantId
@@ -4434,10 +4729,10 @@ function createResourceParams$7(config) {
     return resourceParams;
 }
 function keyBuilder$b(luvio, config) {
-    const resourceParams = createResourceParams$7(config);
+    const resourceParams = createResourceParams$8(config);
     return keyBuilder$c(luvio, resourceParams);
 }
-function typeCheckConfig$7(untrustedConfig) {
+function typeCheckConfig$8(untrustedConfig) {
     const config = {};
     const untrustedConfig_variantId = untrustedConfig.variantId;
     if (typeof untrustedConfig_variantId === 'string') {
@@ -4445,43 +4740,43 @@ function typeCheckConfig$7(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$7(untrustedConfig);
+    const config = typeCheckConfig$8(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$4(luvio, config) {
-    createResourceParams$7(config);
-    return select$d();
+    createResourceParams$8(config);
+    return select$e();
 }
 function onFetchResponseSuccess$4(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$7(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$8(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$4(luvio, config, resourceParams, response) {
     const snapshot = ingestError$4(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$7(luvio, config, options) {
-    const resourceParams = createResourceParams$7(config);
-    const request = createResourceRequest$7(resourceParams);
+function buildNetworkSnapshot$8(luvio, config, options) {
+    const resourceParams = createResourceParams$8(config);
+    const request = createResourceRequest$8(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$4(luvio, config, resourceParams, response), () => getResponseCacheKeys$7(luvio, resourceParams, response.body));
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$4(luvio, config, resourceParams, response), () => getResponseCacheKeys$8(luvio, resourceParams, response.body));
     }, (response) => {
         return luvio.handleErrorResponse(() => onFetchResponseError$4(luvio, config, resourceParams, response));
     });
@@ -4501,7 +4796,7 @@ function buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext
             priority: networkPriority
         };
     }
-    return buildNetworkSnapshot$7(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$8(luvio, config, dispatchOptions);
 }
 function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
     const { luvio, config } = context;
@@ -4512,12 +4807,12 @@ function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getManagedContentVariantAdapterFactory = (luvio) => function CMSAuthoring__getManagedContentVariant(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$7(untrustedConfig, getManagedContentVariant_ConfigPropertyNames);
+    const config = validateAdapterConfig$8(untrustedConfig, getManagedContentVariant_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -4527,7 +4822,7 @@ const getManagedContentVariantAdapterFactory = (luvio) => function CMSAuthoring_
 };
 const notifyChangeFactory$1 = (luvio, options) => {
     return function getConnectCmsContentsVariantsByVariantIdNotifyChange(configs) {
-        const keys = configs.map(c => keyBuilder$q(luvio, c));
+        const keys = configs.map(c => keyBuilder$t(luvio, c));
         luvio.getNotifyChangeStoreEntries(keys).then(entries => {
             for (let i = 0, len = entries.length; i < len; i++) {
                 const { key, record: val } = entries[i];
@@ -4536,17 +4831,17 @@ const notifyChangeFactory$1 = (luvio, options) => {
                     .then((response) => {
                     return luvio.handleSuccessResponse(() => {
                         const { body } = response;
-                        luvio.storeIngest(key, ingest$b, body);
+                        luvio.storeIngest(key, ingest$c, body);
                         return luvio.storeBroadcast();
-                    }, () => getTypeCacheKeys$b(luvio, response.body));
+                    }, () => getTypeCacheKeys$c(luvio, response.body));
                 }, (error) => {
                     return luvio.handleErrorResponse(() => {
                         const errorSnapshot = luvio.errorSnapshot(error);
                         luvio.storeIngestError(key, errorSnapshot, {
-                            ttl: TTL$b,
+                            ttl: TTL$c,
                             namespace: keyPrefix,
-                            version: VERSION$b,
-                            representationName: RepresentationType$b
+                            version: VERSION$c,
+                            representationName: RepresentationType$c
                         });
                         return luvio.storeBroadcast().then(() => errorSnapshot);
                     });
@@ -4691,7 +4986,7 @@ const RepresentationType$5 = 'ManagedContentVariantReferencesCollectionRepresent
 function normalize$5(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$c = function ManagedContentVariantReferencesCollectionRepresentationSelect() {
+const select$d = function ManagedContentVariantReferencesCollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$5,
@@ -4764,22 +5059,22 @@ function getTypeCacheKeys$5(luvio, input, fullPathFactory) {
     return rootKeySet;
 }
 
-function select$b(luvio, params) {
-    return select$c();
+function select$c(luvio, params) {
+    return select$d();
 }
 function keyBuilder$a(luvio, params) {
     return keyPrefix + '::ManagedContentVariantReferencesCollectionRepresentation:(' + 'variantIds:' + params.queryParams.variantIds + ',' + 'contentKeyOrId:' + params.urlParams.contentKeyOrId + ')';
 }
-function getResponseCacheKeys$6(luvio, resourceParams, response) {
+function getResponseCacheKeys$7(luvio, resourceParams, response) {
     return getTypeCacheKeys$5(luvio, response, () => keyBuilder$a(luvio, resourceParams));
 }
-function ingestSuccess$6(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$7(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
     const key = keyBuilder$a(luvio, resourceParams);
     luvio.storeIngest(key, ingest$5, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$b(),
+        node: select$c(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -4801,7 +5096,7 @@ function ingestError$3(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$6(config) {
+function createResourceRequest$7(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -4822,7 +5117,7 @@ const getManagedContentVariantReferences_ConfigPropertyNames = {
         optional: ['variantIds']
     }
 };
-function createResourceParams$6(config) {
+function createResourceParams$7(config) {
     const resourceParams = {
         urlParams: {
             contentKeyOrId: config.contentKeyOrId
@@ -4834,10 +5129,10 @@ function createResourceParams$6(config) {
     return resourceParams;
 }
 function keyBuilder$9(luvio, config) {
-    const resourceParams = createResourceParams$6(config);
+    const resourceParams = createResourceParams$7(config);
     return keyBuilder$a(luvio, resourceParams);
 }
-function typeCheckConfig$6(untrustedConfig) {
+function typeCheckConfig$7(untrustedConfig) {
     const config = {};
     const untrustedConfig_contentKeyOrId = untrustedConfig.contentKeyOrId;
     if (typeof untrustedConfig_contentKeyOrId === 'string') {
@@ -4856,43 +5151,43 @@ function typeCheckConfig$6(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$6(untrustedConfig);
+    const config = typeCheckConfig$7(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$3(luvio, config) {
-    createResourceParams$6(config);
-    return select$b();
+    createResourceParams$7(config);
+    return select$c();
 }
 function onFetchResponseSuccess$3(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$6(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$7(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$3(luvio, config, resourceParams, response) {
     const snapshot = ingestError$3(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$6(luvio, config, options) {
-    const resourceParams = createResourceParams$6(config);
-    const request = createResourceRequest$6(resourceParams);
+function buildNetworkSnapshot$7(luvio, config, options) {
+    const resourceParams = createResourceParams$7(config);
+    const request = createResourceRequest$7(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$3(luvio, config, resourceParams, response), () => getResponseCacheKeys$6(luvio, resourceParams, response.body));
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$3(luvio, config, resourceParams, response), () => getResponseCacheKeys$7(luvio, resourceParams, response.body));
     }, (response) => {
         return luvio.handleErrorResponse(() => onFetchResponseError$3(luvio, config, resourceParams, response));
     });
@@ -4912,7 +5207,7 @@ function buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext
             priority: networkPriority
         };
     }
-    return buildNetworkSnapshot$6(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$7(luvio, config, dispatchOptions);
 }
 function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
     const { luvio, config } = context;
@@ -4923,12 +5218,12 @@ function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getManagedContentVariantReferencesAdapterFactory = (luvio) => function CMSAuthoring__getManagedContentVariantReferences(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$6(untrustedConfig, getManagedContentVariantReferences_ConfigPropertyNames);
+    const config = validateAdapterConfig$7(untrustedConfig, getManagedContentVariantReferences_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -4994,7 +5289,7 @@ const RepresentationType$4 = 'ManagedContentRenditionRepresentation';
 function normalize$4(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$a = function ManagedContentRenditionRepresentationSelect() {
+const select$b = function ManagedContentRenditionRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$4,
@@ -5072,22 +5367,22 @@ function getTypeCacheKeys$4(luvio, input, fullPathFactory) {
     return rootKeySet;
 }
 
-function select$9(luvio, params) {
-    return select$a();
+function select$a(luvio, params) {
+    return select$b();
 }
 function keyBuilder$8(luvio, params) {
     return keyPrefix + '::ManagedContentRenditionRepresentation:(' + 'channelIdOrApiName:' + params.queryParams.channelIdOrApiName + ',' + 'language:' + params.queryParams.language + ',' + 'version:' + params.queryParams.version + ',' + 'contentKeyOrId:' + params.urlParams.contentKeyOrId + ',' + 'renditionType:' + params.urlParams.renditionType + ')';
 }
-function getResponseCacheKeys$5(luvio, resourceParams, response) {
+function getResponseCacheKeys$6(luvio, resourceParams, response) {
     return getTypeCacheKeys$4(luvio, response, () => keyBuilder$8(luvio, resourceParams));
 }
-function ingestSuccess$5(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$6(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
     const key = keyBuilder$8(luvio, resourceParams);
     luvio.storeIngest(key, ingest$4, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$9(),
+        node: select$a(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -5109,7 +5404,7 @@ function ingestError$2(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$5(config) {
+function createResourceRequest$6(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -5130,7 +5425,7 @@ const getManagedContentVariantRendition_ConfigPropertyNames = {
         optional: ['channelIdOrApiName', 'language', 'version']
     }
 };
-function createResourceParams$5(config) {
+function createResourceParams$6(config) {
     const resourceParams = {
         urlParams: {
             contentKeyOrId: config.contentKeyOrId, renditionType: config.renditionType
@@ -5142,10 +5437,10 @@ function createResourceParams$5(config) {
     return resourceParams;
 }
 function keyBuilder$7(luvio, config) {
-    const resourceParams = createResourceParams$5(config);
+    const resourceParams = createResourceParams$6(config);
     return keyBuilder$8(luvio, resourceParams);
 }
-function typeCheckConfig$5(untrustedConfig) {
+function typeCheckConfig$6(untrustedConfig) {
     const config = {};
     const untrustedConfig_contentKeyOrId = untrustedConfig.contentKeyOrId;
     if (typeof untrustedConfig_contentKeyOrId === 'string') {
@@ -5169,43 +5464,43 @@ function typeCheckConfig$5(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$5(untrustedConfig);
+    const config = typeCheckConfig$6(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$2(luvio, config) {
-    createResourceParams$5(config);
-    return select$9();
+    createResourceParams$6(config);
+    return select$a();
 }
 function onFetchResponseSuccess$2(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$5(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$6(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$2(luvio, config, resourceParams, response) {
     const snapshot = ingestError$2(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$5(luvio, config, options) {
-    const resourceParams = createResourceParams$5(config);
-    const request = createResourceRequest$5(resourceParams);
+function buildNetworkSnapshot$6(luvio, config, options) {
+    const resourceParams = createResourceParams$6(config);
+    const request = createResourceRequest$6(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$2(luvio, config, resourceParams, response), () => getResponseCacheKeys$5(luvio, resourceParams, response.body));
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$2(luvio, config, resourceParams, response), () => getResponseCacheKeys$6(luvio, resourceParams, response.body));
     }, (response) => {
         return luvio.handleErrorResponse(() => onFetchResponseError$2(luvio, config, resourceParams, response));
     });
@@ -5225,7 +5520,7 @@ function buildNetworkSnapshotCachePolicy$2(context, coercedAdapterRequestContext
             priority: networkPriority
         };
     }
-    return buildNetworkSnapshot$5(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$6(luvio, config, dispatchOptions);
 }
 function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
     const { luvio, config } = context;
@@ -5236,12 +5531,12 @@ function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getManagedContentVariantRenditionAdapterFactory = (luvio) => function CMSAuthoring__getManagedContentVariantRendition(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$5(untrustedConfig, getManagedContentVariantRendition_ConfigPropertyNames);
+    const config = validateAdapterConfig$6(untrustedConfig, getManagedContentVariantRendition_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -5372,7 +5667,7 @@ function keyBuilderFromType$2(luvio, object) {
 function normalize$3(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$8 = function ManagedContentVariantVersionCollectionRepresentationSelect() {
+const select$9 = function ManagedContentVariantVersionCollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$3,
@@ -5438,24 +5733,24 @@ function getTypeCacheKeys$3(luvio, input, fullPathFactory) {
     return rootKeySet;
 }
 
-function select$7(luvio, params) {
-    return select$8();
+function select$8(luvio, params) {
+    return select$9();
 }
 function keyBuilder$5(luvio, params) {
     return keyBuilder$6(luvio, {
         variantId: params.urlParams.variantId
     });
 }
-function getResponseCacheKeys$4(luvio, resourceParams, response) {
+function getResponseCacheKeys$5(luvio, resourceParams, response) {
     return getTypeCacheKeys$3(luvio, response);
 }
-function ingestSuccess$4(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$5(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
     const key = keyBuilder$5(luvio, resourceParams);
     luvio.storeIngest(key, ingest$3, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$7(),
+        node: select$8(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -5477,7 +5772,7 @@ function ingestError$1(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$4(config) {
+function createResourceRequest$5(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -5496,7 +5791,7 @@ function createResourceRequestFromRepresentation(representation) {
         queryParams: {},
     };
     config.urlParams.variantId = representation.managedContentVariantId;
-    return createResourceRequest$4(config);
+    return createResourceRequest$5(config);
 }
 
 const getManagedContentVariantVersions_ConfigPropertyNames = {
@@ -5506,7 +5801,7 @@ const getManagedContentVariantVersions_ConfigPropertyNames = {
         optional: ['page', 'pageSize', 'status']
     }
 };
-function createResourceParams$4(config) {
+function createResourceParams$5(config) {
     const resourceParams = {
         urlParams: {
             variantId: config.variantId
@@ -5518,10 +5813,10 @@ function createResourceParams$4(config) {
     return resourceParams;
 }
 function keyBuilder$4(luvio, config) {
-    const resourceParams = createResourceParams$4(config);
+    const resourceParams = createResourceParams$5(config);
     return keyBuilder$5(luvio, resourceParams);
 }
-function typeCheckConfig$4(untrustedConfig) {
+function typeCheckConfig$5(untrustedConfig) {
     const config = {};
     const untrustedConfig_variantId = untrustedConfig.variantId;
     if (typeof untrustedConfig_variantId === 'string') {
@@ -5548,43 +5843,43 @@ function typeCheckConfig$4(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$4(untrustedConfig);
+    const config = typeCheckConfig$5(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$1(luvio, config) {
-    createResourceParams$4(config);
-    return select$7();
+    createResourceParams$5(config);
+    return select$8();
 }
 function onFetchResponseSuccess$1(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$4(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$5(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$1(luvio, config, resourceParams, response) {
     const snapshot = ingestError$1(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$4(luvio, config, options) {
-    const resourceParams = createResourceParams$4(config);
-    const request = createResourceRequest$4(resourceParams);
+function buildNetworkSnapshot$5(luvio, config, options) {
+    const resourceParams = createResourceParams$5(config);
+    const request = createResourceRequest$5(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$1(luvio, config, resourceParams, response), () => getResponseCacheKeys$4(luvio, resourceParams, response.body));
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$1(luvio, config, resourceParams, response), () => getResponseCacheKeys$5(luvio, resourceParams, response.body));
     }, (response) => {
         return luvio.handleErrorResponse(() => onFetchResponseError$1(luvio, config, resourceParams, response));
     });
@@ -5604,7 +5899,7 @@ function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext
             priority: networkPriority
         };
     }
-    return buildNetworkSnapshot$4(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$5(luvio, config, dispatchOptions);
 }
 function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
     const { luvio, config } = context;
@@ -5615,12 +5910,12 @@ function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getManagedContentVariantVersionsAdapterFactory = (luvio) => function CMSAuthoring__getManagedContentVariantVersions(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$4(untrustedConfig, getManagedContentVariantVersions_ConfigPropertyNames);
+    const config = validateAdapterConfig$5(untrustedConfig, getManagedContentVariantVersions_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -5770,7 +6065,7 @@ const RepresentationType$2 = 'ManagedContentSearchResultItemsCollectionRepresent
 function normalize$2(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$6 = function ManagedContentSearchResultItemsCollectionRepresentationSelect() {
+const select$7 = function ManagedContentSearchResultItemsCollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$2,
@@ -5836,22 +6131,22 @@ function getTypeCacheKeys$2(luvio, input, fullPathFactory) {
     return rootKeySet;
 }
 
-function select$5(luvio, params) {
-    return select$6();
+function select$6(luvio, params) {
+    return select$7();
 }
 function keyBuilder$3(luvio, params) {
     return keyPrefix + '::ManagedContentSearchResultItemsCollectionRepresentation:(' + 'contentSpaceOrFolderIds:' + params.queryParams.contentSpaceOrFolderIds + ',' + 'contentTypeFQN:' + params.queryParams.contentTypeFQN + ',' + 'languages:' + params.queryParams.languages + ',' + 'page:' + params.queryParams.page + ',' + 'pageSize:' + params.queryParams.pageSize + ',' + 'queryTerm:' + params.queryParams.queryTerm + ',' + 'scope:' + params.queryParams.scope + ')';
 }
-function getResponseCacheKeys$3(luvio, resourceParams, response) {
+function getResponseCacheKeys$4(luvio, resourceParams, response) {
     return getTypeCacheKeys$2(luvio, response, () => keyBuilder$3(luvio, resourceParams));
 }
-function ingestSuccess$3(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$4(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
     const key = keyBuilder$3(luvio, resourceParams);
     luvio.storeIngest(key, ingest$2, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$5(),
+        node: select$6(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -5873,7 +6168,7 @@ function ingestError(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$3(config) {
+function createResourceRequest$4(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -5894,7 +6189,7 @@ const getSearchResults_ConfigPropertyNames = {
         optional: ['contentSpaceOrFolderIds', 'contentTypeFQN', 'languages', 'page', 'pageSize', 'scope']
     }
 };
-function createResourceParams$3(config) {
+function createResourceParams$4(config) {
     const resourceParams = {
         queryParams: {
             contentSpaceOrFolderIds: config.contentSpaceOrFolderIds, contentTypeFQN: config.contentTypeFQN, languages: config.languages, page: config.page, pageSize: config.pageSize, queryTerm: config.queryTerm, scope: config.scope
@@ -5903,10 +6198,10 @@ function createResourceParams$3(config) {
     return resourceParams;
 }
 function keyBuilder$2(luvio, config) {
-    const resourceParams = createResourceParams$3(config);
+    const resourceParams = createResourceParams$4(config);
     return keyBuilder$3(luvio, resourceParams);
 }
-function typeCheckConfig$3(untrustedConfig) {
+function typeCheckConfig$4(untrustedConfig) {
     const config = {};
     const untrustedConfig_contentSpaceOrFolderIds = untrustedConfig.contentSpaceOrFolderIds;
     if (ArrayIsArray$1(untrustedConfig_contentSpaceOrFolderIds)) {
@@ -5952,43 +6247,43 @@ function typeCheckConfig$3(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$3(untrustedConfig);
+    const config = typeCheckConfig$4(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment(luvio, config) {
-    createResourceParams$3(config);
-    return select$5();
+    createResourceParams$4(config);
+    return select$6();
 }
 function onFetchResponseSuccess(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$3(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$4(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError(luvio, config, resourceParams, response) {
     const snapshot = ingestError(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$3(luvio, config, options) {
-    const resourceParams = createResourceParams$3(config);
-    const request = createResourceRequest$3(resourceParams);
+function buildNetworkSnapshot$4(luvio, config, options) {
+    const resourceParams = createResourceParams$4(config);
+    const request = createResourceRequest$4(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess(luvio, config, resourceParams, response), () => getResponseCacheKeys$3(luvio, resourceParams, response.body));
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess(luvio, config, resourceParams, response), () => getResponseCacheKeys$4(luvio, resourceParams, response.body));
     }, (response) => {
         return luvio.handleErrorResponse(() => onFetchResponseError(luvio, config, resourceParams, response));
     });
@@ -6008,7 +6303,7 @@ function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext)
             priority: networkPriority
         };
     }
-    return buildNetworkSnapshot$3(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$4(luvio, config, dispatchOptions);
 }
 function buildCachedSnapshotCachePolicy(context, storeLookup) {
     const { luvio, config } = context;
@@ -6019,12 +6314,12 @@ function buildCachedSnapshotCachePolicy(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getSearchResultsAdapterFactory = (luvio) => function CMSAuthoring__getSearchResults(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$3(untrustedConfig, getSearchResults_ConfigPropertyNames);
+    const config = validateAdapterConfig$4(untrustedConfig, getSearchResults_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -6033,6 +6328,162 @@ const getSearchResultsAdapterFactory = (luvio) => function CMSAuthoring__getSear
     buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
 };
 
+function select$5(luvio, params) {
+    return select$i();
+}
+function getResponseCacheKeys$3(luvio, resourceParams, response) {
+    return getTypeCacheKeys$7(luvio, response);
+}
+function ingestSuccess$3(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$3(luvio, body);
+    luvio.storeIngest(key, ingest$7, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$5(),
+        variables: {},
+    });
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    return snapshot;
+}
+function createResourceRequest$3(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/cms/spaces/' + config.urlParams.contentSpaceId + '',
+        method: 'patch',
+        body: config.body,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const patchManagedContentSpace_ConfigPropertyNames = {
+    displayName: 'patchManagedContentSpace',
+    parameters: {
+        required: ['contentSpaceId', 'channels', 'collaborators', 'defaultLanguage', 'description', 'isSpaceV2', 'isUndeletable', 'name', 'supportedLanguages'],
+        optional: []
+    }
+};
+function createResourceParams$3(config) {
+    const resourceParams = {
+        urlParams: {
+            contentSpaceId: config.contentSpaceId
+        },
+        body: {
+            channels: config.channels, collaborators: config.collaborators, defaultLanguage: config.defaultLanguage, description: config.description, isSpaceV2: config.isSpaceV2, isUndeletable: config.isUndeletable, name: config.name, supportedLanguages: config.supportedLanguages
+        }
+    };
+    return resourceParams;
+}
+function typeCheckConfig$3(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contentSpaceId = untrustedConfig.contentSpaceId;
+    if (typeof untrustedConfig_contentSpaceId === 'string') {
+        config.contentSpaceId = untrustedConfig_contentSpaceId;
+    }
+    const untrustedConfig_channels = untrustedConfig.channels;
+    if (ArrayIsArray$1(untrustedConfig_channels)) {
+        const untrustedConfig_channels_array = [];
+        for (let i = 0, arrayLength = untrustedConfig_channels.length; i < arrayLength; i++) {
+            const untrustedConfig_channels_item = untrustedConfig_channels[i];
+            if (typeof untrustedConfig_channels_item === 'string') {
+                untrustedConfig_channels_array.push(untrustedConfig_channels_item);
+            }
+        }
+        config.channels = untrustedConfig_channels_array;
+    }
+    const untrustedConfig_collaborators = untrustedConfig.collaborators;
+    if (ArrayIsArray$1(untrustedConfig_collaborators)) {
+        const untrustedConfig_collaborators_array = [];
+        for (let i = 0, arrayLength = untrustedConfig_collaborators.length; i < arrayLength; i++) {
+            const untrustedConfig_collaborators_item = untrustedConfig_collaborators[i];
+            if (untrustedIsObject(untrustedConfig_collaborators_item)) {
+                const untrustedConfig_collaborators_item_object = {};
+                if (untrustedConfig_collaborators_item_object !== undefined && Object.keys(untrustedConfig_collaborators_item_object).length >= 0) {
+                    untrustedConfig_collaborators_array.push(untrustedConfig_collaborators_item_object);
+                }
+            }
+        }
+        config.collaborators = untrustedConfig_collaborators_array;
+    }
+    const untrustedConfig_defaultLanguage = untrustedConfig.defaultLanguage;
+    if (typeof untrustedConfig_defaultLanguage === 'string') {
+        config.defaultLanguage = untrustedConfig_defaultLanguage;
+    }
+    const untrustedConfig_description = untrustedConfig.description;
+    if (typeof untrustedConfig_description === 'string') {
+        config.description = untrustedConfig_description;
+    }
+    const untrustedConfig_isSpaceV2 = untrustedConfig.isSpaceV2;
+    if (typeof untrustedConfig_isSpaceV2 === 'boolean') {
+        config.isSpaceV2 = untrustedConfig_isSpaceV2;
+    }
+    const untrustedConfig_isUndeletable = untrustedConfig.isUndeletable;
+    if (typeof untrustedConfig_isUndeletable === 'boolean') {
+        config.isUndeletable = untrustedConfig_isUndeletable;
+    }
+    const untrustedConfig_name = untrustedConfig.name;
+    if (typeof untrustedConfig_name === 'string') {
+        config.name = untrustedConfig_name;
+    }
+    const untrustedConfig_supportedLanguages = untrustedConfig.supportedLanguages;
+    if (ArrayIsArray$1(untrustedConfig_supportedLanguages)) {
+        const untrustedConfig_supportedLanguages_array = [];
+        for (let i = 0, arrayLength = untrustedConfig_supportedLanguages.length; i < arrayLength; i++) {
+            const untrustedConfig_supportedLanguages_item = untrustedConfig_supportedLanguages[i];
+            if (typeof untrustedConfig_supportedLanguages_item === 'string') {
+                untrustedConfig_supportedLanguages_array.push(untrustedConfig_supportedLanguages_item);
+            }
+        }
+        config.supportedLanguages = untrustedConfig_supportedLanguages_array;
+    }
+    return config;
+}
+function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$3(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$3(luvio, config, options) {
+    const resourceParams = createResourceParams$3(config);
+    const request = createResourceRequest$3(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$3(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => getResponseCacheKeys$3(luvio, resourceParams, response.body));
+    }, (response) => {
+        deepFreeze$u(response);
+        throw response;
+    });
+}
+const patchManagedContentSpaceAdapterFactory = (luvio) => {
+    return function patchManagedContentSpace(untrustedConfig) {
+        const config = validateAdapterConfig$3(untrustedConfig, patchManagedContentSpace_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "patchManagedContentSpace"');
+        }
+        return buildNetworkSnapshot$3(luvio, config);
+    };
+};
+
 function validate$4(obj, path = 'ManagedContentPublishInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -6356,15 +6807,15 @@ function validate$2(obj, path = 'ManagedContentVariantUpdateInputRepresentation'
 }
 
 function select$2(luvio, params) {
-    return select$q();
+    return select$t();
 }
 function getResponseCacheKeys$1(luvio, resourceParams, response) {
-    return getTypeCacheKeys$b(luvio, response);
+    return getTypeCacheKeys$c(luvio, response);
 }
 function ingestSuccess$1(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$5(luvio, body);
-    luvio.storeIngest(key, ingest$b, body);
+    const key = keyBuilderFromType$6(luvio, body);
+    luvio.storeIngest(key, ingest$c, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
         node: select$2(),
@@ -6753,6 +7204,8 @@ let getCollectionItems;
 let getManagedContent;
 let getManagedContentByFolderId;
 let getManagedContentReferencedBy;
+let getManagedContentSpace;
+let getManagedContentSpaceNotifyChange;
 let getManagedContentSpaces;
 let getManagedContentVariant;
 let getManagedContentVariantNotifyChange;
@@ -6761,6 +7214,7 @@ let getManagedContentVariantRendition;
 let getManagedContentVariantVersions;
 let getManagedContentVariantVersionsNotifyChange;
 let getSearchResults;
+let patchManagedContentSpace;
 let publishManagedContent;
 let replaceManagedContentVariant;
 let unpublishManagedContent;
@@ -6769,6 +7223,7 @@ let getCollectionItems_imperative;
 let getManagedContent_imperative;
 let getManagedContentByFolderId_imperative;
 let getManagedContentReferencedBy_imperative;
+let getManagedContentSpace_imperative;
 let getManagedContentSpaces_imperative;
 let getManagedContentVariant_imperative;
 let getManagedContentVariantReferences_imperative;
@@ -6779,6 +7234,7 @@ const getCollectionItemsMetadata = { apiFamily: 'CMSAuthoring', name: 'getCollec
 const getManagedContentMetadata = { apiFamily: 'CMSAuthoring', name: 'getManagedContent', ttl: 100 };
 const getManagedContentByFolderIdMetadata = { apiFamily: 'CMSAuthoring', name: 'getManagedContentByFolderId', ttl: 100 };
 const getManagedContentReferencedByMetadata = { apiFamily: 'CMSAuthoring', name: 'getManagedContentReferencedBy', ttl: 100 };
+const getManagedContentSpaceMetadata = { apiFamily: 'CMSAuthoring', name: 'getManagedContentSpace', ttl: 100 };
 const getManagedContentSpacesMetadata = { apiFamily: 'CMSAuthoring', name: 'getManagedContentSpaces', ttl: 100 };
 const getManagedContentVariantMetadata = { apiFamily: 'CMSAuthoring', name: 'getManagedContentVariant', ttl: 3600000 };
 const getManagedContentVariantReferencesMetadata = { apiFamily: 'CMSAuthoring', name: 'getManagedContentVariantReferences', ttl: 100 };
@@ -6791,6 +7247,7 @@ function bindExportsTo(luvio) {
     const getManagedContent_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getManagedContent', getManagedContentAdapterFactory), getManagedContentMetadata);
     const getManagedContentByFolderId_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getManagedContentByFolderId', getManagedContentByFolderIdAdapterFactory), getManagedContentByFolderIdMetadata);
     const getManagedContentReferencedBy_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getManagedContentReferencedBy', getManagedContentReferencedByAdapterFactory), getManagedContentReferencedByMetadata);
+    const getManagedContentSpace_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getManagedContentSpace', getManagedContentSpaceAdapterFactory), getManagedContentSpaceMetadata);
     const getManagedContentSpaces_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getManagedContentSpaces', getManagedContentSpacesAdapterFactory), getManagedContentSpacesMetadata);
     const getManagedContentVariant_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getManagedContentVariant', getManagedContentVariantAdapterFactory), getManagedContentVariantMetadata);
     const getManagedContentVariantReferences_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getManagedContentVariantReferences', getManagedContentVariantReferencesAdapterFactory), getManagedContentVariantReferencesMetadata);
@@ -6813,6 +7270,8 @@ function bindExportsTo(luvio) {
         getManagedContent: createWireAdapterConstructor(luvio, getManagedContent_ldsAdapter, getManagedContentMetadata),
         getManagedContentByFolderId: createWireAdapterConstructor(luvio, getManagedContentByFolderId_ldsAdapter, getManagedContentByFolderIdMetadata),
         getManagedContentReferencedBy: createWireAdapterConstructor(luvio, getManagedContentReferencedBy_ldsAdapter, getManagedContentReferencedByMetadata),
+        getManagedContentSpace: createWireAdapterConstructor(luvio, getManagedContentSpace_ldsAdapter, getManagedContentSpaceMetadata),
+        getManagedContentSpaceNotifyChange: createLDSAdapter(luvio, 'getManagedContentSpaceNotifyChange', notifyChangeFactory$2),
         getManagedContentSpaces: createWireAdapterConstructor(luvio, getManagedContentSpaces_ldsAdapter, getManagedContentSpacesMetadata),
         getManagedContentVariant: createWireAdapterConstructor(luvio, getManagedContentVariant_ldsAdapter, getManagedContentVariantMetadata),
         getManagedContentVariantNotifyChange: createLDSAdapter(luvio, 'getManagedContentVariantNotifyChange', notifyChangeFactory$1),
@@ -6821,6 +7280,7 @@ function bindExportsTo(luvio) {
         getManagedContentVariantVersions: createWireAdapterConstructor(luvio, getManagedContentVariantVersions_ldsAdapter, getManagedContentVariantVersionsMetadata),
         getManagedContentVariantVersionsNotifyChange: createLDSAdapter(luvio, 'getManagedContentVariantVersionsNotifyChange', notifyChangeFactory),
         getSearchResults: createWireAdapterConstructor(luvio, getSearchResults_ldsAdapter, getSearchResultsMetadata),
+        patchManagedContentSpace: unwrapSnapshotData(patchManagedContentSpaceAdapterFactory),
         publishManagedContent: unwrapSnapshotData(publishManagedContentAdapterFactory),
         replaceManagedContentVariant: unwrapSnapshotData(replaceManagedContentVariantAdapterFactory),
         unpublishManagedContent: unwrapSnapshotData(unpublishManagedContentAdapterFactory),
@@ -6829,6 +7289,7 @@ function bindExportsTo(luvio) {
         getManagedContent_imperative: createImperativeAdapter(luvio, getManagedContent_ldsAdapter, getManagedContentMetadata),
         getManagedContentByFolderId_imperative: createImperativeAdapter(luvio, getManagedContentByFolderId_ldsAdapter, getManagedContentByFolderIdMetadata),
         getManagedContentReferencedBy_imperative: createImperativeAdapter(luvio, getManagedContentReferencedBy_ldsAdapter, getManagedContentReferencedByMetadata),
+        getManagedContentSpace_imperative: createImperativeAdapter(luvio, getManagedContentSpace_ldsAdapter, getManagedContentSpaceMetadata),
         getManagedContentSpaces_imperative: createImperativeAdapter(luvio, getManagedContentSpaces_ldsAdapter, getManagedContentSpacesMetadata),
         getManagedContentVariant_imperative: createImperativeAdapter(luvio, getManagedContentVariant_ldsAdapter, getManagedContentVariantMetadata),
         getManagedContentVariantReferences_imperative: createImperativeAdapter(luvio, getManagedContentVariantReferences_ldsAdapter, getManagedContentVariantReferencesMetadata),
@@ -6850,6 +7311,8 @@ withDefaultLuvio((luvio) => {
         getManagedContent,
         getManagedContentByFolderId,
         getManagedContentReferencedBy,
+        getManagedContentSpace,
+        getManagedContentSpaceNotifyChange,
         getManagedContentSpaces,
         getManagedContentVariant,
         getManagedContentVariantNotifyChange,
@@ -6858,6 +7321,7 @@ withDefaultLuvio((luvio) => {
         getManagedContentVariantVersions,
         getManagedContentVariantVersionsNotifyChange,
         getSearchResults,
+        patchManagedContentSpace,
         publishManagedContent,
         replaceManagedContentVariant,
         unpublishManagedContent,
@@ -6865,6 +7329,7 @@ withDefaultLuvio((luvio) => {
         getManagedContent_imperative,
         getManagedContentByFolderId_imperative,
         getManagedContentReferencedBy_imperative,
+        getManagedContentSpace_imperative,
         getManagedContentSpaces_imperative,
         getManagedContentVariant_imperative,
         getManagedContentVariantReferences_imperative,
@@ -6874,5 +7339,5 @@ withDefaultLuvio((luvio) => {
     } = bindExportsTo(luvio));
 });
 
-export { createDeployment, createManagedContent, createManagedContentExportV2Job, createManagedContentImportV2Job, createManagedContentVariant, createTranslationV2Job, deleteManagedContentVariant, getCollectionItems, getCollectionItems_imperative, getManagedContent, getManagedContentByFolderId, getManagedContentByFolderId_imperative, getManagedContentReferencedBy, getManagedContentReferencedBy_imperative, getManagedContentSpaces, getManagedContentSpaces_imperative, getManagedContentVariant, getManagedContentVariantNotifyChange, getManagedContentVariantReferences, getManagedContentVariantReferences_imperative, getManagedContentVariantRendition, getManagedContentVariantRendition_imperative, getManagedContentVariantVersions, getManagedContentVariantVersionsNotifyChange, getManagedContentVariantVersions_imperative, getManagedContentVariant_imperative, getManagedContent_imperative, getSearchResults, getSearchResults_imperative, publishManagedContent, replaceManagedContentVariant, unpublishManagedContent };
-// version: 1.102.0-c44aa2ee5
+export { createDeployment, createManagedContent, createManagedContentExportV2Job, createManagedContentImportV2Job, createManagedContentVariant, createTranslationV2Job, deleteManagedContentVariant, getCollectionItems, getCollectionItems_imperative, getManagedContent, getManagedContentByFolderId, getManagedContentByFolderId_imperative, getManagedContentReferencedBy, getManagedContentReferencedBy_imperative, getManagedContentSpace, getManagedContentSpaceNotifyChange, getManagedContentSpace_imperative, getManagedContentSpaces, getManagedContentSpaces_imperative, getManagedContentVariant, getManagedContentVariantNotifyChange, getManagedContentVariantReferences, getManagedContentVariantReferences_imperative, getManagedContentVariantRendition, getManagedContentVariantRendition_imperative, getManagedContentVariantVersions, getManagedContentVariantVersionsNotifyChange, getManagedContentVariantVersions_imperative, getManagedContentVariant_imperative, getManagedContent_imperative, getSearchResults, getSearchResults_imperative, patchManagedContentSpace, publishManagedContent, replaceManagedContentVariant, unpublishManagedContent };
+// version: 1.103.0-29ed5d28b