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

package/dist/es/es2018/cms-authoring.js

@@ -219,8 +219,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) {
@@ -405,28 +405,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;
     }
@@ -441,62 +441,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') {
@@ -506,7 +506,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',
@@ -527,7 +527,7 @@ const createDeployment_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$j(config) {
+function createResourceParams$l(config) {
     const resourceParams = {
         body: {
             DeploymentInput: config.DeploymentInput
@@ -535,7 +535,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);
@@ -544,28 +544,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;
@@ -573,12 +573,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);
     };
 };
 
@@ -683,8 +683,8 @@ function deepFreeze$p(input) {
     ObjectFreeze(input);
 }
 
-const TTL$d = 100;
-const VERSION$d = "eeea454f1268ece5c3e24c986688b876";
+const TTL$e = 100;
+const VERSION$e = "eeea454f1268ece5c3e24c986688b876";
 function validate$w(obj, path = 'ManagedContentCollectionDetailRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -756,30 +756,30 @@ function validate$w(obj, path = 'ManagedContentCollectionDetailRepresentation')
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$d = 'ManagedContentCollectionDetailRepresentation';
-function keyBuilder$s(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$d + ':' + config.collection_key + ':' + config.language + ':' + config.version;
+const RepresentationType$e = 'ManagedContentCollectionDetailRepresentation';
+function keyBuilder$v(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$e + ':' + config.collection_key + ':' + config.language + ':' + config.version;
 }
-function keyBuilderFromType$7(luvio, object) {
+function keyBuilderFromType$8(luvio, object) {
     const keyParams = {
         collection_key: object.collectionKey,
         language: object.language,
         version: object.versionNumber
     };
-    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 ManagedContentCollectionDetailRepresentationSelect() {
+const select$y = function ManagedContentCollectionDetailRepresentationSelect() {
     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;
     }
@@ -796,69 +796,69 @@ function deepFreeze$o(input) {
     ObjectFreeze(input_items);
     ObjectFreeze(input);
 }
-const ingest$d = function ManagedContentCollectionDetailRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$e = function ManagedContentCollectionDetailRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$w(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$o(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 keyBuilder$r(luvio, params) {
-    return keyBuilder$s(luvio, {
+function keyBuilder$u(luvio, params) {
+    return keyBuilder$v(luvio, {
         collection_key: params.urlParams.collectionKeyOrId,
         language: params.queryParams.language || '',
         version: params.queryParams.version || ''
     });
 }
-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, snapshotRefresh) {
+function ingestSuccess$k(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$r(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$d, body);
+    const key = keyBuilder$u(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$e, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$u(),
+        node: select$x(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -868,19 +868,19 @@ function ingestSuccess$i(luvio, resourceParams, response, snapshotRefresh) {
     }
     return snapshot;
 }
-function ingestError$9(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$r(luvio, params);
+function ingestError$a(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$u(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$i(config) {
+function createResourceRequest$k(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -894,7 +894,7 @@ function createResourceRequest$i(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.
@@ -906,7 +906,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 = {
@@ -916,7 +916,7 @@ const getCollectionItems_ConfigPropertyNames = {
         optional: ['language', 'version']
     }
 };
-function createResourceParams$i(config) {
+function createResourceParams$k(config) {
     const resourceParams = {
         urlParams: {
             collectionKeyOrId: config.collectionKeyOrId
@@ -927,11 +927,11 @@ function createResourceParams$i(config) {
     };
     return resourceParams;
 }
-function keyBuilder$q(luvio, config) {
-    const resourceParams = createResourceParams$i(config);
-    return keyBuilder$r(luvio, resourceParams);
+function keyBuilder$t(luvio, config) {
+    const resourceParams = createResourceParams$k(config);
+    return keyBuilder$u(luvio, resourceParams);
 }
-function typeCheckConfig$i(untrustedConfig) {
+function typeCheckConfig$k(untrustedConfig) {
     const config = {};
     const untrustedConfig_collectionKeyOrId = untrustedConfig.collectionKeyOrId;
     if (typeof untrustedConfig_collectionKeyOrId === 'string') {
@@ -947,48 +947,48 @@ 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 adapterFragment$9(luvio, config) {
-    createResourceParams$i(config);
-    return select$u();
+function adapterFragment$a(luvio, config) {
+    createResourceParams$k(config);
+    return select$x();
 }
-function onFetchResponseSuccess$a(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$i(luvio, resourceParams, response, {
+function onFetchResponseSuccess$b(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$k(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$i(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$k(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$i(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$k(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-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(() => onFetchResponseSuccess$b(luvio, config, resourceParams, response), () => getResponseCacheKeys$i(luvio, resourceParams, response.body));
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$c(luvio, config, resourceParams, response), () => getResponseCacheKeys$k(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 = {
@@ -1003,29 +1003,29 @@ function buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext
             priority: networkPriority
         };
     }
-    return buildNetworkSnapshot$i(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$k(luvio, config, dispatchOptions);
 }
-function buildCachedSnapshotCachePolicy$9(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$a(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$q(luvio, config),
-        node: adapterFragment$9(luvio, config),
+        recordId: keyBuilder$t(luvio, config),
+        node: adapterFragment$a(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$i(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$k(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getCollectionItemsAdapterFactory = (luvio) => function CMSAuthoring__getCollectionItems(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$i(untrustedConfig, getCollectionItems_ConfigPropertyNames);
+    const config = validateAdapterConfig$k(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 validate$v(obj, path = 'ManagedContentTranslationV2RequestInputRep') {
@@ -1098,8 +1098,8 @@ function validate$v(obj, path = 'ManagedContentTranslationV2RequestInputRep') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$c = 100;
-const VERSION$c = "52e643b998d6763482c6d74542b38408";
+const TTL$d = 100;
+const VERSION$d = "52e643b998d6763482c6d74542b38408";
 function validate$u(obj, path = 'ManagedContentTranslationV2Representation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -1257,28 +1257,28 @@ function validate$u(obj, path = 'ManagedContentTranslationV2Representation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$c = 'ManagedContentTranslationV2Representation';
-function keyBuilder$p(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$c + ':' + config.id;
+const RepresentationType$d = 'ManagedContentTranslationV2Representation';
+function keyBuilder$s(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$p(luvio, keyParams);
+    return keyBuilder$s(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 ManagedContentTranslationV2RepresentationSelect() {
+const select$w = function ManagedContentTranslationV2RepresentationSelect() {
     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;
     }
@@ -1287,62 +1287,62 @@ function equals$c(existing, incoming) {
 function deepFreeze$n(input) {
     ObjectFreeze(input);
 }
-const ingest$c = function ManagedContentTranslationV2RepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$d = function ManagedContentTranslationV2RepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$u(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$n(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$h(luvio, resourceParams, response) {
+function ingestSuccess$j(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') {
@@ -1352,7 +1352,7 @@ function ingestSuccess$h(luvio, resourceParams, response) {
     }
     return snapshot;
 }
-function createResourceRequest$h(config) {
+function createResourceRequest$j(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -1373,7 +1373,7 @@ const createTranslationV2Job_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$h(config) {
+function createResourceParams$j(config) {
     const resourceParams = {
         urlParams: {
             contentSpaceId: config.contentSpaceId
@@ -1384,7 +1384,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') {
@@ -1397,28 +1397,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$h(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$j(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;
@@ -1426,12 +1426,12 @@ function buildNetworkSnapshot$h(luvio, config, options) {
 }
 const createTranslationV2JobAdapterFactory = (luvio) => {
     return function createTranslationV2Job(untrustedConfig) {
-        const config = validateAdapterConfig$h(untrustedConfig, createTranslationV2Job_ConfigPropertyNames);
+        const config = validateAdapterConfig$j(untrustedConfig, createTranslationV2Job_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createTranslationV2Job"');
         }
-        return buildNetworkSnapshot$h(luvio, config);
+        return buildNetworkSnapshot$j(luvio, config);
     };
 };
 
@@ -1573,8 +1573,8 @@ function deepFreeze$j(input) {
     ObjectFreeze(input);
 }
 
-const TTL$b = 100;
-const VERSION$b = "c04d826180efa7be6ad6764b5928469e";
+const TTL$c = 100;
+const VERSION$c = "c04d826180efa7be6ad6764b5928469e";
 function validate$o(obj, path = 'ManagedContentDocumentRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -1749,30 +1749,30 @@ function validate$o(obj, path = 'ManagedContentDocumentRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$b = 'ManagedContentDocumentRepresentation';
-function keyBuilder$o(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$b + ':' + config.content_key + ':' + config.language + ':' + config.version;
+const RepresentationType$c = 'ManagedContentDocumentRepresentation';
+function keyBuilder$r(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$c + ':' + config.content_key + ':' + config.language + ':' + config.version;
 }
-function keyBuilderFromType$5(luvio, object) {
+function keyBuilderFromType$6(luvio, object) {
     const keyParams = {
         content_key: object.contentKey,
         language: object.language,
         version: object.version
     };
-    return keyBuilder$o(luvio, keyParams);
+    return keyBuilder$r(luvio, keyParams);
 }
-function normalize$b(input, existing, path, luvio, store, timestamp) {
+function normalize$c(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$r = function ManagedContentDocumentRepresentationSelect() {
+const select$u = function ManagedContentDocumentRepresentationSelect() {
     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;
     }
@@ -1806,62 +1806,62 @@ function deepFreeze$i(input) {
     }
     ObjectFreeze(input);
 }
-const ingest$b = function ManagedContentDocumentRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$c = function ManagedContentDocumentRepresentationIngest(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$i(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$q(luvio, params) {
-    return select$r();
+function select$t(luvio, params) {
+    return select$u();
 }
-function getResponseCacheKeys$g(luvio, resourceParams, response) {
-    return getTypeCacheKeys$b(luvio, response);
+function getResponseCacheKeys$i(luvio, resourceParams, response) {
+    return getTypeCacheKeys$c(luvio, response);
 }
-function ingestSuccess$g(luvio, resourceParams, response) {
+function ingestSuccess$i(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$q(),
+        node: select$t(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -1871,7 +1871,7 @@ function ingestSuccess$g(luvio, resourceParams, response) {
     }
     return snapshot;
 }
-function createResourceRequest$g(config) {
+function createResourceRequest$i(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -1885,11 +1885,11 @@ function createResourceRequest$g(config) {
     };
 }
 
-function ingestSuccess$f(luvio, resourceParams, response) {
+function ingestSuccess$h(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$g(luvio, resourceParams, response);
+    return ingestSuccess$i(luvio, resourceParams, response);
 }
 
 const createManagedContent_ConfigPropertyNames = {
@@ -1899,7 +1899,7 @@ const createManagedContent_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$g(config) {
+function createResourceParams$i(config) {
     const resourceParams = {
         body: {
             ManagedContentInputParam: config.ManagedContentInputParam
@@ -1907,7 +1907,7 @@ function createResourceParams$g(config) {
     };
     return resourceParams;
 }
-function typeCheckConfig$g(untrustedConfig) {
+function typeCheckConfig$i(untrustedConfig) {
     const config = {};
     const untrustedConfig_ManagedContentInputParam = untrustedConfig.ManagedContentInputParam;
     const referenceManagedContentInputRepresentationValidationError = validate$t(untrustedConfig_ManagedContentInputParam);
@@ -1916,28 +1916,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;
@@ -1945,12 +1945,12 @@ function buildNetworkSnapshot$g(luvio, config, options) {
 }
 const createManagedContentAdapterFactory = (luvio) => {
     return function createManagedContent(untrustedConfig) {
-        const config = validateAdapterConfig$g(untrustedConfig, createManagedContent_ConfigPropertyNames);
+        const config = validateAdapterConfig$i(untrustedConfig, createManagedContent_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createManagedContent"');
         }
-        return buildNetworkSnapshot$g(luvio, config);
+        return buildNetworkSnapshot$i(luvio, config);
     };
 };
 
@@ -2005,8 +2005,8 @@ function validate$n(obj, path = 'ManagedContentPublishInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$a = 100;
-const VERSION$a = "789bce2e581ff7969982fbf2ffbfd9a5";
+const TTL$b = 100;
+const VERSION$b = "789bce2e581ff7969982fbf2ffbfd9a5";
 function validate$m(obj, path = 'ManagedContentPublishOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -2072,28 +2072,28 @@ function validate$m(obj, path = 'ManagedContentPublishOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$a = 'ManagedContentPublishOutputRepresentation';
-function keyBuilder$n(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$a + ':' + config.id;
+const RepresentationType$b = 'ManagedContentPublishOutputRepresentation';
+function keyBuilder$q(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$b + ':' + config.id;
 }
-function keyBuilderFromType$4(luvio, object) {
+function keyBuilderFromType$5(luvio, object) {
     const keyParams = {
         id: object.deploymentId
     };
-    return keyBuilder$n(luvio, keyParams);
+    return keyBuilder$q(luvio, keyParams);
 }
-function normalize$a(input, existing, path, luvio, store, timestamp) {
+function normalize$b(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$p = function ManagedContentPublishOutputRepresentationSelect() {
+const select$s = function ManagedContentPublishOutputRepresentationSelect() {
     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;
     }
@@ -2102,62 +2102,62 @@ function equals$a(existing, incoming) {
 function deepFreeze$h(input) {
     ObjectFreeze(input);
 }
-const ingest$a = function ManagedContentPublishOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$b = function ManagedContentPublishOutputRepresentationIngest(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$h(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$o(luvio, params) {
-    return select$p();
+function select$r(luvio, params) {
+    return select$s();
 }
-function getResponseCacheKeys$f(luvio, resourceParams, response) {
-    return getTypeCacheKeys$a(luvio, response);
+function getResponseCacheKeys$h(luvio, resourceParams, response) {
+    return getTypeCacheKeys$b(luvio, response);
 }
-function ingestSuccess$e(luvio, resourceParams, response) {
+function ingestSuccess$g(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$o(),
+        node: select$r(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -2167,7 +2167,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',
@@ -2188,7 +2188,7 @@ const publishManagedContent_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$f(config) {
+function createResourceParams$h(config) {
     const resourceParams = {
         body: {
             publishInput: config.publishInput
@@ -2196,7 +2196,7 @@ function createResourceParams$f(config) {
     };
     return resourceParams;
 }
-function typeCheckConfig$f(untrustedConfig) {
+function typeCheckConfig$h(untrustedConfig) {
     const config = {};
     const untrustedConfig_publishInput = untrustedConfig.publishInput;
     const referenceManagedContentPublishInputRepresentationValidationError = validate$n(untrustedConfig_publishInput);
@@ -2205,28 +2205,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;
@@ -2234,12 +2234,12 @@ function buildNetworkSnapshot$f(luvio, config, options) {
 }
 const publishManagedContentAdapterFactory = (luvio) => {
     return function publishManagedContent(untrustedConfig) {
-        const config = validateAdapterConfig$f(untrustedConfig, publishManagedContent_ConfigPropertyNames);
+        const config = validateAdapterConfig$h(untrustedConfig, publishManagedContent_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "publishManagedContent"');
         }
-        return buildNetworkSnapshot$f(luvio, config);
+        return buildNetworkSnapshot$h(luvio, config);
     };
 };
 
@@ -2287,8 +2287,8 @@ function validate$l(obj, path = 'ManagedContentUnpublishInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$9 = 100;
-const VERSION$9 = "2f473ff12e87a4fc2336695104ab8567";
+const TTL$a = 100;
+const VERSION$a = "2f473ff12e87a4fc2336695104ab8567";
 function validate$k(obj, path = 'ManagedContentUnpublishOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -2354,28 +2354,28 @@ function validate$k(obj, path = 'ManagedContentUnpublishOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$9 = 'ManagedContentUnpublishOutputRepresentation';
-function keyBuilder$m(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$9 + ':' + config.id;
+const RepresentationType$a = 'ManagedContentUnpublishOutputRepresentation';
+function keyBuilder$p(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$a + ':' + config.id;
 }
-function keyBuilderFromType$3(luvio, object) {
+function keyBuilderFromType$4(luvio, object) {
     const keyParams = {
         id: object.deploymentId
     };
-    return keyBuilder$m(luvio, keyParams);
+    return keyBuilder$p(luvio, keyParams);
 }
-function normalize$9(input, existing, path, luvio, store, timestamp) {
+function normalize$a(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$n = function ManagedContentUnpublishOutputRepresentationSelect() {
+const select$q = function ManagedContentUnpublishOutputRepresentationSelect() {
     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;
     }
@@ -2384,62 +2384,62 @@ function equals$9(existing, incoming) {
 function deepFreeze$g(input) {
     ObjectFreeze(input);
 }
-const ingest$9 = function ManagedContentUnpublishOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$a = function ManagedContentUnpublishOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$k(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$m(luvio, params) {
-    return select$n();
+function select$p(luvio, params) {
+    return select$q();
 }
-function getResponseCacheKeys$e(luvio, resourceParams, response) {
-    return getTypeCacheKeys$9(luvio, response);
+function getResponseCacheKeys$g(luvio, resourceParams, response) {
+    return getTypeCacheKeys$a(luvio, response);
 }
-function ingestSuccess$d(luvio, resourceParams, response) {
+function ingestSuccess$f(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$3(luvio, body);
-    luvio.storeIngest(key, ingest$9, body);
+    const key = keyBuilderFromType$4(luvio, body);
+    luvio.storeIngest(key, ingest$a, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$m(),
+        node: select$p(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -2449,7 +2449,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',
@@ -2470,7 +2470,7 @@ const unpublishManagedContent_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$e(config) {
+function createResourceParams$g(config) {
     const resourceParams = {
         body: {
             unpublishInput: config.unpublishInput
@@ -2478,7 +2478,7 @@ function createResourceParams$e(config) {
     };
     return resourceParams;
 }
-function typeCheckConfig$e(untrustedConfig) {
+function typeCheckConfig$g(untrustedConfig) {
     const config = {};
     const untrustedConfig_unpublishInput = untrustedConfig.unpublishInput;
     const referenceManagedContentUnpublishInputRepresentationValidationError = validate$l(untrustedConfig_unpublishInput);
@@ -2487,28 +2487,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;
@@ -2516,12 +2516,12 @@ function buildNetworkSnapshot$e(luvio, config, options) {
 }
 const unpublishManagedContentAdapterFactory = (luvio) => {
     return function unpublishManagedContent(untrustedConfig) {
-        const config = validateAdapterConfig$e(untrustedConfig, unpublishManagedContent_ConfigPropertyNames);
+        const config = validateAdapterConfig$g(untrustedConfig, unpublishManagedContent_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "unpublishManagedContent"');
         }
-        return buildNetworkSnapshot$e(luvio, config);
+        return buildNetworkSnapshot$g(luvio, config);
     };
 };
 
@@ -2572,8 +2572,8 @@ function validate$j(obj, path = 'ManagedContentVariantInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$8 = 3600000;
-const VERSION$8 = "7752c6a8bb6b113a02bfde83f39e5957";
+const TTL$9 = 3600000;
+const VERSION$9 = "7752c6a8bb6b113a02bfde83f39e5957";
 function validate$i(obj, path = 'ManagedContentVariantRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -2694,28 +2694,28 @@ function validate$i(obj, path = 'ManagedContentVariantRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$8 = 'ManagedContentVariantRepresentation';
-function keyBuilder$l(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$8 + ':' + config.id;
+const RepresentationType$9 = 'ManagedContentVariantRepresentation';
+function keyBuilder$o(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$9 + ':' + config.id;
 }
-function keyBuilderFromType$2(luvio, object) {
+function keyBuilderFromType$3(luvio, object) {
     const keyParams = {
         id: object.managedContentVariantId
     };
-    return keyBuilder$l(luvio, keyParams);
+    return keyBuilder$o(luvio, keyParams);
 }
-function normalize$8(input, existing, path, luvio, store, timestamp) {
+function normalize$9(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$l = function ManagedContentVariantRepresentationSelect() {
+const select$o = function ManagedContentVariantRepresentationSelect() {
     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;
     }
@@ -2745,62 +2745,62 @@ function deepFreeze$f(input) {
     deepFreeze$j(input_status);
     ObjectFreeze(input);
 }
-const ingest$8 = function ManagedContentVariantRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$9 = function ManagedContentVariantRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$i(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$2(luvio, input);
+    const key = keyBuilderFromType$3(luvio, input);
     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$f(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 = keyBuilderFromType$2(luvio, input);
+    const rootKey = keyBuilderFromType$3(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$8,
+        representationName: RepresentationType$9,
         mergeable: false
     });
     return rootKeySet;
 }
 
-function select$k(luvio, params) {
-    return select$l();
+function select$n(luvio, params) {
+    return select$o();
 }
-function getResponseCacheKeys$d(luvio, resourceParams, response) {
-    return getTypeCacheKeys$8(luvio, response);
+function getResponseCacheKeys$f(luvio, resourceParams, response) {
+    return getTypeCacheKeys$9(luvio, response);
 }
-function ingestSuccess$c(luvio, resourceParams, response) {
+function ingestSuccess$e(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$2(luvio, body);
-    luvio.storeIngest(key, ingest$8, body);
+    const key = keyBuilderFromType$3(luvio, body);
+    luvio.storeIngest(key, ingest$9, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$k(),
+        node: select$n(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -2810,7 +2810,7 @@ function ingestSuccess$c(luvio, resourceParams, response) {
     }
     return snapshot;
 }
-function createResourceRequest$d(config) {
+function createResourceRequest$f(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -2831,7 +2831,7 @@ const createManagedContentVariant_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$d(config) {
+function createResourceParams$f(config) {
     const resourceParams = {
         body: {
             managedContentVariantInputParam: config.managedContentVariantInputParam
@@ -2839,7 +2839,7 @@ function createResourceParams$d(config) {
     };
     return resourceParams;
 }
-function typeCheckConfig$d(untrustedConfig) {
+function typeCheckConfig$f(untrustedConfig) {
     const config = {};
     const untrustedConfig_managedContentVariantInputParam = untrustedConfig.managedContentVariantInputParam;
     const referenceManagedContentVariantInputRepresentationValidationError = validate$j(untrustedConfig_managedContentVariantInputParam);
@@ -2848,28 +2848,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((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$c(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$e(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
-        }, () => getResponseCacheKeys$d(luvio, resourceParams, response.body));
+        }, () => getResponseCacheKeys$f(luvio, resourceParams, response.body));
     }, (response) => {
         deepFreeze$u(response);
         throw response;
@@ -2877,35 +2877,35 @@ function buildNetworkSnapshot$d(luvio, config, options) {
 }
 const createManagedContentVariantAdapterFactory = (luvio) => {
     return function createManagedContentVariant(untrustedConfig) {
-        const config = validateAdapterConfig$d(untrustedConfig, createManagedContentVariant_ConfigPropertyNames);
+        const config = validateAdapterConfig$f(untrustedConfig, createManagedContentVariant_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createManagedContentVariant"');
         }
-        return buildNetworkSnapshot$d(luvio, config);
+        return buildNetworkSnapshot$f(luvio, config);
     };
 };
 
-function keyBuilder$k(luvio, params) {
-    return keyBuilder$l(luvio, {
+function keyBuilder$n(luvio, params) {
+    return keyBuilder$o(luvio, {
         id: params.urlParams.variantId
     });
 }
-function getResponseCacheKeys$c(luvio, resourceParams) {
-    const key = keyBuilder$k(luvio, resourceParams);
+function getResponseCacheKeys$e(luvio, resourceParams) {
+    const key = keyBuilder$n(luvio, resourceParams);
     const cacheKeyMap = new StoreKeyMap();
     cacheKeyMap.set(key, {
         namespace: keyPrefix,
-        representationName: RepresentationType$8,
+        representationName: RepresentationType$9,
         mergeable: false
     });
     return cacheKeyMap;
 }
 function evictSuccess(luvio, resourceParams) {
-    const key = keyBuilder$k(luvio, resourceParams);
+    const key = keyBuilder$n(luvio, resourceParams);
     luvio.storeEvict(key);
 }
-function createResourceRequest$c(config) {
+function createResourceRequest$e(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -2927,7 +2927,7 @@ const deleteManagedContentVariant_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$c(config) {
+function createResourceParams$e(config) {
     const resourceParams = {
         urlParams: {
             variantId: config.variantId
@@ -2935,7 +2935,7 @@ function createResourceParams$c(config) {
     };
     return resourceParams;
 }
-function typeCheckConfig$c(untrustedConfig) {
+function typeCheckConfig$e(untrustedConfig) {
     const config = {};
     const untrustedConfig_variantId = untrustedConfig.variantId;
     if (typeof untrustedConfig_variantId === 'string') {
@@ -2943,28 +2943,28 @@ 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 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(() => {
         return luvio.handleSuccessResponse(() => {
             evictSuccess(luvio, resourceParams);
             return luvio.storeBroadcast();
-        }, () => getResponseCacheKeys$c(luvio, resourceParams));
+        }, () => getResponseCacheKeys$e(luvio, resourceParams));
     }, (response) => {
         deepFreeze$u(response);
         throw response;
@@ -2972,33 +2972,33 @@ function buildNetworkSnapshot$c(luvio, config, options) {
 }
 const deleteManagedContentVariantAdapterFactory = (luvio) => {
     return function CMSAuthoringdeleteManagedContentVariant(untrustedConfig) {
-        const config = validateAdapterConfig$c(untrustedConfig, deleteManagedContentVariant_ConfigPropertyNames);
+        const config = validateAdapterConfig$e(untrustedConfig, deleteManagedContentVariant_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error(`Invalid config for "${adapterName}"`);
         }
-        return buildNetworkSnapshot$c(luvio, config);
+        return buildNetworkSnapshot$e(luvio, config);
     };
 };
 
-function select$j(luvio, params) {
-    return select$l();
+function select$m(luvio, params) {
+    return select$o();
 }
-function keyBuilder$j(luvio, params) {
-    return keyBuilder$l(luvio, {
+function keyBuilder$m(luvio, params) {
+    return keyBuilder$o(luvio, {
         id: params.urlParams.variantId
     });
 }
-function getResponseCacheKeys$b(luvio, resourceParams, response) {
-    return getTypeCacheKeys$8(luvio, response);
+function getResponseCacheKeys$d(luvio, resourceParams, response) {
+    return getTypeCacheKeys$9(luvio, response);
 }
-function ingestSuccess$b(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$d(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$j(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$8, body);
+    const key = keyBuilder$m(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$9, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$j(),
+        node: select$m(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -3008,19 +3008,19 @@ function ingestSuccess$b(luvio, resourceParams, response, snapshotRefresh) {
     }
     return snapshot;
 }
-function ingestError$8(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$j(luvio, params);
+function ingestError$9(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$m(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$b(config) {
+function createResourceRequest$d(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -3041,7 +3041,7 @@ const getManagedContentVariant_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$b(config) {
+function createResourceParams$d(config) {
     const resourceParams = {
         urlParams: {
             variantId: config.variantId
@@ -3049,11 +3049,11 @@ function createResourceParams$b(config) {
     };
     return resourceParams;
 }
-function keyBuilder$i(luvio, config) {
-    const resourceParams = createResourceParams$b(config);
-    return keyBuilder$j(luvio, resourceParams);
+function keyBuilder$l(luvio, config) {
+    const resourceParams = createResourceParams$d(config);
+    return keyBuilder$m(luvio, resourceParams);
 }
-function typeCheckConfig$b(untrustedConfig) {
+function typeCheckConfig$d(untrustedConfig) {
     const config = {};
     const untrustedConfig_variantId = untrustedConfig.variantId;
     if (typeof untrustedConfig_variantId === 'string') {
@@ -3061,48 +3061,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$j();
+function adapterFragment$9(luvio, config) {
+    createResourceParams$d(config);
+    return select$m();
 }
-function onFetchResponseSuccess$9(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$b(luvio, resourceParams, response, {
+function onFetchResponseSuccess$a(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 = {
@@ -3117,29 +3117,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$i(luvio, config),
-        node: adapterFragment$8(luvio, config),
+        recordId: keyBuilder$l(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 getManagedContentVariantAdapterFactory = (luvio) => function CMSAuthoring__getManagedContentVariant(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$b(untrustedConfig, getManagedContentVariant_ConfigPropertyNames);
+    const config = validateAdapterConfig$d(untrustedConfig, getManagedContentVariant_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$h(obj, path = 'ManagedContentVariantUpdateInputRepresentation') {
@@ -3175,19 +3175,19 @@ function validate$h(obj, path = 'ManagedContentVariantUpdateInputRepresentation'
     return v_error === undefined ? null : v_error;
 }
 
-function select$i(luvio, params) {
-    return select$l();
+function select$l(luvio, params) {
+    return select$o();
 }
-function getResponseCacheKeys$a(luvio, resourceParams, response) {
-    return getTypeCacheKeys$8(luvio, response);
+function getResponseCacheKeys$c(luvio, resourceParams, response) {
+    return getTypeCacheKeys$9(luvio, response);
 }
-function ingestSuccess$a(luvio, resourceParams, response) {
+function ingestSuccess$c(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$2(luvio, body);
-    luvio.storeIngest(key, ingest$8, body);
+    const key = keyBuilderFromType$3(luvio, body);
+    luvio.storeIngest(key, ingest$9, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$i(),
+        node: select$l(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -3197,7 +3197,7 @@ function ingestSuccess$a(luvio, resourceParams, response) {
     }
     return snapshot;
 }
-function createResourceRequest$a(config) {
+function createResourceRequest$c(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -3218,7 +3218,7 @@ const replaceManagedContentVariant_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$a(config) {
+function createResourceParams$c(config) {
     const resourceParams = {
         urlParams: {
             variantId: config.variantId
@@ -3229,7 +3229,7 @@ function createResourceParams$a(config) {
     };
     return resourceParams;
 }
-function typeCheckConfig$a(untrustedConfig) {
+function typeCheckConfig$c(untrustedConfig) {
     const config = {};
     const untrustedConfig_variantId = untrustedConfig.variantId;
     if (typeof untrustedConfig_variantId === 'string') {
@@ -3242,28 +3242,28 @@ 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 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(() => {
-            const snapshot = ingestSuccess$a(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$c(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
-        }, () => getResponseCacheKeys$a(luvio, resourceParams, response.body));
+        }, () => getResponseCacheKeys$c(luvio, resourceParams, response.body));
     }, (response) => {
         deepFreeze$u(response);
         throw response;
@@ -3271,12 +3271,12 @@ function buildNetworkSnapshot$a(luvio, config, options) {
 }
 const replaceManagedContentVariantAdapterFactory = (luvio) => {
     return function replaceManagedContentVariant(untrustedConfig) {
-        const config = validateAdapterConfig$a(untrustedConfig, replaceManagedContentVariant_ConfigPropertyNames);
+        const config = validateAdapterConfig$c(untrustedConfig, replaceManagedContentVariant_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "replaceManagedContentVariant"');
         }
-        return buildNetworkSnapshot$a(luvio, config);
+        return buildNetworkSnapshot$c(luvio, config);
     };
 };
 
@@ -3347,8 +3347,8 @@ function deepFreeze$e(input) {
     ObjectFreeze(input);
 }
 
-const TTL$7 = 100;
-const VERSION$7 = "993f4fe3a5b12699f037079dbe30610b";
+const TTL$8 = 100;
+const VERSION$8 = "993f4fe3a5b12699f037079dbe30610b";
 function validate$f(obj, path = 'ManagedContentVariantVersionCollectionRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -3389,28 +3389,28 @@ function validate$f(obj, path = 'ManagedContentVariantVersionCollectionRepresent
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$7 = 'ManagedContentVariantVersionCollectionRepresentation';
-function keyBuilder$h(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$7 + ':' + config.variantId;
+const RepresentationType$8 = 'ManagedContentVariantVersionCollectionRepresentation';
+function keyBuilder$k(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$8 + ':' + config.variantId;
 }
-function keyBuilderFromType$1(luvio, object) {
+function keyBuilderFromType$2(luvio, object) {
     const keyParams = {
         variantId: object.managedContentVariantId
     };
-    return keyBuilder$h(luvio, keyParams);
+    return keyBuilder$k(luvio, keyParams);
 }
-function normalize$7(input, existing, path, luvio, store, timestamp) {
+function normalize$8(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$h = function ManagedContentVariantVersionCollectionRepresentationSelect() {
+const select$k = function ManagedContentVariantVersionCollectionRepresentationSelect() {
     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;
     }
@@ -3425,67 +3425,67 @@ function deepFreeze$d(input) {
     ObjectFreeze(input_versions);
     ObjectFreeze(input);
 }
-const ingest$7 = function ManagedContentVariantVersionCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$8 = function ManagedContentVariantVersionCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$f(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$1(luvio, input);
+    const key = keyBuilderFromType$2(luvio, input);
     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$d(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 = keyBuilderFromType$1(luvio, input);
+    const rootKey = keyBuilderFromType$2(luvio, input);
     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) {
-    return keyBuilder$h(luvio, {
+function keyBuilder$j(luvio, params) {
+    return keyBuilder$k(luvio, {
         variantId: params.urlParams.variantId
     });
 }
-function getResponseCacheKeys$9(luvio, resourceParams, response) {
-    return getTypeCacheKeys$7(luvio, response);
+function getResponseCacheKeys$b(luvio, resourceParams, response) {
+    return getTypeCacheKeys$8(luvio, response);
 }
-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') {
@@ -3495,19 +3495,19 @@ function ingestSuccess$9(luvio, resourceParams, response, snapshotRefresh) {
     }
     return snapshot;
 }
-function ingestError$7(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$g(luvio, params);
+function ingestError$8(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',
@@ -3528,7 +3528,7 @@ const getManagedContentVariantVersions_ConfigPropertyNames = {
         optional: ['page', 'pageSize', 'status']
     }
 };
-function createResourceParams$9(config) {
+function createResourceParams$b(config) {
     const resourceParams = {
         urlParams: {
             variantId: config.variantId
@@ -3539,11 +3539,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_variantId = untrustedConfig.variantId;
     if (typeof untrustedConfig_variantId === 'string') {
@@ -3570,48 +3570,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$7(luvio, config) {
-    createResourceParams$9(config);
-    return select$g();
+function adapterFragment$8(luvio, config) {
+    createResourceParams$b(config);
+    return select$j();
 }
-function onFetchResponseSuccess$8(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$9(luvio, resourceParams, response, {
+function onFetchResponseSuccess$9(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$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$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$8(luvio, config, resourceParams, response), () => getResponseCacheKeys$9(luvio, resourceParams, response.body));
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$9(luvio, config, resourceParams, response), () => getResponseCacheKeys$b(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 = {
@@ -3626,51 +3626,51 @@ function buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext
             priority: networkPriority
         };
     }
-    return buildNetworkSnapshot$9(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$b(luvio, config, dispatchOptions);
 }
-function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$8(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$f(luvio, config),
-        node: adapterFragment$7(luvio, config),
+        recordId: keyBuilder$i(luvio, config),
+        node: adapterFragment$8(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$b(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getManagedContentVariantVersionsAdapterFactory = (luvio) => function CMSAuthoring__getManagedContentVariantVersions(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$9(untrustedConfig, getManagedContentVariantVersions_ConfigPropertyNames);
+    const config = validateAdapterConfig$b(untrustedConfig, getManagedContentVariantVersions_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 select$f(luvio, params) {
-    return select$r();
+function select$i(luvio, params) {
+    return select$u();
 }
-function keyBuilder$e(luvio, params) {
-    return keyBuilder$o(luvio, {
+function keyBuilder$h(luvio, params) {
+    return keyBuilder$r(luvio, {
         content_key: params.urlParams.contentKeyOrId,
         language: params.queryParams.language || '',
         version: params.queryParams.version || ''
     });
 }
-function getResponseCacheKeys$8(luvio, resourceParams, response) {
-    return getTypeCacheKeys$b(luvio, response);
+function getResponseCacheKeys$a(luvio, resourceParams, response) {
+    return getTypeCacheKeys$c(luvio, response);
 }
-function ingestSuccess$8(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$a(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$e(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$b, body);
+    const key = keyBuilder$h(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$c, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$f(),
+        node: select$i(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -3680,19 +3680,19 @@ function ingestSuccess$8(luvio, resourceParams, response, snapshotRefresh) {
     }
     return snapshot;
 }
-function ingestError$6(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$e(luvio, params);
+function ingestError$7(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$h(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$8(config) {
+function createResourceRequest$a(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -3706,7 +3706,7 @@ function createResourceRequest$8(config) {
     };
 }
 
-function onFetchResponseSuccess$7(luvio, config, resourceParams, response) {
+function onFetchResponseSuccess$8(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.
@@ -3755,7 +3755,7 @@ function onFetchResponseSuccess$7(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$6(luvio, config, resourceParams, response);
+    return onFetchResponseSuccess$7(luvio, config, resourceParams, response);
 }
 
 const getManagedContent_ConfigPropertyNames = {
@@ -3765,7 +3765,7 @@ const getManagedContent_ConfigPropertyNames = {
         optional: ['language', 'version']
     }
 };
-function createResourceParams$8(config) {
+function createResourceParams$a(config) {
     const resourceParams = {
         urlParams: {
             contentKeyOrId: config.contentKeyOrId
@@ -3776,11 +3776,11 @@ function createResourceParams$8(config) {
     };
     return resourceParams;
 }
-function keyBuilder$d(luvio, config) {
-    const resourceParams = createResourceParams$8(config);
-    return keyBuilder$e(luvio, resourceParams);
+function keyBuilder$g(luvio, config) {
+    const resourceParams = createResourceParams$a(config);
+    return keyBuilder$h(luvio, resourceParams);
 }
-function typeCheckConfig$8(untrustedConfig) {
+function typeCheckConfig$a(untrustedConfig) {
     const config = {};
     const untrustedConfig_contentKeyOrId = untrustedConfig.contentKeyOrId;
     if (typeof untrustedConfig_contentKeyOrId === 'string') {
@@ -3796,48 +3796,48 @@ function typeCheckConfig$8(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$a(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$8(untrustedConfig);
+    const config = typeCheckConfig$a(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$6(luvio, config) {
-    createResourceParams$8(config);
-    return select$f();
+function adapterFragment$7(luvio, config) {
+    createResourceParams$a(config);
+    return select$i();
 }
-function onFetchResponseSuccess$6(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$8(luvio, resourceParams, response, {
+function onFetchResponseSuccess$7(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$a(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+        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, {
+function onFetchResponseError$7(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$7(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$a(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$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$7(luvio, config, resourceParams, response), () => getResponseCacheKeys$8(luvio, resourceParams, response.body));
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$8(luvio, config, resourceParams, response), () => getResponseCacheKeys$a(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 = {
@@ -3852,33 +3852,33 @@ function buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext
             priority: networkPriority
         };
     }
-    return buildNetworkSnapshot$8(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$a(luvio, config, dispatchOptions);
 }
-function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$d(luvio, config),
-        node: adapterFragment$6(luvio, config),
+        recordId: keyBuilder$g(luvio, config),
+        node: adapterFragment$7(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getManagedContentAdapterFactory = (luvio) => function CMSAuthoring__getManagedContent(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$8(untrustedConfig, getManagedContent_ConfigPropertyNames);
+    const config = validateAdapterConfig$a(untrustedConfig, getManagedContent_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$6 = 1000;
-const VERSION$6 = "98edee4f058ced93570a7b0ce2293672";
+const TTL$7 = 1000;
+const VERSION$7 = "98edee4f058ced93570a7b0ce2293672";
 function validate$e(obj, path = 'ManagedContentRenditionRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -3930,19 +3930,19 @@ function validate$e(obj, path = 'ManagedContentRenditionRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$6 = 'ManagedContentRenditionRepresentation';
-function normalize$6(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$7 = 'ManagedContentRenditionRepresentation';
+function normalize$7(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$e = function ManagedContentRenditionRepresentationSelect() {
+const select$h = function ManagedContentRenditionRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$6,
+        version: VERSION$7,
         private: [],
         opaque: true
     };
 };
-function equals$6(existing, incoming) {
+function equals$7(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
@@ -3969,7 +3969,7 @@ function deepFreeze$c(input) {
     ObjectFreeze(input_renditionSchema);
     ObjectFreeze(input);
 }
-const ingest$6 = function ManagedContentRenditionRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$7 = function ManagedContentRenditionRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$e(input);
         if (validateError !== null) {
@@ -3978,56 +3978,56 @@ const ingest$6 = function ManagedContentRenditionRepresentationIngest(input, pat
     }
     const key = path.fullPath;
     const existingRecord = store.readEntry(key);
-    const ttlToUse = TTL$6;
-    let incomingRecord = normalize$6(input, 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$c(input);
-    if (existingRecord === undefined || equals$6(existingRecord, incomingRecord) === false) {
+    if (existingRecord === undefined || equals$7(existingRecord, incomingRecord) === false) {
         luvio.storePublish(key, incomingRecord);
     }
     {
         const storeMetadataParams = {
             ttl: ttlToUse,
             namespace: "CMSAuthoring",
-            version: VERSION$6,
-            representationName: RepresentationType$6,
+            version: VERSION$7,
+            representationName: RepresentationType$7,
         };
         luvio.publishStoreMetadata(key, storeMetadataParams);
     }
     return createLink(key);
 };
-function getTypeCacheKeys$6(luvio, input, fullPathFactory) {
+function getTypeCacheKeys$7(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$6,
+        representationName: RepresentationType$7,
         mergeable: false
     });
     return rootKeySet;
 }
 
-function select$d(luvio, params) {
-    return select$e();
+function select$g(luvio, params) {
+    return select$h();
 }
-function keyBuilder$c(luvio, params) {
+function keyBuilder$f(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$7(luvio, resourceParams, response) {
-    return getTypeCacheKeys$6(luvio, response, () => keyBuilder$c(luvio, resourceParams));
+function getResponseCacheKeys$9(luvio, resourceParams, response) {
+    return getTypeCacheKeys$7(luvio, response, () => keyBuilder$f(luvio, resourceParams));
 }
-function ingestSuccess$7(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$9(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$c(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$6, body);
+    const key = keyBuilder$f(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$7, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$d(),
+        node: select$g(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -4037,19 +4037,19 @@ function ingestSuccess$7(luvio, resourceParams, response, snapshotRefresh) {
     }
     return snapshot;
 }
-function ingestError$5(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$c(luvio, params);
+function ingestError$6(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$f(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$6,
+        ttl: TTL$7,
         namespace: keyPrefix,
-        version: VERSION$6,
-        representationName: RepresentationType$6
+        version: VERSION$7,
+        representationName: RepresentationType$7
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$7(config) {
+function createResourceRequest$9(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -4070,7 +4070,7 @@ const getManagedContentVariantRendition_ConfigPropertyNames = {
         optional: ['channelIdOrApiName', 'language', 'version']
     }
 };
-function createResourceParams$7(config) {
+function createResourceParams$9(config) {
     const resourceParams = {
         urlParams: {
             contentKeyOrId: config.contentKeyOrId, renditionType: config.renditionType
@@ -4081,11 +4081,11 @@ function createResourceParams$7(config) {
     };
     return resourceParams;
 }
-function keyBuilder$b(luvio, config) {
-    const resourceParams = createResourceParams$7(config);
-    return keyBuilder$c(luvio, resourceParams);
+function keyBuilder$e(luvio, config) {
+    const resourceParams = createResourceParams$9(config);
+    return keyBuilder$f(luvio, resourceParams);
 }
-function typeCheckConfig$7(untrustedConfig) {
+function typeCheckConfig$9(untrustedConfig) {
     const config = {};
     const untrustedConfig_contentKeyOrId = untrustedConfig.contentKeyOrId;
     if (typeof untrustedConfig_contentKeyOrId === 'string') {
@@ -4109,48 +4109,48 @@ function typeCheckConfig$7(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$7(untrustedConfig);
+    const config = typeCheckConfig$9(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$5(luvio, config) {
-    createResourceParams$7(config);
-    return select$d();
+function adapterFragment$6(luvio, config) {
+    createResourceParams$9(config);
+    return select$g();
 }
-function onFetchResponseSuccess$5(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$7(luvio, resourceParams, response, {
+function onFetchResponseSuccess$6(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$9(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$7(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, {
+function onFetchResponseError$6(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$6(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$9(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$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$7(luvio, resourceParams, response.body));
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$6(luvio, config, resourceParams, response), () => getResponseCacheKeys$9(luvio, resourceParams, response.body));
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$5(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$6(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext) {
+function buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext) {
     const { luvio, config } = context;
     const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
     const dispatchOptions = {
@@ -4165,29 +4165,29 @@ function buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext
             priority: networkPriority
         };
     }
-    return buildNetworkSnapshot$7(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$9(luvio, config, dispatchOptions);
 }
-function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$b(luvio, config),
-        node: adapterFragment$5(luvio, config),
+        recordId: keyBuilder$e(luvio, config),
+        node: adapterFragment$6(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getManagedContentVariantRenditionAdapterFactory = (luvio) => function CMSAuthoring__getManagedContentVariantRendition(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$7(untrustedConfig, getManagedContentVariantRendition_ConfigPropertyNames);
+    const config = validateAdapterConfig$9(untrustedConfig, getManagedContentVariantRendition_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$5, buildNetworkSnapshotCachePolicy$5);
+    buildCachedSnapshotCachePolicy$6, buildNetworkSnapshotCachePolicy$6);
 };
 
 function validate$d(obj, path = 'AbstractManagedContentReferencedByItemRepresentation') {
@@ -4262,8 +4262,8 @@ function deepFreeze$b(input) {
     ObjectFreeze(input);
 }
 
-const TTL$5 = 100;
-const VERSION$5 = "c297f5edbe1b51eadd89e68f176520ba";
+const TTL$6 = 100;
+const VERSION$6 = "c297f5edbe1b51eadd89e68f176520ba";
 function validate$c(obj, path = 'ManagedContentReferencedByCollectionRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -4323,19 +4323,19 @@ function validate$c(obj, path = 'ManagedContentReferencedByCollectionRepresentat
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$5 = 'ManagedContentReferencedByCollectionRepresentation';
-function normalize$5(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$6 = 'ManagedContentReferencedByCollectionRepresentation';
+function normalize$6(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$c = function ManagedContentReferencedByCollectionRepresentationSelect() {
+const select$f = function ManagedContentReferencedByCollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$5,
+        version: VERSION$6,
         private: [],
         opaque: true
     };
 };
-function equals$5(existing, incoming) {
+function equals$6(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
@@ -4350,7 +4350,7 @@ function deepFreeze$a(input) {
     ObjectFreeze(input_referencedBy);
     ObjectFreeze(input);
 }
-const ingest$5 = function ManagedContentReferencedByCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$6 = function ManagedContentReferencedByCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$c(input);
         if (validateError !== null) {
@@ -4359,56 +4359,56 @@ const ingest$5 = function ManagedContentReferencedByCollectionRepresentationInge
     }
     const key = path.fullPath;
     const existingRecord = store.readEntry(key);
-    const ttlToUse = TTL$5;
-    let incomingRecord = normalize$5(input, store.readEntry(key), {
+    const ttlToUse = TTL$6;
+    let incomingRecord = normalize$6(input, store.readEntry(key), {
         fullPath: key,
         parent: path.parent,
         propertyName: path.propertyName,
         ttl: ttlToUse
     });
     deepFreeze$a(input);
-    if (existingRecord === undefined || equals$5(existingRecord, incomingRecord) === false) {
+    if (existingRecord === undefined || equals$6(existingRecord, incomingRecord) === false) {
         luvio.storePublish(key, incomingRecord);
     }
     {
         const storeMetadataParams = {
             ttl: ttlToUse,
             namespace: "CMSAuthoring",
-            version: VERSION$5,
-            representationName: RepresentationType$5,
+            version: VERSION$6,
+            representationName: RepresentationType$6,
         };
         luvio.publishStoreMetadata(key, storeMetadataParams);
     }
     return createLink(key);
 };
-function getTypeCacheKeys$5(luvio, input, fullPathFactory) {
+function getTypeCacheKeys$6(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$5,
+        representationName: RepresentationType$6,
         mergeable: false
     });
     return rootKeySet;
 }
 
-function select$b(luvio, params) {
-    return select$c();
+function select$e(luvio, params) {
+    return select$f();
 }
-function keyBuilder$a(luvio, params) {
+function keyBuilder$d(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$6(luvio, resourceParams, response) {
-    return getTypeCacheKeys$5(luvio, response, () => keyBuilder$a(luvio, resourceParams));
+function getResponseCacheKeys$8(luvio, resourceParams, response) {
+    return getTypeCacheKeys$6(luvio, response, () => keyBuilder$d(luvio, resourceParams));
 }
-function ingestSuccess$6(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$8(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$a(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$5, body);
+    const key = keyBuilder$d(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$6, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$b(),
+        node: select$e(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -4418,19 +4418,19 @@ function ingestSuccess$6(luvio, resourceParams, response, snapshotRefresh) {
     }
     return snapshot;
 }
-function ingestError$4(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$a(luvio, params);
+function ingestError$5(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$d(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$5,
+        ttl: TTL$6,
         namespace: keyPrefix,
-        version: VERSION$5,
-        representationName: RepresentationType$5
+        version: VERSION$6,
+        representationName: RepresentationType$6
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$6(config) {
+function createResourceRequest$8(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -4451,7 +4451,7 @@ const getManagedContentReferencedBy_ConfigPropertyNames = {
         optional: ['includeReferenceDetails', 'page', 'pageSize', 'referenceType']
     }
 };
-function createResourceParams$6(config) {
+function createResourceParams$8(config) {
     const resourceParams = {
         urlParams: {
             contentKeyOrId: config.contentKeyOrId
@@ -4462,11 +4462,11 @@ function createResourceParams$6(config) {
     };
     return resourceParams;
 }
-function keyBuilder$9(luvio, config) {
-    const resourceParams = createResourceParams$6(config);
-    return keyBuilder$a(luvio, resourceParams);
+function keyBuilder$c(luvio, config) {
+    const resourceParams = createResourceParams$8(config);
+    return keyBuilder$d(luvio, resourceParams);
 }
-function typeCheckConfig$6(untrustedConfig) {
+function typeCheckConfig$8(untrustedConfig) {
     const config = {};
     const untrustedConfig_contentKeyOrId = untrustedConfig.contentKeyOrId;
     if (typeof untrustedConfig_contentKeyOrId === 'string') {
@@ -4490,48 +4490,48 @@ function typeCheckConfig$6(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$6(untrustedConfig);
+    const config = typeCheckConfig$8(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$4(luvio, config) {
-    createResourceParams$6(config);
-    return select$b();
+function adapterFragment$5(luvio, config) {
+    createResourceParams$8(config);
+    return select$e();
 }
-function onFetchResponseSuccess$4(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$6(luvio, resourceParams, response, {
+function onFetchResponseSuccess$5(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$8(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$6(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, {
+function onFetchResponseError$5(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$5(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$8(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$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$6(luvio, resourceParams, response.body));
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$5(luvio, config, resourceParams, response), () => getResponseCacheKeys$8(luvio, resourceParams, response.body));
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$4(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$5(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext) {
+function buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext) {
     const { luvio, config } = context;
     const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
     const dispatchOptions = {
@@ -4546,29 +4546,29 @@ function buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext
             priority: networkPriority
         };
     }
-    return buildNetworkSnapshot$6(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$8(luvio, config, dispatchOptions);
 }
-function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$9(luvio, config),
-        node: adapterFragment$4(luvio, config),
+        recordId: keyBuilder$c(luvio, config),
+        node: adapterFragment$5(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getManagedContentReferencedByAdapterFactory = (luvio) => function CMSAuthoring__getManagedContentReferencedBy(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$6(untrustedConfig, getManagedContentReferencedBy_ConfigPropertyNames);
+    const config = validateAdapterConfig$8(untrustedConfig, getManagedContentReferencedBy_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$4, buildNetworkSnapshotCachePolicy$4);
+    buildCachedSnapshotCachePolicy$5, buildNetworkSnapshotCachePolicy$5);
 };
 
 function validate$b(obj, path = 'ManagedContentLanguageSummaryRepresentation') {
@@ -4690,8 +4690,8 @@ function deepFreeze$8(input) {
     ObjectFreeze(input);
 }
 
-const TTL$4 = 100;
-const VERSION$4 = "944ebf1d8e72c74b2d0a208b3dfa8326";
+const TTL$5 = 100;
+const VERSION$5 = "944ebf1d8e72c74b2d0a208b3dfa8326";
 function validate$9(obj, path = 'ManagedContentVariantReferencesCollectionRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -4724,19 +4724,19 @@ function validate$9(obj, path = 'ManagedContentVariantReferencesCollectionRepres
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$4 = 'ManagedContentVariantReferencesCollectionRepresentation';
-function normalize$4(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$5 = 'ManagedContentVariantReferencesCollectionRepresentation';
+function normalize$5(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$a = function ManagedContentVariantReferencesCollectionRepresentationSelect() {
+const select$d = function ManagedContentVariantReferencesCollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$4,
+        version: VERSION$5,
         private: [],
         opaque: true
     };
 };
-function equals$4(existing, incoming) {
+function equals$5(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
@@ -4758,7 +4758,7 @@ function deepFreeze$7(input) {
     ObjectFreeze(input_referenceVariants);
     ObjectFreeze(input);
 }
-const ingest$4 = function ManagedContentVariantReferencesCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$5 = function ManagedContentVariantReferencesCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$9(input);
         if (validateError !== null) {
@@ -4767,56 +4767,56 @@ const ingest$4 = function ManagedContentVariantReferencesCollectionRepresentatio
     }
     const key = path.fullPath;
     const existingRecord = store.readEntry(key);
-    const ttlToUse = TTL$4;
-    let incomingRecord = normalize$4(input, store.readEntry(key), {
+    const ttlToUse = TTL$5;
+    let incomingRecord = normalize$5(input, store.readEntry(key), {
         fullPath: key,
         parent: path.parent,
         propertyName: path.propertyName,
         ttl: ttlToUse
     });
     deepFreeze$7(input);
-    if (existingRecord === undefined || equals$4(existingRecord, incomingRecord) === false) {
+    if (existingRecord === undefined || equals$5(existingRecord, incomingRecord) === false) {
         luvio.storePublish(key, incomingRecord);
     }
     {
         const storeMetadataParams = {
             ttl: ttlToUse,
             namespace: "CMSAuthoring",
-            version: VERSION$4,
-            representationName: RepresentationType$4,
+            version: VERSION$5,
+            representationName: RepresentationType$5,
         };
         luvio.publishStoreMetadata(key, storeMetadataParams);
     }
     return createLink(key);
 };
-function getTypeCacheKeys$4(luvio, input, fullPathFactory) {
+function getTypeCacheKeys$5(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$4,
+        representationName: RepresentationType$5,
         mergeable: false
     });
     return rootKeySet;
 }
 
-function select$9(luvio, params) {
-    return select$a();
+function select$c(luvio, params) {
+    return select$d();
 }
-function keyBuilder$8(luvio, params) {
+function keyBuilder$b(luvio, params) {
     return keyPrefix + '::ManagedContentVariantReferencesCollectionRepresentation:(' + 'variantIds:' + params.queryParams.variantIds + ',' + 'contentKeyOrId:' + params.urlParams.contentKeyOrId + ')';
 }
-function getResponseCacheKeys$5(luvio, resourceParams, response) {
-    return getTypeCacheKeys$4(luvio, response, () => keyBuilder$8(luvio, resourceParams));
+function getResponseCacheKeys$7(luvio, resourceParams, response) {
+    return getTypeCacheKeys$5(luvio, response, () => keyBuilder$b(luvio, resourceParams));
 }
-function ingestSuccess$5(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$7(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$8(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$4, body);
+    const key = keyBuilder$b(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$5, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$9(),
+        node: select$c(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -4826,19 +4826,19 @@ function ingestSuccess$5(luvio, resourceParams, response, snapshotRefresh) {
     }
     return snapshot;
 }
-function ingestError$3(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$8(luvio, params);
+function ingestError$4(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$b(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$4,
+        ttl: TTL$5,
         namespace: keyPrefix,
-        version: VERSION$4,
-        representationName: RepresentationType$4
+        version: VERSION$5,
+        representationName: RepresentationType$5
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$5(config) {
+function createResourceRequest$7(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -4859,7 +4859,7 @@ const getManagedContentVariantReferences_ConfigPropertyNames = {
         optional: ['variantIds']
     }
 };
-function createResourceParams$5(config) {
+function createResourceParams$7(config) {
     const resourceParams = {
         urlParams: {
             contentKeyOrId: config.contentKeyOrId
@@ -4870,11 +4870,11 @@ function createResourceParams$5(config) {
     };
     return resourceParams;
 }
-function keyBuilder$7(luvio, config) {
-    const resourceParams = createResourceParams$5(config);
-    return keyBuilder$8(luvio, resourceParams);
+function keyBuilder$a(luvio, config) {
+    const resourceParams = createResourceParams$7(config);
+    return keyBuilder$b(luvio, resourceParams);
 }
-function typeCheckConfig$5(untrustedConfig) {
+function typeCheckConfig$7(untrustedConfig) {
     const config = {};
     const untrustedConfig_contentKeyOrId = untrustedConfig.contentKeyOrId;
     if (typeof untrustedConfig_contentKeyOrId === 'string') {
@@ -4893,48 +4893,48 @@ function typeCheckConfig$5(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$5(untrustedConfig);
+    const config = typeCheckConfig$7(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$3(luvio, config) {
-    createResourceParams$5(config);
-    return select$9();
+function adapterFragment$4(luvio, config) {
+    createResourceParams$7(config);
+    return select$c();
 }
-function onFetchResponseSuccess$3(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$5(luvio, resourceParams, response, {
+function onFetchResponseSuccess$4(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$7(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$5(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, {
+function onFetchResponseError$4(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$4(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$7(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$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$5(luvio, resourceParams, response.body));
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$4(luvio, config, resourceParams, response), () => getResponseCacheKeys$7(luvio, resourceParams, response.body));
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$3(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$4(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext) {
+function buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext) {
     const { luvio, config } = context;
     const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
     const dispatchOptions = {
@@ -4949,29 +4949,29 @@ function buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext
             priority: networkPriority
         };
     }
-    return buildNetworkSnapshot$5(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$7(luvio, config, dispatchOptions);
 }
-function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$7(luvio, config),
-        node: adapterFragment$3(luvio, config),
+        recordId: keyBuilder$a(luvio, config),
+        node: adapterFragment$4(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getManagedContentVariantReferencesAdapterFactory = (luvio) => function CMSAuthoring__getManagedContentVariantReferences(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$5(untrustedConfig, getManagedContentVariantReferences_ConfigPropertyNames);
+    const config = validateAdapterConfig$7(untrustedConfig, getManagedContentVariantReferences_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$3, buildNetworkSnapshotCachePolicy$3);
+    buildCachedSnapshotCachePolicy$4, buildNetworkSnapshotCachePolicy$4);
 };
 
 function validate$8(obj, path = 'ManagedContentSpaceFolderItemRepresentation') {
@@ -5094,8 +5094,8 @@ function deepFreeze$6(input) {
     ObjectFreeze(input);
 }
 
-const TTL$3 = 100;
-const VERSION$3 = "e85b8f02eca0f2e88859e6f3a061e56b";
+const TTL$4 = 100;
+const VERSION$4 = "e85b8f02eca0f2e88859e6f3a061e56b";
 function validate$7(obj, path = 'ManagedContentSpaceFolderItemCollectionRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -5150,19 +5150,19 @@ function validate$7(obj, path = 'ManagedContentSpaceFolderItemCollectionRepresen
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$3 = 'ManagedContentSpaceFolderItemCollectionRepresentation';
-function normalize$3(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$4 = 'ManagedContentSpaceFolderItemCollectionRepresentation';
+function normalize$4(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$8 = function ManagedContentSpaceFolderItemCollectionRepresentationSelect() {
+const select$b = function ManagedContentSpaceFolderItemCollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$3,
+        version: VERSION$4,
         private: [],
         opaque: true
     };
 };
-function equals$3(existing, incoming) {
+function equals$4(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
@@ -5177,7 +5177,7 @@ function deepFreeze$5(input) {
     ObjectFreeze(input_folderItems);
     ObjectFreeze(input);
 }
-const ingest$3 = function ManagedContentSpaceFolderItemCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$4 = function ManagedContentSpaceFolderItemCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$7(input);
         if (validateError !== null) {
@@ -5186,56 +5186,56 @@ const ingest$3 = function ManagedContentSpaceFolderItemCollectionRepresentationI
     }
     const key = path.fullPath;
     const existingRecord = store.readEntry(key);
-    const ttlToUse = TTL$3;
-    let incomingRecord = normalize$3(input, store.readEntry(key), {
+    const ttlToUse = TTL$4;
+    let incomingRecord = normalize$4(input, store.readEntry(key), {
         fullPath: key,
         parent: path.parent,
         propertyName: path.propertyName,
         ttl: ttlToUse
     });
     deepFreeze$5(input);
-    if (existingRecord === undefined || equals$3(existingRecord, incomingRecord) === false) {
+    if (existingRecord === undefined || equals$4(existingRecord, incomingRecord) === false) {
         luvio.storePublish(key, incomingRecord);
     }
     {
         const storeMetadataParams = {
             ttl: ttlToUse,
             namespace: "CMSAuthoring",
-            version: VERSION$3,
-            representationName: RepresentationType$3,
+            version: VERSION$4,
+            representationName: RepresentationType$4,
         };
         luvio.publishStoreMetadata(key, storeMetadataParams);
     }
     return createLink(key);
 };
-function getTypeCacheKeys$3(luvio, input, fullPathFactory) {
+function getTypeCacheKeys$4(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$3,
+        representationName: RepresentationType$4,
         mergeable: false
     });
     return rootKeySet;
 }
 
-function select$7(luvio, params) {
-    return select$8();
+function select$a(luvio, params) {
+    return select$b();
 }
-function keyBuilder$6(luvio, params) {
+function keyBuilder$9(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$4(luvio, resourceParams, response) {
-    return getTypeCacheKeys$3(luvio, response, () => keyBuilder$6(luvio, resourceParams));
+function getResponseCacheKeys$6(luvio, resourceParams, response) {
+    return getTypeCacheKeys$4(luvio, response, () => keyBuilder$9(luvio, resourceParams));
 }
-function ingestSuccess$4(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$6(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$6(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$3, body);
+    const key = keyBuilder$9(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$4, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$7(),
+        node: select$a(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -5245,19 +5245,19 @@ function ingestSuccess$4(luvio, resourceParams, response, snapshotRefresh) {
     }
     return snapshot;
 }
-function ingestError$2(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$6(luvio, params);
+function ingestError$3(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$9(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$3,
+        ttl: TTL$4,
         namespace: keyPrefix,
-        version: VERSION$3,
-        representationName: RepresentationType$3
+        version: VERSION$4,
+        representationName: RepresentationType$4
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$4(config) {
+function createResourceRequest$6(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -5278,7 +5278,7 @@ const getManagedContentByFolderId_ConfigPropertyNames = {
         optional: ['contentType', 'contentTypeFilter', 'contentTypes', 'filter', 'page', 'pageSize', 'queryTerm', 'showPublishedOnly', 'sortBy', 'sortOrder']
     }
 };
-function createResourceParams$4(config) {
+function createResourceParams$6(config) {
     const resourceParams = {
         urlParams: {
             folderId: config.folderId
@@ -5289,11 +5289,11 @@ function createResourceParams$4(config) {
     };
     return resourceParams;
 }
-function keyBuilder$5(luvio, config) {
-    const resourceParams = createResourceParams$4(config);
-    return keyBuilder$6(luvio, resourceParams);
+function keyBuilder$8(luvio, config) {
+    const resourceParams = createResourceParams$6(config);
+    return keyBuilder$9(luvio, resourceParams);
 }
-function typeCheckConfig$4(untrustedConfig) {
+function typeCheckConfig$6(untrustedConfig) {
     const config = {};
     const untrustedConfig_folderId = untrustedConfig.folderId;
     if (typeof untrustedConfig_folderId === 'string') {
@@ -5348,48 +5348,48 @@ function typeCheckConfig$4(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$4(untrustedConfig);
+    const config = typeCheckConfig$6(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$2(luvio, config) {
-    createResourceParams$4(config);
-    return select$7();
+function adapterFragment$3(luvio, config) {
+    createResourceParams$6(config);
+    return select$a();
 }
-function onFetchResponseSuccess$2(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$4(luvio, resourceParams, response, {
+function onFetchResponseSuccess$3(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$6(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$4(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, {
+function onFetchResponseError$3(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$3(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$6(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$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$4(luvio, resourceParams, response.body));
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$3(luvio, config, resourceParams, response), () => getResponseCacheKeys$6(luvio, resourceParams, response.body));
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$2(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$3(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$2(context, coercedAdapterRequestContext) {
+function buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext) {
     const { luvio, config } = context;
     const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
     const dispatchOptions = {
@@ -5404,29 +5404,29 @@ function buildNetworkSnapshotCachePolicy$2(context, coercedAdapterRequestContext
             priority: networkPriority
         };
     }
-    return buildNetworkSnapshot$4(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$6(luvio, config, dispatchOptions);
 }
-function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$5(luvio, config),
-        node: adapterFragment$2(luvio, config),
+        recordId: keyBuilder$8(luvio, config),
+        node: adapterFragment$3(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getManagedContentByFolderIdAdapterFactory = (luvio) => function CMSAuthoring__getManagedContentByFolderId(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$4(untrustedConfig, getManagedContentByFolderId_ConfigPropertyNames);
+    const config = validateAdapterConfig$6(untrustedConfig, getManagedContentByFolderId_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$2, buildNetworkSnapshotCachePolicy$2);
+    buildCachedSnapshotCachePolicy$3, buildNetworkSnapshotCachePolicy$3);
 };
 
 function validate$6(obj, path = 'AbstractManagedContentSearchResultRepresentation') {
@@ -5496,8 +5496,8 @@ function deepFreeze$4(input) {
     ObjectFreeze(input);
 }
 
-const TTL$2 = 100;
-const VERSION$2 = "bbcdc04e5d094f6f8048bc2863d86527";
+const TTL$3 = 100;
+const VERSION$3 = "bbcdc04e5d094f6f8048bc2863d86527";
 function validate$5(obj, path = 'ManagedContentSearchResultItemsCollectionRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -5536,19 +5536,19 @@ function validate$5(obj, path = 'ManagedContentSearchResultItemsCollectionRepres
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$2 = 'ManagedContentSearchResultItemsCollectionRepresentation';
-function normalize$2(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$3 = 'ManagedContentSearchResultItemsCollectionRepresentation';
+function normalize$3(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$6 = function ManagedContentSearchResultItemsCollectionRepresentationSelect() {
+const select$9 = function ManagedContentSearchResultItemsCollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$2,
+        version: VERSION$3,
         private: [],
         opaque: true
     };
 };
-function equals$2(existing, incoming) {
+function equals$3(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
@@ -5563,7 +5563,7 @@ function deepFreeze$3(input) {
     ObjectFreeze(input_items);
     ObjectFreeze(input);
 }
-const ingest$2 = function ManagedContentSearchResultItemsCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$3 = function ManagedContentSearchResultItemsCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$5(input);
         if (validateError !== null) {
@@ -5572,56 +5572,56 @@ const ingest$2 = function ManagedContentSearchResultItemsCollectionRepresentatio
     }
     const key = path.fullPath;
     const existingRecord = store.readEntry(key);
-    const ttlToUse = TTL$2;
-    let incomingRecord = normalize$2(input, store.readEntry(key), {
+    const ttlToUse = TTL$3;
+    let incomingRecord = normalize$3(input, store.readEntry(key), {
         fullPath: key,
         parent: path.parent,
         propertyName: path.propertyName,
         ttl: ttlToUse
     });
     deepFreeze$3(input);
-    if (existingRecord === undefined || equals$2(existingRecord, incomingRecord) === false) {
+    if (existingRecord === undefined || equals$3(existingRecord, incomingRecord) === false) {
         luvio.storePublish(key, incomingRecord);
     }
     {
         const storeMetadataParams = {
             ttl: ttlToUse,
             namespace: "CMSAuthoring",
-            version: VERSION$2,
-            representationName: RepresentationType$2,
+            version: VERSION$3,
+            representationName: RepresentationType$3,
         };
         luvio.publishStoreMetadata(key, storeMetadataParams);
     }
     return createLink(key);
 };
-function getTypeCacheKeys$2(luvio, input, fullPathFactory) {
+function getTypeCacheKeys$3(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$2,
+        representationName: RepresentationType$3,
         mergeable: false
     });
     return rootKeySet;
 }
 
-function select$5(luvio, params) {
-    return select$6();
+function select$8(luvio, params) {
+    return select$9();
 }
-function keyBuilder$4(luvio, params) {
+function keyBuilder$7(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) {
-    return getTypeCacheKeys$2(luvio, response, () => keyBuilder$4(luvio, resourceParams));
+function getResponseCacheKeys$5(luvio, resourceParams, response) {
+    return getTypeCacheKeys$3(luvio, response, () => keyBuilder$7(luvio, resourceParams));
 }
-function ingestSuccess$3(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$5(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$4(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$2, body);
+    const key = keyBuilder$7(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$3, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$5(),
+        node: select$8(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -5631,19 +5631,19 @@ function ingestSuccess$3(luvio, resourceParams, response, snapshotRefresh) {
     }
     return snapshot;
 }
-function ingestError$1(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$4(luvio, params);
+function ingestError$2(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$7(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$2,
+        ttl: TTL$3,
         namespace: keyPrefix,
-        version: VERSION$2,
-        representationName: RepresentationType$2
+        version: VERSION$3,
+        representationName: RepresentationType$3
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$3(config) {
+function createResourceRequest$5(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -5664,7 +5664,7 @@ const getSearchResults_ConfigPropertyNames = {
         optional: ['contentSpaceOrFolderIds', 'contentTypeFQN', 'languages', 'page', 'pageSize', 'scope']
     }
 };
-function createResourceParams$3(config) {
+function createResourceParams$5(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
@@ -5672,11 +5672,11 @@ function createResourceParams$3(config) {
     };
     return resourceParams;
 }
-function keyBuilder$3(luvio, config) {
-    const resourceParams = createResourceParams$3(config);
-    return keyBuilder$4(luvio, resourceParams);
+function keyBuilder$6(luvio, config) {
+    const resourceParams = createResourceParams$5(config);
+    return keyBuilder$7(luvio, resourceParams);
 }
-function typeCheckConfig$3(untrustedConfig) {
+function typeCheckConfig$5(untrustedConfig) {
     const config = {};
     const untrustedConfig_contentSpaceOrFolderIds = untrustedConfig.contentSpaceOrFolderIds;
     if (ArrayIsArray$1(untrustedConfig_contentSpaceOrFolderIds)) {
@@ -5722,48 +5722,48 @@ function typeCheckConfig$3(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$3(untrustedConfig);
+    const config = typeCheckConfig$5(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$1(luvio, config) {
-    createResourceParams$3(config);
-    return select$5();
+function adapterFragment$2(luvio, config) {
+    createResourceParams$5(config);
+    return select$8();
 }
-function onFetchResponseSuccess$1(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$3(luvio, resourceParams, response, {
+function onFetchResponseSuccess$2(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$5(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$3(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, {
+function onFetchResponseError$2(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$2(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$5(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$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$3(luvio, resourceParams, response.body));
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$2(luvio, config, resourceParams, response), () => getResponseCacheKeys$5(luvio, resourceParams, response.body));
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$1(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$2(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext) {
+function buildNetworkSnapshotCachePolicy$2(context, coercedAdapterRequestContext) {
     const { luvio, config } = context;
     const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
     const dispatchOptions = {
@@ -5778,31 +5778,33 @@ function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext
             priority: networkPriority
         };
     }
-    return buildNetworkSnapshot$3(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$5(luvio, config, dispatchOptions);
 }
-function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$3(luvio, config),
-        node: adapterFragment$1(luvio, config),
+        recordId: keyBuilder$6(luvio, config),
+        node: adapterFragment$2(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getSearchResultsAdapterFactory = (luvio) => function CMSAuthoring__getSearchResults(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$3(untrustedConfig, getSearchResults_ConfigPropertyNames);
+    const config = validateAdapterConfig$5(untrustedConfig, getSearchResults_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$1, buildNetworkSnapshotCachePolicy$1);
+    buildCachedSnapshotCachePolicy$2, buildNetworkSnapshotCachePolicy$2);
 };
 
+const TTL$2 = 100;
+const VERSION$2 = "72679343637cbdd587e2f087852030d7";
 function validate$4(obj, path = 'ManagedContentSpaceRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -5833,6 +5835,32 @@ function validate$4(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';
@@ -5877,16 +5905,85 @@ function validate$4(obj, path = 'ManagedContentSpaceRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
+const RepresentationType$2 = 'ManagedContentSpaceRepresentation';
+function keyBuilder$5(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$2 + ':' + config.id;
+}
+function keyBuilderFromType$1(luvio, object) {
+    const keyParams = {
+        id: object.id
+    };
+    return keyBuilder$5(luvio, keyParams);
+}
+function normalize$2(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$7 = function ManagedContentSpaceRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$2,
+        private: [],
+        opaque: true
+    };
+};
+function equals$2(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
 function deepFreeze$2(input) {
     const input_supportedLanguages = input.supportedLanguages;
     if (input_supportedLanguages !== undefined) {
         ObjectFreeze(input_supportedLanguages);
     }
     ObjectFreeze(input);
+}
+const ingest$2 = function ManagedContentSpaceRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$4(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$1(luvio, input);
+    const existingRecord = store.readEntry(key);
+    const ttlToUse = TTL$2;
+    let incomingRecord = normalize$2(input, store.readEntry(key), {
+        fullPath: key,
+        parent: path.parent,
+        propertyName: path.propertyName,
+        ttl: ttlToUse
+    });
+    deepFreeze$2(input);
+    if (existingRecord === undefined || equals$2(existingRecord, incomingRecord) === false) {
+        luvio.storePublish(key, incomingRecord);
+    }
+    {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "CMSAuthoring",
+            version: VERSION$2,
+            representationName: RepresentationType$2,
+        };
+        luvio.publishStoreMetadata(key, storeMetadataParams);
+    }
+    return createLink(key);
+};
+function getTypeCacheKeys$2(luvio, input, fullPathFactory) {
+    const rootKeySet = new StoreKeyMap();
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$1(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$2,
+        mergeable: false
+    });
+    return rootKeySet;
 }
 
 const TTL$1 = 100;
-const VERSION$1 = "8bf10074a521799f8a3f77915051deb0";
+const VERSION$1 = "292efba3a426b62d2af39a38fd3464b0";
 function validate$3(obj, path = 'ManagedContentSpaceCollectionRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -5914,7 +6011,7 @@ const RepresentationType$1 = 'ManagedContentSpaceCollectionRepresentation';
 function normalize$1(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$4 = function ManagedContentSpaceCollectionRepresentationSelect() {
+const select$6 = function ManagedContentSpaceCollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$1,
@@ -5980,22 +6077,22 @@ function getTypeCacheKeys$1(luvio, input, fullPathFactory) {
     return rootKeySet;
 }
 
-function select$3(luvio, params) {
-    return select$4();
+function select$5(luvio, params) {
+    return select$6();
 }
-function keyBuilder$2(luvio, params) {
+function keyBuilder$4(luvio, params) {
     return keyPrefix + '::ManagedContentSpaceCollectionRepresentation:(' + 'page:' + params.queryParams.page + ',' + 'pageSize:' + params.queryParams.pageSize + ')';
 }
-function getResponseCacheKeys$2(luvio, resourceParams, response) {
-    return getTypeCacheKeys$1(luvio, response, () => keyBuilder$2(luvio, resourceParams));
+function getResponseCacheKeys$4(luvio, resourceParams, response) {
+    return getTypeCacheKeys$1(luvio, response, () => keyBuilder$4(luvio, resourceParams));
 }
-function ingestSuccess$2(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$4(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$2(luvio, resourceParams);
+    const key = keyBuilder$4(luvio, resourceParams);
     luvio.storeIngest(key, ingest$1, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$3(),
+        node: select$5(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -6005,8 +6102,8 @@ function ingestSuccess$2(luvio, resourceParams, response, snapshotRefresh) {
     }
     return snapshot;
 }
-function ingestError(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$2(luvio, params);
+function ingestError$1(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$4(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
         ttl: TTL$1,
@@ -6017,7 +6114,7 @@ function ingestError(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$2(config) {
+function createResourceRequest$4(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v58.0',
@@ -6038,7 +6135,7 @@ const getManagedContentSpaces_ConfigPropertyNames = {
         optional: ['page', 'pageSize']
     }
 };
-function createResourceParams$2(config) {
+function createResourceParams$4(config) {
     const resourceParams = {
         queryParams: {
             page: config.page, pageSize: config.pageSize
@@ -6046,11 +6143,11 @@ function createResourceParams$2(config) {
     };
     return resourceParams;
 }
-function keyBuilder$1(luvio, config) {
-    const resourceParams = createResourceParams$2(config);
-    return keyBuilder$2(luvio, resourceParams);
+function keyBuilder$3(luvio, config) {
+    const resourceParams = createResourceParams$4(config);
+    return keyBuilder$4(luvio, resourceParams);
 }
-function typeCheckConfig$2(untrustedConfig) {
+function typeCheckConfig$4(untrustedConfig) {
     const config = {};
     const untrustedConfig_page = untrustedConfig.page;
     if (typeof untrustedConfig_page === 'number' && Math.floor(untrustedConfig_page) === untrustedConfig_page) {
@@ -6062,43 +6159,204 @@ function typeCheckConfig$2(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$2(untrustedConfig);
+    const config = typeCheckConfig$4(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment$1(luvio, config) {
+    createResourceParams$4(config);
+    return select$5();
+}
+function onFetchResponseSuccess$1(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$4(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$4(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)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+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$1(luvio, config, resourceParams, response), () => getResponseCacheKeys$4(luvio, resourceParams, response.body));
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$1(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$1(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$4(luvio, config, dispatchOptions);
+}
+function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$3(luvio, config),
+        node: adapterFragment$1(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getManagedContentSpacesAdapterFactory = (luvio) => function CMSAuthoring__getManagedContentSpaces(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$4(untrustedConfig, getManagedContentSpaces_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$1, buildNetworkSnapshotCachePolicy$1);
+};
+
+function select$4(luvio, params) {
+    return select$7();
+}
+function keyBuilder$2(luvio, params) {
+    return keyBuilder$5(luvio, {
+        id: params.urlParams.contentSpaceId
+    });
+}
+function getResponseCacheKeys$3(luvio, resourceParams, response) {
+    return getTypeCacheKeys$2(luvio, response);
+}
+function ingestSuccess$3(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$2(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$2, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$4(),
+        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(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$2(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    const storeMetadataParams = {
+        ttl: TTL$2,
+        namespace: keyPrefix,
+        version: VERSION$2,
+        representationName: RepresentationType$2
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
+function createResourceRequest$3(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',
+    };
+}
+
+const getManagedContentSpace_ConfigPropertyNames = {
+    displayName: 'getManagedContentSpace',
+    parameters: {
+        required: ['contentSpaceId'],
+        optional: []
+    }
+};
+function createResourceParams$3(config) {
+    const resourceParams = {
+        urlParams: {
+            contentSpaceId: config.contentSpaceId
+        }
+    };
+    return resourceParams;
+}
+function keyBuilder$1(luvio, config) {
+    const resourceParams = createResourceParams$3(config);
+    return keyBuilder$2(luvio, resourceParams);
+}
+function typeCheckConfig$3(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contentSpaceId = untrustedConfig.contentSpaceId;
+    if (typeof untrustedConfig_contentSpaceId === 'string') {
+        config.contentSpaceId = untrustedConfig_contentSpaceId;
+    }
+    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 adapterFragment(luvio, config) {
-    createResourceParams$2(config);
-    return select$3();
+    createResourceParams$3(config);
+    return select$4();
 }
 function onFetchResponseSuccess(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$2(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$3(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError(luvio, config, resourceParams, response) {
     const snapshot = ingestError(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$2(luvio, config, options) {
-    const resourceParams = createResourceParams$2(config);
-    const request = createResourceRequest$2(resourceParams);
+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(() => onFetchResponseSuccess(luvio, config, resourceParams, response), () => getResponseCacheKeys$2(luvio, resourceParams, response.body));
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess(luvio, config, resourceParams, response), () => getResponseCacheKeys$3(luvio, resourceParams, response.body));
     }, (response) => {
         return luvio.handleErrorResponse(() => onFetchResponseError(luvio, config, resourceParams, response));
     });
@@ -6118,7 +6376,7 @@ function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext)
             priority: networkPriority
         };
     }
-    return buildNetworkSnapshot$2(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$3(luvio, config, dispatchOptions);
 }
 function buildCachedSnapshotCachePolicy(context, storeLookup) {
     const { luvio, config } = context;
@@ -6129,12 +6387,12 @@ function buildCachedSnapshotCachePolicy(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
-const getManagedContentSpacesAdapterFactory = (luvio) => function CMSAuthoring__getManagedContentSpaces(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$2(untrustedConfig, getManagedContentSpaces_ConfigPropertyNames);
+const getManagedContentSpaceAdapterFactory = (luvio) => function CMSAuthoring__getManagedContentSpace(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$3(untrustedConfig, getManagedContentSpace_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -6143,6 +6401,162 @@ const getManagedContentSpacesAdapterFactory = (luvio) => function CMSAuthoring__
     buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
 };
 
+function select$3(luvio, params) {
+    return select$7();
+}
+function getResponseCacheKeys$2(luvio, resourceParams, response) {
+    return getTypeCacheKeys$2(luvio, response);
+}
+function ingestSuccess$2(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$1(luvio, body);
+    luvio.storeIngest(key, ingest$2, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$3(),
+        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$2(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$2(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$2(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$2(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$2(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$2(luvio, config, options) {
+    const resourceParams = createResourceParams$2(config);
+    const request = createResourceRequest$2(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$2(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => getResponseCacheKeys$2(luvio, resourceParams, response.body));
+    }, (response) => {
+        deepFreeze$u(response);
+        throw response;
+    });
+}
+const patchManagedContentSpaceAdapterFactory = (luvio) => {
+    return function patchManagedContentSpace(untrustedConfig) {
+        const config = validateAdapterConfig$2(untrustedConfig, patchManagedContentSpace_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "patchManagedContentSpace"');
+        }
+        return buildNetworkSnapshot$2(luvio, config);
+    };
+};
+
 function validate$2(obj, path = 'ManagedContentExportContentV2JobRequestInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -6657,4 +7071,4 @@ const createManagedContentImportV2JobAdapterFactory = (luvio) => {
     };
 };
 
-export { createDeploymentAdapterFactory, createManagedContentAdapterFactory, createManagedContentExportV2JobAdapterFactory, createManagedContentImportV2JobAdapterFactory, createManagedContentVariantAdapterFactory, createTranslationV2JobAdapterFactory, deleteManagedContentVariantAdapterFactory, getCollectionItemsAdapterFactory, getManagedContentAdapterFactory, getManagedContentByFolderIdAdapterFactory, getManagedContentReferencedByAdapterFactory, getManagedContentSpacesAdapterFactory, getManagedContentVariantAdapterFactory, getManagedContentVariantReferencesAdapterFactory, getManagedContentVariantRenditionAdapterFactory, getManagedContentVariantVersionsAdapterFactory, getSearchResultsAdapterFactory, publishManagedContentAdapterFactory, replaceManagedContentVariantAdapterFactory, unpublishManagedContentAdapterFactory };
+export { createDeploymentAdapterFactory, createManagedContentAdapterFactory, createManagedContentExportV2JobAdapterFactory, createManagedContentImportV2JobAdapterFactory, createManagedContentVariantAdapterFactory, createTranslationV2JobAdapterFactory, deleteManagedContentVariantAdapterFactory, getCollectionItemsAdapterFactory, getManagedContentAdapterFactory, getManagedContentByFolderIdAdapterFactory, getManagedContentReferencedByAdapterFactory, getManagedContentSpaceAdapterFactory, getManagedContentSpacesAdapterFactory, getManagedContentVariantAdapterFactory, getManagedContentVariantReferencesAdapterFactory, getManagedContentVariantRenditionAdapterFactory, getManagedContentVariantVersionsAdapterFactory, getSearchResultsAdapterFactory, patchManagedContentSpaceAdapterFactory, publishManagedContentAdapterFactory, replaceManagedContentVariantAdapterFactory, unpublishManagedContentAdapterFactory };