@salesforce/lds-adapters-cms-authoring 1.273.0 → 1.274.0

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

@@ -4,7 +4,7 @@
  * For full license text, see the LICENSE.txt file
  */
 
-import { serializeStructuredKey, ingestShape, deepFreeze, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$l, typeCheckConfig as typeCheckConfig$B, StoreKeyMap, createResourceParams as createResourceParams$B } from '@luvio/engine';
+import { serializeStructuredKey, ingestShape, deepFreeze, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$l, typeCheckConfig as typeCheckConfig$C, StoreKeyMap, createResourceParams as createResourceParams$C } from '@luvio/engine';
 
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
 const { keys: ObjectKeys$1, create: ObjectCreate$1 } = Object;
@@ -93,8 +93,8 @@ function createLink(ref) {
     };
 }
 
-const VERSION$z = "7297fb0dbfe8f664d76179a65037c290";
-function validate$12(obj, path = 'ManagedContentTypeSummaryRepresentation') {
+const VERSION$A = "7297fb0dbfe8f664d76179a65037c290";
+function validate$18(obj, path = 'ManagedContentTypeSummaryRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -114,10 +114,10 @@ function validate$12(obj, path = 'ManagedContentTypeSummaryRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$17 = function ManagedContentTypeSummaryRepresentationSelect() {
+const select$19 = function ManagedContentTypeSummaryRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$z,
+        version: VERSION$A,
         private: [],
         selections: [
             {
@@ -132,7 +132,7 @@ const select$17 = function ManagedContentTypeSummaryRepresentationSelect() {
         ]
     };
 };
-function equals$z(existing, incoming) {
+function equals$A(existing, incoming) {
     const existing_fullyQualifiedName = existing.fullyQualifiedName;
     const incoming_fullyQualifiedName = incoming.fullyQualifiedName;
     if (!(existing_fullyQualifiedName === incoming_fullyQualifiedName)) {
@@ -154,8 +154,8 @@ function equals$z(existing, incoming) {
     return true;
 }
 
-const VERSION$y = "c30d880a3dba684a405d1cf961af2b76";
-function validate$11(obj, path = 'ManagedContentVariantSnapshotSummaryRepresentation') {
+const VERSION$z = "c30d880a3dba684a405d1cf961af2b76";
+function validate$17(obj, path = 'ManagedContentVariantSnapshotSummaryRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -164,7 +164,7 @@ function validate$11(obj, path = 'ManagedContentVariantSnapshotSummaryRepresenta
         const path_contentType = path + '.contentType';
         let obj_contentType_union0 = null;
         const obj_contentType_union0_error = (() => {
-            const referencepath_contentTypeValidationError = validate$12(obj_contentType, path_contentType);
+            const referencepath_contentTypeValidationError = validate$18(obj_contentType, path_contentType);
             if (referencepath_contentTypeValidationError !== null) {
                 let message = 'Object doesn\'t match ManagedContentTypeSummaryRepresentation (at "' + path_contentType + '")\n';
                 message += referencepath_contentTypeValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -322,11 +322,11 @@ function validate$11(obj, path = 'ManagedContentVariantSnapshotSummaryRepresenta
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$16 = function ManagedContentVariantSnapshotSummaryRepresentationSelect() {
-    const { selections: ManagedContentTypeSummaryRepresentation__selections, opaque: ManagedContentTypeSummaryRepresentation__opaque, } = select$17();
+const select$18 = function ManagedContentVariantSnapshotSummaryRepresentationSelect() {
+    const { selections: ManagedContentTypeSummaryRepresentation__selections, opaque: ManagedContentTypeSummaryRepresentation__opaque, } = select$19();
     return {
         kind: 'Fragment',
-        version: VERSION$y,
+        version: VERSION$z,
         private: [],
         selections: [
             {
@@ -358,13 +358,13 @@ const select$16 = function ManagedContentVariantSnapshotSummaryRepresentationSel
         ]
     };
 };
-function equals$y(existing, incoming) {
+function equals$z(existing, incoming) {
     const existing_contentType = existing.contentType;
     const incoming_contentType = incoming.contentType;
     if (!(existing_contentType === incoming_contentType
         || (existing_contentType != null &&
             incoming_contentType != null &&
-            equals$z(existing_contentType, incoming_contentType)))) {
+            equals$A(existing_contentType, incoming_contentType)))) {
         return false;
     }
     const existing_id = existing.id;
@@ -395,8 +395,8 @@ function equals$y(existing, incoming) {
     return true;
 }
 
-const VERSION$x = "f99d45f1e809783023bfd9dbe2fe4a6c";
-function validate$10(obj, path = 'ManagedContentDeploymentItemRepresentation') {
+const VERSION$y = "f99d45f1e809783023bfd9dbe2fe4a6c";
+function validate$16(obj, path = 'ManagedContentDeploymentItemRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -423,7 +423,7 @@ function validate$10(obj, path = 'ManagedContentDeploymentItemRepresentation') {
         }
         const obj_mcvSnapshotSummary = obj.mcvSnapshotSummary;
         const path_mcvSnapshotSummary = path + '.mcvSnapshotSummary';
-        const referencepath_mcvSnapshotSummaryValidationError = validate$11(obj_mcvSnapshotSummary, path_mcvSnapshotSummary);
+        const referencepath_mcvSnapshotSummaryValidationError = validate$17(obj_mcvSnapshotSummary, path_mcvSnapshotSummary);
         if (referencepath_mcvSnapshotSummaryValidationError !== null) {
             let message = 'Object doesn\'t match ManagedContentVariantSnapshotSummaryRepresentation (at "' + path_mcvSnapshotSummary + '")\n';
             message += referencepath_mcvSnapshotSummaryValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -489,11 +489,11 @@ function validate$10(obj, path = 'ManagedContentDeploymentItemRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$15 = function ManagedContentDeploymentItemRepresentationSelect() {
-    const { selections: ManagedContentVariantSnapshotSummaryRepresentation__selections, opaque: ManagedContentVariantSnapshotSummaryRepresentation__opaque, } = select$16();
+const select$17 = function ManagedContentDeploymentItemRepresentationSelect() {
+    const { selections: ManagedContentVariantSnapshotSummaryRepresentation__selections, opaque: ManagedContentVariantSnapshotSummaryRepresentation__opaque, } = select$18();
     return {
         kind: 'Fragment',
-        version: VERSION$x,
+        version: VERSION$y,
         private: [],
         selections: [
             {
@@ -532,7 +532,7 @@ const select$15 = function ManagedContentDeploymentItemRepresentationSelect() {
         ]
     };
 };
-function equals$x(existing, incoming) {
+function equals$y(existing, incoming) {
     const existing_isTopLevel = existing.isTopLevel;
     const incoming_isTopLevel = incoming.isTopLevel;
     if (!(existing_isTopLevel === incoming_isTopLevel)) {
@@ -560,7 +560,7 @@ function equals$x(existing, incoming) {
     }
     const existing_mcvSnapshotSummary = existing.mcvSnapshotSummary;
     const incoming_mcvSnapshotSummary = incoming.mcvSnapshotSummary;
-    if (!(equals$y(existing_mcvSnapshotSummary, incoming_mcvSnapshotSummary))) {
+    if (!(equals$z(existing_mcvSnapshotSummary, incoming_mcvSnapshotSummary))) {
         return false;
     }
     const existing_targetId = existing.targetId;
@@ -576,8 +576,8 @@ function equals$x(existing, incoming) {
     return true;
 }
 
-const VERSION$w = "4b75ed6ff448da86412b605f7e775a62";
-function validate$$(obj, path = 'ManagedContentUserSummaryRepresentation') {
+const VERSION$x = "4b75ed6ff448da86412b605f7e775a62";
+function validate$15(obj, path = 'ManagedContentUserSummaryRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -602,10 +602,10 @@ function validate$$(obj, path = 'ManagedContentUserSummaryRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$14 = function ManagedContentUserSummaryRepresentationSelect() {
+const select$16 = function ManagedContentUserSummaryRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$w,
+        version: VERSION$x,
         private: [],
         selections: [
             {
@@ -624,7 +624,7 @@ const select$14 = function ManagedContentUserSummaryRepresentationSelect() {
         ]
     };
 };
-function equals$w(existing, incoming) {
+function equals$x(existing, incoming) {
     const existing_id = existing.id;
     const incoming_id = incoming.id;
     if (!(existing_id === incoming_id)) {
@@ -651,9 +651,9 @@ function equals$w(existing, incoming) {
     return true;
 }
 
-const TTL$r = 100;
-const VERSION$v = "f7e3c655efe77a7c9968ade15a6029b1";
-function validate$_(obj, path = 'ManagedContentDeploymentRepresentation') {
+const TTL$s = 100;
+const VERSION$w = "f7e3c655efe77a7c9968ade15a6029b1";
+function validate$14(obj, path = 'ManagedContentDeploymentRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -723,7 +723,7 @@ function validate$_(obj, path = 'ManagedContentDeploymentRepresentation') {
         for (let i = 0; i < obj_deploymentItems.length; i++) {
             const obj_deploymentItems_item = obj_deploymentItems[i];
             const path_deploymentItems_item = path_deploymentItems + '[' + i + ']';
-            const referencepath_deploymentItems_itemValidationError = validate$10(obj_deploymentItems_item, path_deploymentItems_item);
+            const referencepath_deploymentItems_itemValidationError = validate$16(obj_deploymentItems_item, path_deploymentItems_item);
             if (referencepath_deploymentItems_itemValidationError !== null) {
                 let message = 'Object doesn\'t match ManagedContentDeploymentItemRepresentation (at "' + path_deploymentItems_item + '")\n';
                 message += referencepath_deploymentItems_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -786,7 +786,7 @@ function validate$_(obj, path = 'ManagedContentDeploymentRepresentation') {
         const path_lastModifiedBy = path + '.lastModifiedBy';
         let obj_lastModifiedBy_union0 = null;
         const obj_lastModifiedBy_union0_error = (() => {
-            const referencepath_lastModifiedByValidationError = validate$$(obj_lastModifiedBy, path_lastModifiedBy);
+            const referencepath_lastModifiedByValidationError = validate$15(obj_lastModifiedBy, path_lastModifiedBy);
             if (referencepath_lastModifiedByValidationError !== null) {
                 let message = 'Object doesn\'t match ManagedContentUserSummaryRepresentation (at "' + path_lastModifiedBy + '")\n';
                 message += referencepath_lastModifiedByValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -840,25 +840,25 @@ function validate$_(obj, path = 'ManagedContentDeploymentRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$s = 'ManagedContentDeploymentRepresentation';
-function keyBuilder$U(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$s + ':' + config.id;
+const RepresentationType$t = 'ManagedContentDeploymentRepresentation';
+function keyBuilder$V(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$t + ':' + config.id;
 }
-function keyBuilderFromType$d(luvio, object) {
+function keyBuilderFromType$e(luvio, object) {
     const keyParams = {
         id: object.deploymentId
     };
-    return keyBuilder$U(luvio, keyParams);
+    return keyBuilder$V(luvio, keyParams);
 }
-function normalize$s(input, existing, path, luvio, store, timestamp) {
+function normalize$t(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$13 = function ManagedContentDeploymentRepresentationSelect() {
-    const { selections: ManagedContentDeploymentItemRepresentation__selections, opaque: ManagedContentDeploymentItemRepresentation__opaque, } = select$15();
-    const { selections: ManagedContentUserSummaryRepresentation__selections, opaque: ManagedContentUserSummaryRepresentation__opaque, } = select$14();
+const select$15 = function ManagedContentDeploymentRepresentationSelect() {
+    const { selections: ManagedContentDeploymentItemRepresentation__selections, opaque: ManagedContentDeploymentItemRepresentation__opaque, } = select$17();
+    const { selections: ManagedContentUserSummaryRepresentation__selections, opaque: ManagedContentUserSummaryRepresentation__opaque, } = select$16();
     return {
         kind: 'Fragment',
-        version: VERSION$v,
+        version: VERSION$w,
         private: [],
         selections: [
             {
@@ -900,7 +900,7 @@ const select$13 = function ManagedContentDeploymentRepresentationSelect() {
         ]
     };
 };
-function equals$v(existing, incoming) {
+function equals$w(existing, incoming) {
     const existing_deploymentId = existing.deploymentId;
     const incoming_deploymentId = incoming.deploymentId;
     if (!(existing_deploymentId === incoming_deploymentId)) {
@@ -919,7 +919,7 @@ function equals$v(existing, incoming) {
     const existing_deploymentItems = existing.deploymentItems;
     const incoming_deploymentItems = incoming.deploymentItems;
     const equals_deploymentItems_items = equalsArray(existing_deploymentItems, incoming_deploymentItems, (existing_deploymentItems_item, incoming_deploymentItems_item) => {
-        if (!(equals$x(existing_deploymentItems_item, incoming_deploymentItems_item))) {
+        if (!(equals$y(existing_deploymentItems_item, incoming_deploymentItems_item))) {
             return false;
         }
     });
@@ -941,7 +941,7 @@ function equals$v(existing, incoming) {
     if (!(existing_lastModifiedBy === incoming_lastModifiedBy
         || (existing_lastModifiedBy != null &&
             incoming_lastModifiedBy != null &&
-            equals$w(existing_lastModifiedBy, incoming_lastModifiedBy)))) {
+            equals$x(existing_lastModifiedBy, incoming_lastModifiedBy)))) {
         return false;
     }
     const existing_scheduledDate = existing.scheduledDate;
@@ -951,31 +951,31 @@ function equals$v(existing, incoming) {
     }
     return true;
 }
-const ingest$s = function ManagedContentDeploymentRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$t = function ManagedContentDeploymentRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$_(input);
+        const validateError = validate$14(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$d(luvio, input);
-    const ttlToUse = TTL$r;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$s, "CMSAuthoring", VERSION$v, RepresentationType$s, equals$v);
+    const key = keyBuilderFromType$e(luvio, input);
+    const ttlToUse = TTL$s;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$t, "CMSAuthoring", VERSION$w, RepresentationType$t, equals$w);
     return createLink(key);
 };
-function getTypeCacheKeys$s(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$t(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$d(luvio, input);
+    const rootKey = keyBuilderFromType$e(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$s,
+        representationName: RepresentationType$t,
         mergeable: false
     });
 }
 
-const TTL$q = 100;
-const VERSION$u = "b2c15aa80814ecd854e68bf635879e35";
-function validate$Z(obj, path = 'ManagedContentDeploymentCollectionRepresentation') {
+const TTL$r = 100;
+const VERSION$v = "b2c15aa80814ecd854e68bf635879e35";
+function validate$13(obj, path = 'ManagedContentDeploymentCollectionRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1052,14 +1052,14 @@ function validate$Z(obj, path = 'ManagedContentDeploymentCollectionRepresentatio
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$r = 'ManagedContentDeploymentCollectionRepresentation';
-function normalize$r(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$s = 'ManagedContentDeploymentCollectionRepresentation';
+function normalize$s(input, existing, path, luvio, store, timestamp) {
     const input_deployments = input.deployments;
     const input_deployments_id = path.fullPath + '__deployments';
     for (let i = 0; i < input_deployments.length; i++) {
         const input_deployments_item = input_deployments[i];
         let input_deployments_item_id = input_deployments_id + '__' + i;
-        input_deployments[i] = ingest$s(input_deployments_item, {
+        input_deployments[i] = ingest$t(input_deployments_item, {
             fullPath: input_deployments_item_id,
             propertyName: i,
             parent: {
@@ -1072,10 +1072,10 @@ function normalize$r(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$12 = function ManagedContentDeploymentCollectionRepresentationSelect() {
+const select$14 = function ManagedContentDeploymentCollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$u,
+        version: VERSION$v,
         private: [],
         selections: [
             {
@@ -1086,7 +1086,7 @@ const select$12 = function ManagedContentDeploymentCollectionRepresentationSelec
                 name: 'deployments',
                 kind: 'Link',
                 plural: true,
-                fragment: select$13()
+                fragment: select$15()
             },
             {
                 name: 'nextPageUrl',
@@ -1099,7 +1099,7 @@ const select$12 = function ManagedContentDeploymentCollectionRepresentationSelec
         ]
     };
 };
-function equals$u(existing, incoming) {
+function equals$v(existing, incoming) {
     const existing_currentPageUrl = existing.currentPageUrl;
     const incoming_currentPageUrl = incoming.currentPageUrl;
     if (!(existing_currentPageUrl === incoming_currentPageUrl)) {
@@ -1127,48 +1127,48 @@ function equals$u(existing, incoming) {
     }
     return true;
 }
-const ingest$r = function ManagedContentDeploymentCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$s = function ManagedContentDeploymentCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$Z(input);
+        const validateError = validate$13(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = path.fullPath;
-    const ttlToUse = TTL$q;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$r, "CMSAuthoring", VERSION$u, RepresentationType$r, equals$u);
+    const ttlToUse = TTL$r;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$s, "CMSAuthoring", VERSION$v, RepresentationType$s, equals$v);
     return createLink(key);
 };
-function getTypeCacheKeys$r(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$s(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$r,
+        representationName: RepresentationType$s,
         mergeable: false
     });
     const input_deployments_length = input.deployments.length;
     for (let i = 0; i < input_deployments_length; i++) {
-        getTypeCacheKeys$s(rootKeySet, luvio, input.deployments[i]);
+        getTypeCacheKeys$t(rootKeySet, luvio, input.deployments[i]);
     }
 }
 
-function select$11(luvio, params) {
-    return select$12();
+function select$13(luvio, params) {
+    return select$14();
 }
-function keyBuilder$T(luvio, params) {
+function keyBuilder$U(luvio, params) {
     return keyPrefix + '::ManagedContentDeploymentCollectionRepresentation:(' + 'contentSpaceId:' + params.queryParams.contentSpaceId + ',' + 'deploymentId:' + params.queryParams.deploymentId + ',' + 'deploymentStatus:' + params.queryParams.deploymentStatus + ',' + 'deploymentType:' + params.queryParams.deploymentType + ',' + 'managedContentVersionId:' + params.queryParams.managedContentVersionId + ',' + 'page:' + params.queryParams.page + ',' + 'pageSize:' + params.queryParams.pageSize + ',' + 'variantIds:' + params.queryParams.variantIds + ')';
 }
-function getResponseCacheKeys$A(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$r(storeKeyMap, luvio, response, () => keyBuilder$T(luvio, resourceParams));
+function getResponseCacheKeys$B(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$s(storeKeyMap, luvio, response, () => keyBuilder$U(luvio, resourceParams));
 }
-function ingestSuccess$A(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$B(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$T(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$r, body);
+    const key = keyBuilder$U(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$s, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$11(),
+        node: select$13(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -1180,18 +1180,18 @@ function ingestSuccess$A(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$k(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$T(luvio, params);
+    const key = keyBuilder$U(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$q,
+        ttl: TTL$r,
         namespace: keyPrefix,
-        version: VERSION$u,
-        representationName: RepresentationType$r
+        version: VERSION$v,
+        representationName: RepresentationType$s
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$A(config) {
+function createResourceRequest$B(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -1205,7 +1205,7 @@ function createResourceRequest$A(config) {
     };
 }
 
-const adapterName$A = 'getDeployments';
+const adapterName$B = 'getDeployments';
 const oneOfConfigPropertiesIdentifier = [
     'deploymentId',
     'contentSpaceId',
@@ -1222,25 +1222,25 @@ const getDeployments_ConfigPropertyMetadata = [
     generateParamConfigMetadata('pageSize', false, 1 /* QueryParameter */, 3 /* Integer */),
     generateParamConfigMetadata('variantIds', false, 1 /* QueryParameter */, 0 /* String */, true),
 ];
-const getDeployments_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$A, getDeployments_ConfigPropertyMetadata);
-const createResourceParams$A = /*#__PURE__*/ createResourceParams$B(getDeployments_ConfigPropertyMetadata);
-function keyBuilder$S(luvio, config) {
-    const resourceParams = createResourceParams$A(config);
-    return keyBuilder$T(luvio, resourceParams);
+const getDeployments_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$B, getDeployments_ConfigPropertyMetadata);
+const createResourceParams$B = /*#__PURE__*/ createResourceParams$C(getDeployments_ConfigPropertyMetadata);
+function keyBuilder$T(luvio, config) {
+    const resourceParams = createResourceParams$B(config);
+    return keyBuilder$U(luvio, resourceParams);
 }
-function typeCheckConfig$A(untrustedConfig) {
+function typeCheckConfig$B(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getDeployments_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, getDeployments_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$A(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$B(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames, oneOfConfigPropertiesIdentifier);
     }
-    const config = typeCheckConfig$A(untrustedConfig);
+    const config = typeCheckConfig$B(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
@@ -1253,31 +1253,31 @@ function validateAdapterConfig$A(untrustedConfig, configPropertyNames) {
     return config;
 }
 function adapterFragment$k(luvio, config) {
-    createResourceParams$A(config);
-    return select$11();
+    createResourceParams$B(config);
+    return select$13();
 }
 function onFetchResponseSuccess$m(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$A(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$B(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$A(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$B(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$k(luvio, config, resourceParams, response) {
     const snapshot = ingestError$k(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$A(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$B(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$A(luvio, config, options) {
-    const resourceParams = createResourceParams$A(config);
-    const request = createResourceRequest$A(resourceParams);
+function buildNetworkSnapshot$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$m(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$A(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$B(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -1285,23 +1285,23 @@ function buildNetworkSnapshot$A(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$k(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$l(context, coercedAdapterRequestContext, buildNetworkSnapshot$A, undefined, false);
+    return buildNetworkSnapshotCachePolicy$l(context, coercedAdapterRequestContext, buildNetworkSnapshot$B, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$k(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$S(luvio, config),
+        recordId: keyBuilder$T(luvio, config),
         node: adapterFragment$k(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$A(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$B(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getDeploymentsAdapterFactory = (luvio) => function CMSAuthoring__getDeployments(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$A(untrustedConfig, getDeployments_ConfigPropertyNames);
+    const config = validateAdapterConfig$B(untrustedConfig, getDeployments_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -1310,7 +1310,7 @@ const getDeploymentsAdapterFactory = (luvio) => function CMSAuthoring__getDeploy
     buildCachedSnapshotCachePolicy$k, buildNetworkSnapshotCachePolicy$k);
 };
 
-function validate$Y(obj, path = 'ManagedContentDeploymentInputRepresentation') {
+function validate$12(obj, path = 'ManagedContentDeploymentInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1394,19 +1394,19 @@ function validate$Y(obj, path = 'ManagedContentDeploymentInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function select$10(luvio, params) {
-    return select$13();
+function select$12(luvio, params) {
+    return select$15();
 }
-function getResponseCacheKeys$z(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$s(storeKeyMap, luvio, response);
+function getResponseCacheKeys$A(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$t(storeKeyMap, luvio, response);
 }
-function ingestSuccess$z(luvio, resourceParams, response) {
+function ingestSuccess$A(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$d(luvio, body);
-    luvio.storeIngest(key, ingest$s, body);
+    const key = keyBuilderFromType$e(luvio, body);
+    luvio.storeIngest(key, ingest$t, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$10(),
+        node: select$12(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -1417,7 +1417,7 @@ function ingestSuccess$z(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$z(config) {
+function createResourceRequest$A(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -1431,45 +1431,45 @@ function createResourceRequest$z(config) {
     };
 }
 
-const adapterName$z = 'createDeployment';
+const adapterName$A = 'createDeployment';
 const createDeployment_ConfigPropertyMetadata = [
     generateParamConfigMetadata('DeploymentInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const createDeployment_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$z, createDeployment_ConfigPropertyMetadata);
-const createResourceParams$z = /*#__PURE__*/ createResourceParams$B(createDeployment_ConfigPropertyMetadata);
-function typeCheckConfig$z(untrustedConfig) {
+const createDeployment_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$A, createDeployment_ConfigPropertyMetadata);
+const createResourceParams$A = /*#__PURE__*/ createResourceParams$C(createDeployment_ConfigPropertyMetadata);
+function typeCheckConfig$A(untrustedConfig) {
     const config = {};
     const untrustedConfig_DeploymentInput = untrustedConfig.DeploymentInput;
-    const referenceManagedContentDeploymentInputRepresentationValidationError = validate$Y(untrustedConfig_DeploymentInput);
+    const referenceManagedContentDeploymentInputRepresentationValidationError = validate$12(untrustedConfig_DeploymentInput);
     if (referenceManagedContentDeploymentInputRepresentationValidationError === null) {
         config.DeploymentInput = untrustedConfig_DeploymentInput;
     }
     return config;
 }
-function validateAdapterConfig$z(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$A(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$z(untrustedConfig);
+    const config = typeCheckConfig$A(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$z(luvio, config, options) {
-    const resourceParams = createResourceParams$z(config);
-    const request = createResourceRequest$z(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(() => {
-            const snapshot = ingestSuccess$z(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$A(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$z(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$A(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -1479,17 +1479,17 @@ function buildNetworkSnapshot$z(luvio, config, options) {
 }
 const createDeploymentAdapterFactory = (luvio) => {
     return function createDeployment(untrustedConfig) {
-        const config = validateAdapterConfig$z(untrustedConfig, createDeployment_ConfigPropertyNames);
+        const config = validateAdapterConfig$A(untrustedConfig, createDeployment_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createDeployment"');
         }
-        return buildNetworkSnapshot$z(luvio, config);
+        return buildNetworkSnapshot$A(luvio, config);
     };
 };
 
-const VERSION$t = "7e57fd77c4503be9a8822f2603a04df3";
-function validate$X(obj, path = 'ManagedContentJobBodyRepresentation') {
+const VERSION$u = "7e57fd77c4503be9a8822f2603a04df3";
+function validate$11(obj, path = 'ManagedContentJobBodyRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1517,10 +1517,10 @@ function validate$X(obj, path = 'ManagedContentJobBodyRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$$ = function ManagedContentJobBodyRepresentationSelect() {
+const select$11 = function ManagedContentJobBodyRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$t,
+        version: VERSION$u,
         private: [],
         selections: [
             {
@@ -1542,7 +1542,7 @@ const select$$ = function ManagedContentJobBodyRepresentationSelect() {
         ]
     };
 };
-function equals$t(existing, incoming) {
+function equals$u(existing, incoming) {
     const existing_bodyType = existing.bodyType;
     const incoming_bodyType = incoming.bodyType;
     if (!(existing_bodyType === incoming_bodyType)) {
@@ -1566,8 +1566,8 @@ function equals$t(existing, incoming) {
     return true;
 }
 
-const VERSION$s = "eba1876bba76cb05d9cbb8a968bd6796";
-function validate$W(obj, path = 'ManagedContentJobBodyCollectionRepresentation') {
+const VERSION$t = "eba1876bba76cb05d9cbb8a968bd6796";
+function validate$10(obj, path = 'ManagedContentJobBodyCollectionRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1580,7 +1580,7 @@ function validate$W(obj, path = 'ManagedContentJobBodyCollectionRepresentation')
         for (let i = 0; i < obj_jobBodies.length; i++) {
             const obj_jobBodies_item = obj_jobBodies[i];
             const path_jobBodies_item = path_jobBodies + '[' + i + ']';
-            const referencepath_jobBodies_itemValidationError = validate$X(obj_jobBodies_item, path_jobBodies_item);
+            const referencepath_jobBodies_itemValidationError = validate$11(obj_jobBodies_item, path_jobBodies_item);
             if (referencepath_jobBodies_itemValidationError !== null) {
                 let message = 'Object doesn\'t match ManagedContentJobBodyRepresentation (at "' + path_jobBodies_item + '")\n';
                 message += referencepath_jobBodies_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -1590,11 +1590,11 @@ function validate$W(obj, path = 'ManagedContentJobBodyCollectionRepresentation')
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$_ = function ManagedContentJobBodyCollectionRepresentationSelect() {
-    const { selections: ManagedContentJobBodyRepresentation__selections, opaque: ManagedContentJobBodyRepresentation__opaque, } = select$$();
+const select$10 = function ManagedContentJobBodyCollectionRepresentationSelect() {
+    const { selections: ManagedContentJobBodyRepresentation__selections, opaque: ManagedContentJobBodyRepresentation__opaque, } = select$11();
     return {
         kind: 'Fragment',
-        version: VERSION$s,
+        version: VERSION$t,
         private: [],
         selections: [
             {
@@ -1606,11 +1606,11 @@ const select$_ = function ManagedContentJobBodyCollectionRepresentationSelect()
         ]
     };
 };
-function equals$s(existing, incoming) {
+function equals$t(existing, incoming) {
     const existing_jobBodies = existing.jobBodies;
     const incoming_jobBodies = incoming.jobBodies;
     const equals_jobBodies_items = equalsArray(existing_jobBodies, incoming_jobBodies, (existing_jobBodies_item, incoming_jobBodies_item) => {
-        if (!(equals$t(existing_jobBodies_item, incoming_jobBodies_item))) {
+        if (!(equals$u(existing_jobBodies_item, incoming_jobBodies_item))) {
             return false;
         }
     });
@@ -1620,9 +1620,9 @@ function equals$s(existing, incoming) {
     return true;
 }
 
-const TTL$p = 100;
-const VERSION$r = "9c2de7843d4d4e7784d56c7f83c58f0e";
-function validate$V(obj, path = 'ManagedContentV2JobDetailRepresentation') {
+const TTL$q = 100;
+const VERSION$s = "9c2de7843d4d4e7784d56c7f83c58f0e";
+function validate$$(obj, path = 'ManagedContentV2JobDetailRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1631,7 +1631,7 @@ function validate$V(obj, path = 'ManagedContentV2JobDetailRepresentation') {
         const path_body = path + '.body';
         let obj_body_union0 = null;
         const obj_body_union0_error = (() => {
-            const referencepath_bodyValidationError = validate$W(obj_body, path_body);
+            const referencepath_bodyValidationError = validate$10(obj_body, path_body);
             if (referencepath_bodyValidationError !== null) {
                 let message = 'Object doesn\'t match ManagedContentJobBodyCollectionRepresentation (at "' + path_body + '")\n';
                 message += referencepath_bodyValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -1725,24 +1725,24 @@ function validate$V(obj, path = 'ManagedContentV2JobDetailRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$q = 'ManagedContentV2JobDetailRepresentation';
-function keyBuilder$R(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$q + ':' + config.id;
+const RepresentationType$r = 'ManagedContentV2JobDetailRepresentation';
+function keyBuilder$S(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$r + ':' + config.id;
 }
-function keyBuilderFromType$c(luvio, object) {
+function keyBuilderFromType$d(luvio, object) {
     const keyParams = {
         id: object.id
     };
-    return keyBuilder$R(luvio, keyParams);
+    return keyBuilder$S(luvio, keyParams);
 }
-function normalize$q(input, existing, path, luvio, store, timestamp) {
+function normalize$r(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$Z = function ManagedContentV2JobDetailRepresentationSelect() {
-    const { selections: ManagedContentJobBodyCollectionRepresentation__selections, opaque: ManagedContentJobBodyCollectionRepresentation__opaque, } = select$_();
+const select$$ = function ManagedContentV2JobDetailRepresentationSelect() {
+    const { selections: ManagedContentJobBodyCollectionRepresentation__selections, opaque: ManagedContentJobBodyCollectionRepresentation__opaque, } = select$10();
     return {
         kind: 'Fragment',
-        version: VERSION$r,
+        version: VERSION$s,
         private: [],
         selections: [
             {
@@ -1790,7 +1790,7 @@ const select$Z = function ManagedContentV2JobDetailRepresentationSelect() {
         ]
     };
 };
-function equals$r(existing, incoming) {
+function equals$s(existing, incoming) {
     const existing_createdById = existing.createdById;
     const incoming_createdById = incoming.createdById;
     if (!(existing_createdById === incoming_createdById)) {
@@ -1836,7 +1836,7 @@ function equals$r(existing, incoming) {
     if (!(existing_body === incoming_body
         || (existing_body != null &&
             incoming_body != null &&
-            equals$s(existing_body, incoming_body)))) {
+            equals$t(existing_body, incoming_body)))) {
         return false;
     }
     const existing_createdDate = existing.createdDate;
@@ -1846,31 +1846,31 @@ function equals$r(existing, incoming) {
     }
     return true;
 }
-const ingest$q = function ManagedContentV2JobDetailRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$r = function ManagedContentV2JobDetailRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$V(input);
+        const validateError = validate$$(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$c(luvio, input);
-    const ttlToUse = TTL$p;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$q, "CMSAuthoring", VERSION$r, RepresentationType$q, equals$r);
+    const key = keyBuilderFromType$d(luvio, input);
+    const ttlToUse = TTL$q;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$r, "CMSAuthoring", VERSION$s, RepresentationType$r, equals$s);
     return createLink(key);
 };
-function getTypeCacheKeys$q(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$r(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$c(luvio, input);
+    const rootKey = keyBuilderFromType$d(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$q,
+        representationName: RepresentationType$r,
         mergeable: false
     });
 }
 
-const TTL$o = 100;
-const VERSION$q = "75cfd71e168144693d36fa16f7d8f4d0";
-function validate$U(obj, path = 'ManagedContentJobCollectionRepresentation') {
+const TTL$p = 100;
+const VERSION$r = "75cfd71e168144693d36fa16f7d8f4d0";
+function validate$_(obj, path = 'ManagedContentJobCollectionRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1947,14 +1947,14 @@ function validate$U(obj, path = 'ManagedContentJobCollectionRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$p = 'ManagedContentJobCollectionRepresentation';
-function normalize$p(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$q = 'ManagedContentJobCollectionRepresentation';
+function normalize$q(input, existing, path, luvio, store, timestamp) {
     const input_jobs = input.jobs;
     const input_jobs_id = path.fullPath + '__jobs';
     for (let i = 0; i < input_jobs.length; i++) {
         const input_jobs_item = input_jobs[i];
         let input_jobs_item_id = input_jobs_id + '__' + i;
-        input_jobs[i] = ingest$q(input_jobs_item, {
+        input_jobs[i] = ingest$r(input_jobs_item, {
             fullPath: input_jobs_item_id,
             propertyName: i,
             parent: {
@@ -1967,10 +1967,10 @@ function normalize$p(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$Y = function ManagedContentJobCollectionRepresentationSelect() {
+const select$_ = function ManagedContentJobCollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$q,
+        version: VERSION$r,
         private: [],
         selections: [
             {
@@ -1981,7 +1981,7 @@ const select$Y = function ManagedContentJobCollectionRepresentationSelect() {
                 name: 'jobs',
                 kind: 'Link',
                 plural: true,
-                fragment: select$Z()
+                fragment: select$$()
             },
             {
                 name: 'nextPageUrl',
@@ -1994,7 +1994,7 @@ const select$Y = function ManagedContentJobCollectionRepresentationSelect() {
         ]
     };
 };
-function equals$q(existing, incoming) {
+function equals$r(existing, incoming) {
     const existing_currentPageUrl = existing.currentPageUrl;
     const incoming_currentPageUrl = incoming.currentPageUrl;
     if (!(existing_currentPageUrl === incoming_currentPageUrl)) {
@@ -2022,48 +2022,48 @@ function equals$q(existing, incoming) {
     }
     return true;
 }
-const ingest$p = function ManagedContentJobCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$q = function ManagedContentJobCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$U(input);
+        const validateError = validate$_(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = path.fullPath;
-    const ttlToUse = TTL$o;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$p, "CMSAuthoring", VERSION$q, RepresentationType$p, equals$q);
+    const ttlToUse = TTL$p;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$q, "CMSAuthoring", VERSION$r, RepresentationType$q, equals$r);
     return createLink(key);
 };
-function getTypeCacheKeys$p(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$q(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$p,
+        representationName: RepresentationType$q,
         mergeable: false
     });
     const input_jobs_length = input.jobs.length;
     for (let i = 0; i < input_jobs_length; i++) {
-        getTypeCacheKeys$q(rootKeySet, luvio, input.jobs[i]);
+        getTypeCacheKeys$r(rootKeySet, luvio, input.jobs[i]);
     }
 }
 
-function select$X(luvio, params) {
-    return select$Y();
+function select$Z(luvio, params) {
+    return select$_();
 }
-function keyBuilder$Q(luvio, params) {
+function keyBuilder$R(luvio, params) {
     return keyPrefix + '::ManagedContentJobCollectionRepresentation:(' + 'jobType:' + params.queryParams.jobType + ',' + 'page:' + params.queryParams.page + ',' + 'pageSize:' + params.queryParams.pageSize + ',' + 'contentSpaceId:' + params.urlParams.contentSpaceId + ')';
 }
-function getResponseCacheKeys$y(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$p(storeKeyMap, luvio, response, () => keyBuilder$Q(luvio, resourceParams));
+function getResponseCacheKeys$z(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$q(storeKeyMap, luvio, response, () => keyBuilder$R(luvio, resourceParams));
 }
-function ingestSuccess$y(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$z(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$Q(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$p, body);
+    const key = keyBuilder$R(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$q, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$X(),
+        node: select$Z(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -2075,18 +2075,18 @@ function ingestSuccess$y(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$j(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$Q(luvio, params);
+    const key = keyBuilder$R(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$o,
+        ttl: TTL$p,
         namespace: keyPrefix,
-        version: VERSION$q,
-        representationName: RepresentationType$p
+        version: VERSION$r,
+        representationName: RepresentationType$q
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$y(config) {
+function createResourceRequest$z(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -2100,63 +2100,63 @@ function createResourceRequest$y(config) {
     };
 }
 
-const adapterName$y = 'getAllCMSJobsForSpace';
+const adapterName$z = 'getAllCMSJobsForSpace';
 const getAllCMSJobsForSpace_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contentSpaceId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('jobType', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('page', false, 1 /* QueryParameter */, 3 /* Integer */),
     generateParamConfigMetadata('pageSize', false, 1 /* QueryParameter */, 3 /* Integer */),
 ];
-const getAllCMSJobsForSpace_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$y, getAllCMSJobsForSpace_ConfigPropertyMetadata);
-const createResourceParams$y = /*#__PURE__*/ createResourceParams$B(getAllCMSJobsForSpace_ConfigPropertyMetadata);
-function keyBuilder$P(luvio, config) {
-    const resourceParams = createResourceParams$y(config);
-    return keyBuilder$Q(luvio, resourceParams);
+const getAllCMSJobsForSpace_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$z, getAllCMSJobsForSpace_ConfigPropertyMetadata);
+const createResourceParams$z = /*#__PURE__*/ createResourceParams$C(getAllCMSJobsForSpace_ConfigPropertyMetadata);
+function keyBuilder$Q(luvio, config) {
+    const resourceParams = createResourceParams$z(config);
+    return keyBuilder$R(luvio, resourceParams);
 }
-function typeCheckConfig$y(untrustedConfig) {
+function typeCheckConfig$z(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getAllCMSJobsForSpace_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, getAllCMSJobsForSpace_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$y(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$z(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$y(untrustedConfig);
+    const config = typeCheckConfig$z(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$j(luvio, config) {
-    createResourceParams$y(config);
-    return select$X();
+    createResourceParams$z(config);
+    return select$Z();
 }
 function onFetchResponseSuccess$l(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$y(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$z(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$y(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$z(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$j(luvio, config, resourceParams, response) {
     const snapshot = ingestError$j(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$y(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$z(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$y(luvio, config, options) {
-    const resourceParams = createResourceParams$y(config);
-    const request = createResourceRequest$y(resourceParams);
+function buildNetworkSnapshot$z(luvio, config, options) {
+    const resourceParams = createResourceParams$z(config);
+    const request = createResourceRequest$z(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess$l(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$y(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$z(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -2164,23 +2164,23 @@ function buildNetworkSnapshot$y(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$j(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$l(context, coercedAdapterRequestContext, buildNetworkSnapshot$y, undefined, false);
+    return buildNetworkSnapshotCachePolicy$l(context, coercedAdapterRequestContext, buildNetworkSnapshot$z, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$j(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$P(luvio, config),
+        recordId: keyBuilder$Q(luvio, config),
         node: adapterFragment$j(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$y(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$z(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getAllCMSJobsForSpaceAdapterFactory = (luvio) => function CMSAuthoring__getAllCMSJobsForSpace(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$y(untrustedConfig, getAllCMSJobsForSpace_ConfigPropertyNames);
+    const config = validateAdapterConfig$z(untrustedConfig, getAllCMSJobsForSpace_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -2189,24 +2189,24 @@ const getAllCMSJobsForSpaceAdapterFactory = (luvio) => function CMSAuthoring__ge
     buildCachedSnapshotCachePolicy$j, buildNetworkSnapshotCachePolicy$j);
 };
 
-function select$W(luvio, params) {
-    return select$Z();
+function select$Y(luvio, params) {
+    return select$$();
 }
-function keyBuilder$O(luvio, params) {
-    return keyBuilder$R(luvio, {
+function keyBuilder$P(luvio, params) {
+    return keyBuilder$S(luvio, {
         id: params.urlParams.jobId
     });
 }
-function getResponseCacheKeys$x(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$q(storeKeyMap, luvio, response);
+function getResponseCacheKeys$y(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$r(storeKeyMap, luvio, response);
 }
-function ingestSuccess$x(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$y(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$O(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$q, body);
+    const key = keyBuilder$P(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$r, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$W(),
+        node: select$Y(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -2218,18 +2218,18 @@ function ingestSuccess$x(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$i(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$O(luvio, params);
+    const key = keyBuilder$P(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$p,
+        ttl: TTL$q,
         namespace: keyPrefix,
-        version: VERSION$r,
-        representationName: RepresentationType$q
+        version: VERSION$s,
+        representationName: RepresentationType$r
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$x(config) {
+function createResourceRequest$y(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -2243,61 +2243,61 @@ function createResourceRequest$x(config) {
     };
 }
 
-const adapterName$x = 'getCMSJobForSpace';
+const adapterName$y = 'getCMSJobForSpace';
 const getCMSJobForSpace_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contentSpaceId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('jobId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getCMSJobForSpace_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$x, getCMSJobForSpace_ConfigPropertyMetadata);
-const createResourceParams$x = /*#__PURE__*/ createResourceParams$B(getCMSJobForSpace_ConfigPropertyMetadata);
-function keyBuilder$N(luvio, config) {
-    const resourceParams = createResourceParams$x(config);
-    return keyBuilder$O(luvio, resourceParams);
+const getCMSJobForSpace_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$y, getCMSJobForSpace_ConfigPropertyMetadata);
+const createResourceParams$y = /*#__PURE__*/ createResourceParams$C(getCMSJobForSpace_ConfigPropertyMetadata);
+function keyBuilder$O(luvio, config) {
+    const resourceParams = createResourceParams$y(config);
+    return keyBuilder$P(luvio, resourceParams);
 }
-function typeCheckConfig$x(untrustedConfig) {
+function typeCheckConfig$y(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getCMSJobForSpace_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, getCMSJobForSpace_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$x(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$y(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$x(untrustedConfig);
+    const config = typeCheckConfig$y(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$i(luvio, config) {
-    createResourceParams$x(config);
-    return select$W();
+    createResourceParams$y(config);
+    return select$Y();
 }
 function onFetchResponseSuccess$k(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$x(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$y(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$x(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$y(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$i(luvio, config, resourceParams, response) {
     const snapshot = ingestError$i(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$x(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$y(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$x(luvio, config, options) {
-    const resourceParams = createResourceParams$x(config);
-    const request = createResourceRequest$x(resourceParams);
+function buildNetworkSnapshot$y(luvio, config, options) {
+    const resourceParams = createResourceParams$y(config);
+    const request = createResourceRequest$y(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess$k(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$x(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$y(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -2305,23 +2305,23 @@ function buildNetworkSnapshot$x(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$l(context, coercedAdapterRequestContext, buildNetworkSnapshot$x, undefined, false);
+    return buildNetworkSnapshotCachePolicy$l(context, coercedAdapterRequestContext, buildNetworkSnapshot$y, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$i(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$N(luvio, config),
+        recordId: keyBuilder$O(luvio, config),
         node: adapterFragment$i(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$x(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$y(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getCMSJobForSpaceAdapterFactory = (luvio) => function CMSAuthoring__getCMSJobForSpace(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$x(untrustedConfig, getCMSJobForSpace_ConfigPropertyNames);
+    const config = validateAdapterConfig$y(untrustedConfig, getCMSJobForSpace_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -2330,7 +2330,7 @@ const getCMSJobForSpaceAdapterFactory = (luvio) => function CMSAuthoring__getCMS
     buildCachedSnapshotCachePolicy$i, buildNetworkSnapshotCachePolicy$i);
 };
 
-function validate$T(obj, path = 'ManagedContentSpaceFolderItemV1Representation') {
+function validate$Z(obj, path = 'ManagedContentSpaceFolderItemV1Representation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -2418,9 +2418,9 @@ function validate$T(obj, path = 'ManagedContentSpaceFolderItemV1Representation')
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$n = 100;
-const VERSION$p = "df1370994ae2e57cdebc5f5125930e2d";
-function validate$S(obj, path = 'ManagedContentSpaceFolderItemV1CollectionRepresentation') {
+const TTL$o = 100;
+const VERSION$q = "df1370994ae2e57cdebc5f5125930e2d";
+function validate$Y(obj, path = 'ManagedContentSpaceFolderItemV1CollectionRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -2438,7 +2438,7 @@ function validate$S(obj, path = 'ManagedContentSpaceFolderItemV1CollectionRepres
         for (let i = 0; i < obj_folderItems.length; i++) {
             const obj_folderItems_item = obj_folderItems[i];
             const path_folderItems_item = path_folderItems + '[' + i + ']';
-            const referencepath_folderItems_itemValidationError = validate$T(obj_folderItems_item, path_folderItems_item);
+            const referencepath_folderItems_itemValidationError = validate$Z(obj_folderItems_item, path_folderItems_item);
             if (referencepath_folderItems_itemValidationError !== null) {
                 let message = 'Object doesn\'t match ManagedContentSpaceFolderItemV1Representation (at "' + path_folderItems_item + '")\n';
                 message += referencepath_folderItems_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -2474,62 +2474,62 @@ function validate$S(obj, path = 'ManagedContentSpaceFolderItemV1CollectionRepres
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$o = 'ManagedContentSpaceFolderItemV1CollectionRepresentation';
-function normalize$o(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$p = 'ManagedContentSpaceFolderItemV1CollectionRepresentation';
+function normalize$p(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$V = function ManagedContentSpaceFolderItemV1CollectionRepresentationSelect() {
+const select$X = function ManagedContentSpaceFolderItemV1CollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$p,
+        version: VERSION$q,
         private: [],
         opaque: true
     };
 };
-function equals$p(existing, incoming) {
+function equals$q(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$o = function ManagedContentSpaceFolderItemV1CollectionRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$p = function ManagedContentSpaceFolderItemV1CollectionRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$S(input);
+        const validateError = validate$Y(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = path.fullPath;
-    const ttlToUse = TTL$n;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$o, "CMSAuthoring", VERSION$p, RepresentationType$o, equals$p);
+    const ttlToUse = TTL$o;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$p, "CMSAuthoring", VERSION$q, RepresentationType$p, equals$q);
     return createLink(key);
 };
-function getTypeCacheKeys$o(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$p(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$o,
+        representationName: RepresentationType$p,
         mergeable: false
     });
 }
 
-function select$U(luvio, params) {
-    return select$V();
+function select$W(luvio, params) {
+    return select$X();
 }
-function keyBuilder$M(luvio, params) {
+function keyBuilder$N(luvio, params) {
     return keyPrefix + '::ManagedContentSpaceFolderItemV1CollectionRepresentation:(' + 'contentTypeFilter:' + params.queryParams.contentTypeFilter + ',' + 'contentTypes:' + params.queryParams.contentTypes + ',' + 'filter:' + params.queryParams.filter + ',' + 'managedContentType:' + params.queryParams.managedContentType + ',' + '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$w(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$o(storeKeyMap, luvio, response, () => keyBuilder$M(luvio, resourceParams));
+function getResponseCacheKeys$x(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$p(storeKeyMap, luvio, response, () => keyBuilder$N(luvio, resourceParams));
 }
-function ingestSuccess$w(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$x(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$M(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$o, body);
+    const key = keyBuilder$N(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$p, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$U(),
+        node: select$W(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -2541,18 +2541,18 @@ function ingestSuccess$w(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$h(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$M(luvio, params);
+    const key = keyBuilder$N(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$n,
+        ttl: TTL$o,
         namespace: keyPrefix,
-        version: VERSION$p,
-        representationName: RepresentationType$o
+        version: VERSION$q,
+        representationName: RepresentationType$p
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$w(config) {
+function createResourceRequest$x(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -2566,7 +2566,7 @@ function createResourceRequest$w(config) {
     };
 }
 
-const adapterName$w = 'getManagedContentSpaceFolderItemsV1';
+const adapterName$x = 'getManagedContentSpaceFolderItemsV1';
 const getManagedContentSpaceFolderItemsV1_ConfigPropertyMetadata = [
     generateParamConfigMetadata('folderId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('contentTypeFilter', false, 1 /* QueryParameter */, 0 /* String */),
@@ -2580,56 +2580,56 @@ const getManagedContentSpaceFolderItemsV1_ConfigPropertyMetadata = [
     generateParamConfigMetadata('sortBy', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('sortOrder', false, 1 /* QueryParameter */, 0 /* String */),
 ];
-const getManagedContentSpaceFolderItemsV1_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$w, getManagedContentSpaceFolderItemsV1_ConfigPropertyMetadata);
-const createResourceParams$w = /*#__PURE__*/ createResourceParams$B(getManagedContentSpaceFolderItemsV1_ConfigPropertyMetadata);
-function keyBuilder$L(luvio, config) {
-    const resourceParams = createResourceParams$w(config);
-    return keyBuilder$M(luvio, resourceParams);
+const getManagedContentSpaceFolderItemsV1_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$x, getManagedContentSpaceFolderItemsV1_ConfigPropertyMetadata);
+const createResourceParams$x = /*#__PURE__*/ createResourceParams$C(getManagedContentSpaceFolderItemsV1_ConfigPropertyMetadata);
+function keyBuilder$M(luvio, config) {
+    const resourceParams = createResourceParams$x(config);
+    return keyBuilder$N(luvio, resourceParams);
 }
-function typeCheckConfig$w(untrustedConfig) {
+function typeCheckConfig$x(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getManagedContentSpaceFolderItemsV1_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, getManagedContentSpaceFolderItemsV1_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$w(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$x(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$w(untrustedConfig);
+    const config = typeCheckConfig$x(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$h(luvio, config) {
-    createResourceParams$w(config);
-    return select$U();
+    createResourceParams$x(config);
+    return select$W();
 }
 function onFetchResponseSuccess$j(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$w(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$x(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$w(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$x(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$h(luvio, config, resourceParams, response) {
     const snapshot = ingestError$h(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$w(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$x(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$w(luvio, config, options) {
-    const resourceParams = createResourceParams$w(config);
-    const request = createResourceRequest$w(resourceParams);
+function buildNetworkSnapshot$x(luvio, config, options) {
+    const resourceParams = createResourceParams$x(config);
+    const request = createResourceRequest$x(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess$j(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$w(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$x(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -2637,23 +2637,23 @@ function buildNetworkSnapshot$w(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$l(context, coercedAdapterRequestContext, buildNetworkSnapshot$w, undefined, false);
+    return buildNetworkSnapshotCachePolicy$l(context, coercedAdapterRequestContext, buildNetworkSnapshot$x, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$h(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$L(luvio, config),
+        recordId: keyBuilder$M(luvio, config),
         node: adapterFragment$h(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$w(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$x(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getManagedContentSpaceFolderItemsV1AdapterFactory = (luvio) => function CMSAuthoring__getManagedContentSpaceFolderItemsV1(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$w(untrustedConfig, getManagedContentSpaceFolderItemsV1_ConfigPropertyNames);
+    const config = validateAdapterConfig$x(untrustedConfig, getManagedContentSpaceFolderItemsV1_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -2662,7 +2662,7 @@ const getManagedContentSpaceFolderItemsV1AdapterFactory = (luvio) => function CM
     buildCachedSnapshotCachePolicy$h, buildNetworkSnapshotCachePolicy$h);
 };
 
-function validate$R(obj, path = 'ManagedContentCollectionItemTypeSummaryRepresentation') {
+function validate$X(obj, path = 'ManagedContentCollectionItemTypeSummaryRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -2681,7 +2681,7 @@ function validate$R(obj, path = 'ManagedContentCollectionItemTypeSummaryRepresen
     return v_error === undefined ? null : v_error;
 }
 
-function validate$Q(obj, path = 'ManagedContentCollectionItemRepresentation') {
+function validate$W(obj, path = 'ManagedContentCollectionItemRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -2702,7 +2702,7 @@ function validate$Q(obj, path = 'ManagedContentCollectionItemRepresentation') {
         }
         const obj_contentType = obj.contentType;
         const path_contentType = path + '.contentType';
-        const referencepath_contentTypeValidationError = validate$R(obj_contentType, path_contentType);
+        const referencepath_contentTypeValidationError = validate$X(obj_contentType, path_contentType);
         if (referencepath_contentTypeValidationError !== null) {
             let message = 'Object doesn\'t match ManagedContentCollectionItemTypeSummaryRepresentation (at "' + path_contentType + '")\n';
             message += referencepath_contentTypeValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -2722,9 +2722,9 @@ function validate$Q(obj, path = 'ManagedContentCollectionItemRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$m = 100;
-const VERSION$o = "eeea454f1268ece5c3e24c986688b876";
-function validate$P(obj, path = 'ManagedContentCollectionDetailRepresentation') {
+const TTL$n = 100;
+const VERSION$p = "eeea454f1268ece5c3e24c986688b876";
+function validate$V(obj, path = 'ManagedContentCollectionDetailRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -2736,7 +2736,7 @@ function validate$P(obj, path = 'ManagedContentCollectionDetailRepresentation')
         }
         const obj_collectionType = obj.collectionType;
         const path_collectionType = path + '.collectionType';
-        const referencepath_collectionTypeValidationError = validate$12(obj_collectionType, path_collectionType);
+        const referencepath_collectionTypeValidationError = validate$18(obj_collectionType, path_collectionType);
         if (referencepath_collectionTypeValidationError !== null) {
             let message = 'Object doesn\'t match ManagedContentTypeSummaryRepresentation (at "' + path_collectionType + '")\n';
             message += referencepath_collectionTypeValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -2760,7 +2760,7 @@ function validate$P(obj, path = 'ManagedContentCollectionDetailRepresentation')
         for (let i = 0; i < obj_items.length; i++) {
             const obj_items_item = obj_items[i];
             const path_items_item = path_items + '[' + i + ']';
-            const referencepath_items_itemValidationError = validate$Q(obj_items_item, path_items_item);
+            const referencepath_items_itemValidationError = validate$W(obj_items_item, path_items_item);
             if (referencepath_items_itemValidationError !== null) {
                 let message = 'Object doesn\'t match ManagedContentCollectionItemRepresentation (at "' + path_items_item + '")\n';
                 message += referencepath_items_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -2795,77 +2795,77 @@ function validate$P(obj, path = 'ManagedContentCollectionDetailRepresentation')
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$n = 'ManagedContentCollectionDetailRepresentation';
-function keyBuilder$K(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$n + ':' + config.collection_key + ':' + config.language + ':' + config.version;
+const RepresentationType$o = 'ManagedContentCollectionDetailRepresentation';
+function keyBuilder$L(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$o + ':' + config.collection_key + ':' + config.language + ':' + config.version;
 }
-function keyBuilderFromType$b(luvio, object) {
+function keyBuilderFromType$c(luvio, object) {
     const keyParams = {
         collection_key: object.collectionKey,
         language: object.language,
         version: object.versionNumber
     };
-    return keyBuilder$K(luvio, keyParams);
+    return keyBuilder$L(luvio, keyParams);
 }
-function normalize$n(input, existing, path, luvio, store, timestamp) {
+function normalize$o(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$T = function ManagedContentCollectionDetailRepresentationSelect() {
+const select$V = function ManagedContentCollectionDetailRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$o,
+        version: VERSION$p,
         private: [],
         opaque: true
     };
 };
-function equals$o(existing, incoming) {
+function equals$p(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$n = function ManagedContentCollectionDetailRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$o = function ManagedContentCollectionDetailRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$P(input);
+        const validateError = validate$V(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$b(luvio, input);
-    const ttlToUse = TTL$m;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$n, "CMSAuthoring", VERSION$o, RepresentationType$n, equals$o);
+    const key = keyBuilderFromType$c(luvio, input);
+    const ttlToUse = TTL$n;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$o, "CMSAuthoring", VERSION$p, RepresentationType$o, equals$p);
     return createLink(key);
 };
-function getTypeCacheKeys$n(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$o(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$b(luvio, input);
+    const rootKey = keyBuilderFromType$c(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$n,
+        representationName: RepresentationType$o,
         mergeable: false
     });
 }
 
-function select$S(luvio, params) {
-    return select$T();
+function select$U(luvio, params) {
+    return select$V();
 }
-function keyBuilder$J(luvio, params) {
-    return keyBuilder$K(luvio, {
+function keyBuilder$K(luvio, params) {
+    return keyBuilder$L(luvio, {
         collection_key: params.urlParams.collectionKeyOrId,
         language: params.queryParams.language || '',
         version: params.queryParams.version || ''
     });
 }
-function getResponseCacheKeys$v(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$n(storeKeyMap, luvio, response);
+function getResponseCacheKeys$w(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$o(storeKeyMap, luvio, response);
 }
-function ingestSuccess$v(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$w(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$J(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$n, body);
+    const key = keyBuilder$K(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$o, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$S(),
+        node: select$U(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -2877,18 +2877,18 @@ function ingestSuccess$v(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$g(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$J(luvio, params);
+    const key = keyBuilder$K(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$m,
+        ttl: TTL$n,
         namespace: keyPrefix,
-        version: VERSION$o,
-        representationName: RepresentationType$n
+        version: VERSION$p,
+        representationName: RepresentationType$o
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$v(config) {
+function createResourceRequest$w(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -2917,62 +2917,62 @@ function onFetchResponseSuccess$i(luvio, config, resourceParams, response) {
     return onFetchResponseSuccess$h(luvio, config, updatedResourceParams, response);
 }
 
-const adapterName$v = 'getCollectionItems';
+const adapterName$w = 'getCollectionItems';
 const getCollectionItems_ConfigPropertyMetadata = [
     generateParamConfigMetadata('collectionKeyOrId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('language', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('version', false, 1 /* QueryParameter */, 0 /* String */),
 ];
-const getCollectionItems_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$v, getCollectionItems_ConfigPropertyMetadata);
-const createResourceParams$v = /*#__PURE__*/ createResourceParams$B(getCollectionItems_ConfigPropertyMetadata);
-function keyBuilder$I(luvio, config) {
-    const resourceParams = createResourceParams$v(config);
-    return keyBuilder$J(luvio, resourceParams);
+const getCollectionItems_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$w, getCollectionItems_ConfigPropertyMetadata);
+const createResourceParams$w = /*#__PURE__*/ createResourceParams$C(getCollectionItems_ConfigPropertyMetadata);
+function keyBuilder$J(luvio, config) {
+    const resourceParams = createResourceParams$w(config);
+    return keyBuilder$K(luvio, resourceParams);
 }
-function typeCheckConfig$v(untrustedConfig) {
+function typeCheckConfig$w(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getCollectionItems_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, getCollectionItems_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$v(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$w(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$v(untrustedConfig);
+    const config = typeCheckConfig$w(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$g(luvio, config) {
-    createResourceParams$v(config);
-    return select$S();
+    createResourceParams$w(config);
+    return select$U();
 }
 function onFetchResponseSuccess$h(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$v(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$w(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$v(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$w(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$g(luvio, config, resourceParams, response) {
     const snapshot = ingestError$g(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$v(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$w(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$v(luvio, config, options) {
-    const resourceParams = createResourceParams$v(config);
-    const request = createResourceRequest$v(resourceParams);
+function buildNetworkSnapshot$w(luvio, config, options) {
+    const resourceParams = createResourceParams$w(config);
+    const request = createResourceRequest$w(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess$i(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$v(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$w(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -2980,23 +2980,23 @@ function buildNetworkSnapshot$v(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$g(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$l(context, coercedAdapterRequestContext, buildNetworkSnapshot$v, undefined, false);
+    return buildNetworkSnapshotCachePolicy$l(context, coercedAdapterRequestContext, buildNetworkSnapshot$w, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$g(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$I(luvio, config),
+        recordId: keyBuilder$J(luvio, config),
         node: adapterFragment$g(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$v(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$w(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getCollectionItemsAdapterFactory = (luvio) => function CMSAuthoring__getCollectionItems(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$v(untrustedConfig, getCollectionItems_ConfigPropertyNames);
+    const config = validateAdapterConfig$w(untrustedConfig, getCollectionItems_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -3005,7 +3005,7 @@ const getCollectionItemsAdapterFactory = (luvio) => function CMSAuthoring__getCo
     buildCachedSnapshotCachePolicy$g, buildNetworkSnapshotCachePolicy$g);
 };
 
-function validate$O(obj, path = 'ManagedContentTranslationV2RequestInputRep') {
+function validate$U(obj, path = 'ManagedContentTranslationV2RequestInputRep') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -3075,9 +3075,9 @@ function validate$O(obj, path = 'ManagedContentTranslationV2RequestInputRep') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$l = 100;
-const VERSION$n = "52e643b998d6763482c6d74542b38408";
-function validate$N(obj, path = 'ManagedContentTranslationV2Representation') {
+const TTL$m = 100;
+const VERSION$o = "52e643b998d6763482c6d74542b38408";
+function validate$T(obj, path = 'ManagedContentTranslationV2Representation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -3234,68 +3234,68 @@ function validate$N(obj, path = 'ManagedContentTranslationV2Representation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$m = 'ManagedContentTranslationV2Representation';
-function keyBuilder$H(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$m + ':' + config.id;
+const RepresentationType$n = 'ManagedContentTranslationV2Representation';
+function keyBuilder$I(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$n + ':' + config.id;
 }
-function keyBuilderFromType$a(luvio, object) {
+function keyBuilderFromType$b(luvio, object) {
     const keyParams = {
         id: object.id
     };
-    return keyBuilder$H(luvio, keyParams);
+    return keyBuilder$I(luvio, keyParams);
 }
-function normalize$m(input, existing, path, luvio, store, timestamp) {
+function normalize$n(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$R = function ManagedContentTranslationV2RepresentationSelect() {
+const select$T = function ManagedContentTranslationV2RepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$n,
+        version: VERSION$o,
         private: [],
         opaque: true
     };
 };
-function equals$n(existing, incoming) {
+function equals$o(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$m = function ManagedContentTranslationV2RepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$n = function ManagedContentTranslationV2RepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$N(input);
+        const validateError = validate$T(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$a(luvio, input);
-    const ttlToUse = TTL$l;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$m, "CMSAuthoring", VERSION$n, RepresentationType$m, equals$n);
+    const key = keyBuilderFromType$b(luvio, input);
+    const ttlToUse = TTL$m;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$n, "CMSAuthoring", VERSION$o, RepresentationType$n, equals$o);
     return createLink(key);
 };
-function getTypeCacheKeys$m(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$n(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$a(luvio, input);
+    const rootKey = keyBuilderFromType$b(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$m,
+        representationName: RepresentationType$n,
         mergeable: false
     });
 }
 
-function select$Q(luvio, params) {
-    return select$R();
+function select$S(luvio, params) {
+    return select$T();
 }
-function getResponseCacheKeys$u(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$m(storeKeyMap, luvio, response);
+function getResponseCacheKeys$v(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$n(storeKeyMap, luvio, response);
 }
-function ingestSuccess$u(luvio, resourceParams, response) {
+function ingestSuccess$v(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$a(luvio, body);
-    luvio.storeIngest(key, ingest$m, body);
+    const key = keyBuilderFromType$b(luvio, body);
+    luvio.storeIngest(key, ingest$n, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$Q(),
+        node: select$S(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -3306,7 +3306,7 @@ function ingestSuccess$u(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$u(config) {
+function createResourceRequest$v(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -3320,47 +3320,47 @@ function createResourceRequest$u(config) {
     };
 }
 
-const adapterName$u = 'createTranslationV2Job';
+const adapterName$v = 'createTranslationV2Job';
 const createTranslationV2Job_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contentSpaceId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('translationV2Request', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const createTranslationV2Job_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$u, createTranslationV2Job_ConfigPropertyMetadata);
-const createResourceParams$u = /*#__PURE__*/ createResourceParams$B(createTranslationV2Job_ConfigPropertyMetadata);
-function typeCheckConfig$u(untrustedConfig) {
+const createTranslationV2Job_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$v, createTranslationV2Job_ConfigPropertyMetadata);
+const createResourceParams$v = /*#__PURE__*/ createResourceParams$C(createTranslationV2Job_ConfigPropertyMetadata);
+function typeCheckConfig$v(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, createTranslationV2Job_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, createTranslationV2Job_ConfigPropertyMetadata);
     const untrustedConfig_translationV2Request = untrustedConfig.translationV2Request;
-    const referenceManagedContentTranslationV2RequestInputRepValidationError = validate$O(untrustedConfig_translationV2Request);
+    const referenceManagedContentTranslationV2RequestInputRepValidationError = validate$U(untrustedConfig_translationV2Request);
     if (referenceManagedContentTranslationV2RequestInputRepValidationError === null) {
         config.translationV2Request = untrustedConfig_translationV2Request;
     }
     return config;
 }
-function validateAdapterConfig$u(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$v(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$u(untrustedConfig);
+    const config = typeCheckConfig$v(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$u(luvio, config, options) {
-    const resourceParams = createResourceParams$u(config);
-    const request = createResourceRequest$u(resourceParams);
+function buildNetworkSnapshot$v(luvio, config, options) {
+    const resourceParams = createResourceParams$v(config);
+    const request = createResourceRequest$v(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$u(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$v(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$u(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$v(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -3370,16 +3370,16 @@ function buildNetworkSnapshot$u(luvio, config, options) {
 }
 const createTranslationV2JobAdapterFactory = (luvio) => {
     return function createTranslationV2Job(untrustedConfig) {
-        const config = validateAdapterConfig$u(untrustedConfig, createTranslationV2Job_ConfigPropertyNames);
+        const config = validateAdapterConfig$v(untrustedConfig, createTranslationV2Job_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createTranslationV2Job"');
         }
-        return buildNetworkSnapshot$u(luvio, config);
+        return buildNetworkSnapshot$v(luvio, config);
     };
 };
 
-function validate$M(obj, path = 'ManagedContentTaxonomyPathFragmentRepresentation') {
+function validate$S(obj, path = 'ManagedContentTaxonomyPathFragmentRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -3398,9 +3398,9 @@ function validate$M(obj, path = 'ManagedContentTaxonomyPathFragmentRepresentatio
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$k = 100;
-const VERSION$m = "861a01549e9c8877564cf9109fe8af72";
-function validate$L(obj, path = 'ManagedContentTaxonomyPathRepresentation') {
+const TTL$l = 100;
+const VERSION$n = "861a01549e9c8877564cf9109fe8af72";
+function validate$R(obj, path = 'ManagedContentTaxonomyPathRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -3412,7 +3412,7 @@ function validate$L(obj, path = 'ManagedContentTaxonomyPathRepresentation') {
         }
         const obj_taxonomyFragment = obj.taxonomyFragment;
         const path_taxonomyFragment = path + '.taxonomyFragment';
-        const referencepath_taxonomyFragmentValidationError = validate$M(obj_taxonomyFragment, path_taxonomyFragment);
+        const referencepath_taxonomyFragmentValidationError = validate$S(obj_taxonomyFragment, path_taxonomyFragment);
         if (referencepath_taxonomyFragmentValidationError !== null) {
             let message = 'Object doesn\'t match ManagedContentTaxonomyPathFragmentRepresentation (at "' + path_taxonomyFragment + '")\n';
             message += referencepath_taxonomyFragmentValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -3426,7 +3426,7 @@ function validate$L(obj, path = 'ManagedContentTaxonomyPathRepresentation') {
         for (let i = 0; i < obj_termFragments.length; i++) {
             const obj_termFragments_item = obj_termFragments[i];
             const path_termFragments_item = path_termFragments + '[' + i + ']';
-            const referencepath_termFragments_itemValidationError = validate$M(obj_termFragments_item, path_termFragments_item);
+            const referencepath_termFragments_itemValidationError = validate$S(obj_termFragments_item, path_termFragments_item);
             if (referencepath_termFragments_itemValidationError !== null) {
                 let message = 'Object doesn\'t match ManagedContentTaxonomyPathFragmentRepresentation (at "' + path_termFragments_item + '")\n';
                 message += referencepath_termFragments_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -3436,48 +3436,48 @@ function validate$L(obj, path = 'ManagedContentTaxonomyPathRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$l = 'ManagedContentTaxonomyPathRepresentation';
-function normalize$l(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$m = 'ManagedContentTaxonomyPathRepresentation';
+function normalize$m(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$P = function ManagedContentTaxonomyPathRepresentationSelect() {
+const select$R = function ManagedContentTaxonomyPathRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$m,
+        version: VERSION$n,
         private: [],
         opaque: true
     };
 };
-function equals$m(existing, incoming) {
+function equals$n(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$l = function ManagedContentTaxonomyPathRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$m = function ManagedContentTaxonomyPathRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$L(input);
+        const validateError = validate$R(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = path.fullPath;
-    const ttlToUse = TTL$k;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$l, "CMSAuthoring", VERSION$m, RepresentationType$l, equals$m);
+    const ttlToUse = TTL$l;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$m, "CMSAuthoring", VERSION$n, RepresentationType$m, equals$n);
     return createLink(key);
 };
-function getTypeCacheKeys$l(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$m(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$l,
+        representationName: RepresentationType$m,
         mergeable: false
     });
 }
 
-const VERSION$l = "05c4867cd20f87930367aa80db4baab5";
-function validate$K(obj, path = 'ManagedContentTaxonomyTermRepresentation') {
+const VERSION$m = "05c4867cd20f87930367aa80db4baab5";
+function validate$Q(obj, path = 'ManagedContentTaxonomyTermRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -3507,14 +3507,14 @@ function validate$K(obj, path = 'ManagedContentTaxonomyTermRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$k = 'ManagedContentTaxonomyTermRepresentation';
-function normalize$k(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$l = 'ManagedContentTaxonomyTermRepresentation';
+function normalize$l(input, existing, path, luvio, store, timestamp) {
     const input_pathsFromRoot = input.pathsFromRoot;
     const input_pathsFromRoot_id = path.fullPath + '__pathsFromRoot';
     for (let i = 0; i < input_pathsFromRoot.length; i++) {
         const input_pathsFromRoot_item = input_pathsFromRoot[i];
         let input_pathsFromRoot_item_id = input_pathsFromRoot_id + '__' + i;
-        input_pathsFromRoot[i] = ingest$l(input_pathsFromRoot_item, {
+        input_pathsFromRoot[i] = ingest$m(input_pathsFromRoot_item, {
             fullPath: input_pathsFromRoot_item_id,
             propertyName: i,
             parent: {
@@ -3527,10 +3527,10 @@ function normalize$k(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$O = function ManagedContentTaxonomyTermRepresentationSelect() {
+const select$Q = function ManagedContentTaxonomyTermRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$l,
+        version: VERSION$m,
         private: [],
         selections: [
             {
@@ -3545,12 +3545,12 @@ const select$O = function ManagedContentTaxonomyTermRepresentationSelect() {
                 name: 'pathsFromRoot',
                 kind: 'Link',
                 plural: true,
-                fragment: select$P()
+                fragment: select$R()
             }
         ]
     };
 };
-function equals$l(existing, incoming) {
+function equals$m(existing, incoming) {
     const existing_id = existing.id;
     const incoming_id = incoming.id;
     if (!(existing_id === incoming_id)) {
@@ -3573,35 +3573,35 @@ function equals$l(existing, incoming) {
     }
     return true;
 }
-const ingest$k = function ManagedContentTaxonomyTermRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$l = function ManagedContentTaxonomyTermRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$K(input);
+        const validateError = validate$Q(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = path.fullPath;
     const ttlToUse = path.ttl;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$k, "CMSAuthoring", VERSION$l, RepresentationType$k, equals$l);
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$l, "CMSAuthoring", VERSION$m, RepresentationType$l, equals$m);
     return createLink(key);
 };
-function getTypeCacheKeys$k(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$l(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$k,
+        representationName: RepresentationType$l,
         mergeable: false
     });
     const input_pathsFromRoot_length = input.pathsFromRoot.length;
     for (let i = 0; i < input_pathsFromRoot_length; i++) {
-        getTypeCacheKeys$l(rootKeySet, luvio, input.pathsFromRoot[i], () => '');
+        getTypeCacheKeys$m(rootKeySet, luvio, input.pathsFromRoot[i], () => '');
     }
 }
 
-const TTL$j = 100;
-const VERSION$k = "838bc0422b420be598cab667d4031ed0";
-function validate$J(obj, path = 'ManagedContentTaxonomyTermCollectionRepresentation') {
+const TTL$k = 100;
+const VERSION$l = "838bc0422b420be598cab667d4031ed0";
+function validate$P(obj, path = 'ManagedContentTaxonomyTermCollectionRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -3631,23 +3631,23 @@ function validate$J(obj, path = 'ManagedContentTaxonomyTermCollectionRepresentat
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$j = 'ManagedContentTaxonomyTermCollectionRepresentation';
-function keyBuilder$G(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$j + ':' + config.id;
+const RepresentationType$k = 'ManagedContentTaxonomyTermCollectionRepresentation';
+function keyBuilder$H(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$k + ':' + config.id;
 }
-function keyBuilderFromType$9(luvio, object) {
+function keyBuilderFromType$a(luvio, object) {
     const keyParams = {
         id: object.contentKey
     };
-    return keyBuilder$G(luvio, keyParams);
+    return keyBuilder$H(luvio, keyParams);
 }
-function normalize$j(input, existing, path, luvio, store, timestamp) {
+function normalize$k(input, existing, path, luvio, store, timestamp) {
     const input_taxonomyTerms = input.taxonomyTerms;
     const input_taxonomyTerms_id = path.fullPath + '__taxonomyTerms';
     for (let i = 0; i < input_taxonomyTerms.length; i++) {
         const input_taxonomyTerms_item = input_taxonomyTerms[i];
         let input_taxonomyTerms_item_id = input_taxonomyTerms_id + '__' + i;
-        input_taxonomyTerms[i] = ingest$k(input_taxonomyTerms_item, {
+        input_taxonomyTerms[i] = ingest$l(input_taxonomyTerms_item, {
             fullPath: input_taxonomyTerms_item_id,
             propertyName: i,
             parent: {
@@ -3660,10 +3660,10 @@ function normalize$j(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$N = function ManagedContentTaxonomyTermCollectionRepresentationSelect() {
+const select$P = function ManagedContentTaxonomyTermCollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$k,
+        version: VERSION$l,
         private: [],
         selections: [
             {
@@ -3678,12 +3678,12 @@ const select$N = function ManagedContentTaxonomyTermCollectionRepresentationSele
                 name: 'taxonomyTerms',
                 kind: 'Link',
                 plural: true,
-                fragment: select$O()
+                fragment: select$Q()
             }
         ]
     };
 };
-function equals$k(existing, incoming) {
+function equals$l(existing, incoming) {
     const existing_contentKey = existing.contentKey;
     const incoming_contentKey = incoming.contentKey;
     if (!(existing_contentKey === incoming_contentKey)) {
@@ -3706,50 +3706,50 @@ function equals$k(existing, incoming) {
     }
     return true;
 }
-const ingest$j = function ManagedContentTaxonomyTermCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$k = function ManagedContentTaxonomyTermCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$J(input);
+        const validateError = validate$P(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$9(luvio, input);
-    const ttlToUse = TTL$j;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$j, "CMSAuthoring", VERSION$k, RepresentationType$j, equals$k);
+    const key = keyBuilderFromType$a(luvio, input);
+    const ttlToUse = TTL$k;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$k, "CMSAuthoring", VERSION$l, RepresentationType$k, equals$l);
     return createLink(key);
 };
-function getTypeCacheKeys$j(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$k(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$9(luvio, input);
+    const rootKey = keyBuilderFromType$a(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$j,
+        representationName: RepresentationType$k,
         mergeable: false
     });
     const input_taxonomyTerms_length = input.taxonomyTerms.length;
     for (let i = 0; i < input_taxonomyTerms_length; i++) {
-        getTypeCacheKeys$k(rootKeySet, luvio, input.taxonomyTerms[i], () => '');
+        getTypeCacheKeys$l(rootKeySet, luvio, input.taxonomyTerms[i], () => '');
     }
 }
 
-function select$M(luvio, params) {
-    return select$N();
+function select$O(luvio, params) {
+    return select$P();
 }
-function keyBuilder$F(luvio, params) {
-    return keyBuilder$G(luvio, {
+function keyBuilder$G(luvio, params) {
+    return keyBuilder$H(luvio, {
         id: params.urlParams.contentKeyOrId
     });
 }
-function getResponseCacheKeys$t(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$j(storeKeyMap, luvio, response);
+function getResponseCacheKeys$u(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$k(storeKeyMap, luvio, response);
 }
-function ingestSuccess$t(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$u(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$F(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$j, body);
+    const key = keyBuilder$G(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$k, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$M(),
+        node: select$O(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -3761,18 +3761,18 @@ function ingestSuccess$t(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$f(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$F(luvio, params);
+    const key = keyBuilder$G(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$j,
+        ttl: TTL$k,
         namespace: keyPrefix,
-        version: VERSION$k,
-        representationName: RepresentationType$j
+        version: VERSION$l,
+        representationName: RepresentationType$k
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$t(config) {
+function createResourceRequest$u(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -3786,60 +3786,60 @@ function createResourceRequest$t(config) {
     };
 }
 
-const adapterName$t = 'getManagedContentTaxonomyTerms';
+const adapterName$u = 'getManagedContentTaxonomyTerms';
 const getManagedContentTaxonomyTerms_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contentKeyOrId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getManagedContentTaxonomyTerms_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$t, getManagedContentTaxonomyTerms_ConfigPropertyMetadata);
-const createResourceParams$t = /*#__PURE__*/ createResourceParams$B(getManagedContentTaxonomyTerms_ConfigPropertyMetadata);
-function keyBuilder$E(luvio, config) {
-    const resourceParams = createResourceParams$t(config);
-    return keyBuilder$F(luvio, resourceParams);
+const getManagedContentTaxonomyTerms_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$u, getManagedContentTaxonomyTerms_ConfigPropertyMetadata);
+const createResourceParams$u = /*#__PURE__*/ createResourceParams$C(getManagedContentTaxonomyTerms_ConfigPropertyMetadata);
+function keyBuilder$F(luvio, config) {
+    const resourceParams = createResourceParams$u(config);
+    return keyBuilder$G(luvio, resourceParams);
 }
-function typeCheckConfig$t(untrustedConfig) {
+function typeCheckConfig$u(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getManagedContentTaxonomyTerms_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, getManagedContentTaxonomyTerms_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$t(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$u(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$t(untrustedConfig);
+    const config = typeCheckConfig$u(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$f(luvio, config) {
-    createResourceParams$t(config);
-    return select$M();
+    createResourceParams$u(config);
+    return select$O();
 }
 function onFetchResponseSuccess$g(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$t(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$u(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$t(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$u(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$f(luvio, config, resourceParams, response) {
     const snapshot = ingestError$f(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$t(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$u(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$t(luvio, config, options) {
-    const resourceParams = createResourceParams$t(config);
-    const request = createResourceRequest$t(resourceParams);
+function buildNetworkSnapshot$u(luvio, config, options) {
+    const resourceParams = createResourceParams$u(config);
+    const request = createResourceRequest$u(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess$g(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$t(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$u(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -3847,23 +3847,23 @@ function buildNetworkSnapshot$t(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$l(context, coercedAdapterRequestContext, buildNetworkSnapshot$t, undefined, false);
+    return buildNetworkSnapshotCachePolicy$l(context, coercedAdapterRequestContext, buildNetworkSnapshot$u, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$f(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$E(luvio, config),
+        recordId: keyBuilder$F(luvio, config),
         node: adapterFragment$f(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$t(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$u(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getManagedContentTaxonomyTermsAdapterFactory = (luvio) => function CMSAuthoring__getManagedContentTaxonomyTerms(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$t(untrustedConfig, getManagedContentTaxonomyTerms_ConfigPropertyNames);
+    const config = validateAdapterConfig$u(untrustedConfig, getManagedContentTaxonomyTerms_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -3872,19 +3872,19 @@ const getManagedContentTaxonomyTermsAdapterFactory = (luvio) => function CMSAuth
     buildCachedSnapshotCachePolicy$f, buildNetworkSnapshotCachePolicy$f);
 };
 
-function select$L(luvio, params) {
-    return select$N();
+function select$N(luvio, params) {
+    return select$P();
 }
-function getResponseCacheKeys$s(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$j(storeKeyMap, luvio, response);
+function getResponseCacheKeys$t(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$k(storeKeyMap, luvio, response);
 }
-function ingestSuccess$s(luvio, resourceParams, response) {
+function ingestSuccess$t(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$9(luvio, body);
-    luvio.storeIngest(key, ingest$j, body);
+    const key = keyBuilderFromType$a(luvio, body);
+    luvio.storeIngest(key, ingest$k, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$L(),
+        node: select$N(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -3895,7 +3895,7 @@ function ingestSuccess$s(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$s(config) {
+function createResourceRequest$t(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -3909,43 +3909,43 @@ function createResourceRequest$s(config) {
     };
 }
 
-const adapterName$s = 'updateManagedContentTaxonomyTerms';
+const adapterName$t = 'updateManagedContentTaxonomyTerms';
 const updateManagedContentTaxonomyTerms_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contentKeyOrId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('termsToAdd', true, 2 /* Body */, 0 /* String */, true),
     generateParamConfigMetadata('termsToRemove', true, 2 /* Body */, 0 /* String */, true),
 ];
-const updateManagedContentTaxonomyTerms_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$s, updateManagedContentTaxonomyTerms_ConfigPropertyMetadata);
-const createResourceParams$s = /*#__PURE__*/ createResourceParams$B(updateManagedContentTaxonomyTerms_ConfigPropertyMetadata);
-function typeCheckConfig$s(untrustedConfig) {
+const updateManagedContentTaxonomyTerms_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$t, updateManagedContentTaxonomyTerms_ConfigPropertyMetadata);
+const createResourceParams$t = /*#__PURE__*/ createResourceParams$C(updateManagedContentTaxonomyTerms_ConfigPropertyMetadata);
+function typeCheckConfig$t(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, updateManagedContentTaxonomyTerms_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, updateManagedContentTaxonomyTerms_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$s(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$t(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$s(untrustedConfig);
+    const config = typeCheckConfig$t(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$s(luvio, config, options) {
-    const resourceParams = createResourceParams$s(config);
-    const request = createResourceRequest$s(resourceParams);
+function buildNetworkSnapshot$t(luvio, config, options) {
+    const resourceParams = createResourceParams$t(config);
+    const request = createResourceRequest$t(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$s(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$t(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$s(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$t(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -3955,16 +3955,16 @@ function buildNetworkSnapshot$s(luvio, config, options) {
 }
 const updateManagedContentTaxonomyTermsAdapterFactory = (luvio) => {
     return function updateManagedContentTaxonomyTerms(untrustedConfig) {
-        const config = validateAdapterConfig$s(untrustedConfig, updateManagedContentTaxonomyTerms_ConfigPropertyNames);
+        const config = validateAdapterConfig$t(untrustedConfig, updateManagedContentTaxonomyTerms_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "updateManagedContentTaxonomyTerms"');
         }
-        return buildNetworkSnapshot$s(luvio, config);
+        return buildNetworkSnapshot$t(luvio, config);
     };
 };
 
-function validate$I(obj, path = 'ManagedContentInputRepresentation') {
+function validate$O(obj, path = 'ManagedContentInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4011,7 +4011,7 @@ function validate$I(obj, path = 'ManagedContentInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$H(obj, path = 'ManagedContentSpaceSummaryRepresentation') {
+function validate$N(obj, path = 'ManagedContentSpaceSummaryRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4030,7 +4030,7 @@ function validate$H(obj, path = 'ManagedContentSpaceSummaryRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$G(obj, path = 'ManagedContentFolderSummaryRepresentation') {
+function validate$M(obj, path = 'ManagedContentFolderSummaryRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4049,7 +4049,7 @@ function validate$G(obj, path = 'ManagedContentFolderSummaryRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$F(obj, path = 'ManagedContentVariantStatusRepresentation') {
+function validate$L(obj, path = 'ManagedContentVariantStatusRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4068,9 +4068,9 @@ function validate$F(obj, path = 'ManagedContentVariantStatusRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$i = 100;
-const VERSION$j = "f644ed182fdec4abba2087ae85c47223";
-function validate$E(obj, path = 'ManagedContentDocumentRepresentation') {
+const TTL$j = 100;
+const VERSION$k = "f644ed182fdec4abba2087ae85c47223";
+function validate$K(obj, path = 'ManagedContentDocumentRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4122,170 +4122,669 @@ function validate$E(obj, path = 'ManagedContentDocumentRepresentation') {
         }
         const obj_contentSpace = obj.contentSpace;
         const path_contentSpace = path + '.contentSpace';
-        const referencepath_contentSpaceValidationError = validate$H(obj_contentSpace, path_contentSpace);
+        const referencepath_contentSpaceValidationError = validate$N(obj_contentSpace, path_contentSpace);
         if (referencepath_contentSpaceValidationError !== null) {
             let message = 'Object doesn\'t match ManagedContentSpaceSummaryRepresentation (at "' + path_contentSpace + '")\n';
             message += referencepath_contentSpaceValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
             return new TypeError(message);
         }
-        const obj_contentType = obj.contentType;
-        const path_contentType = path + '.contentType';
-        const referencepath_contentTypeValidationError = validate$12(obj_contentType, path_contentType);
-        if (referencepath_contentTypeValidationError !== null) {
-            let message = 'Object doesn\'t match ManagedContentTypeSummaryRepresentation (at "' + path_contentType + '")\n';
-            message += referencepath_contentTypeValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
-            return new TypeError(message);
+        const obj_contentType = obj.contentType;
+        const path_contentType = path + '.contentType';
+        const referencepath_contentTypeValidationError = validate$18(obj_contentType, path_contentType);
+        if (referencepath_contentTypeValidationError !== null) {
+            let message = 'Object doesn\'t match ManagedContentTypeSummaryRepresentation (at "' + path_contentType + '")\n';
+            message += referencepath_contentTypeValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_createdBy = obj.createdBy;
+        const path_createdBy = path + '.createdBy';
+        const referencepath_createdByValidationError = validate$15(obj_createdBy, path_createdBy);
+        if (referencepath_createdByValidationError !== null) {
+            let message = 'Object doesn\'t match ManagedContentUserSummaryRepresentation (at "' + path_createdBy + '")\n';
+            message += referencepath_createdByValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_createdDate = obj.createdDate;
+        const path_createdDate = path + '.createdDate';
+        if (typeof obj_createdDate !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_createdDate + '" (at "' + path_createdDate + '")');
+        }
+        const obj_folder = obj.folder;
+        const path_folder = path + '.folder';
+        const referencepath_folderValidationError = validate$M(obj_folder, path_folder);
+        if (referencepath_folderValidationError !== null) {
+            let message = 'Object doesn\'t match ManagedContentFolderSummaryRepresentation (at "' + path_folder + '")\n';
+            message += referencepath_folderValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_isPublished = obj.isPublished;
+        const path_isPublished = path + '.isPublished';
+        if (typeof obj_isPublished !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_isPublished + '" (at "' + path_isPublished + '")');
+        }
+        const obj_language = obj.language;
+        const path_language = path + '.language';
+        if (typeof obj_language !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_language + '" (at "' + path_language + '")');
+        }
+        const obj_lastModifiedBy = obj.lastModifiedBy;
+        const path_lastModifiedBy = path + '.lastModifiedBy';
+        const referencepath_lastModifiedByValidationError = validate$15(obj_lastModifiedBy, path_lastModifiedBy);
+        if (referencepath_lastModifiedByValidationError !== null) {
+            let message = 'Object doesn\'t match ManagedContentUserSummaryRepresentation (at "' + path_lastModifiedBy + '")\n';
+            message += referencepath_lastModifiedByValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_lastModifiedDate = obj.lastModifiedDate;
+        const path_lastModifiedDate = path + '.lastModifiedDate';
+        if (typeof obj_lastModifiedDate !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_lastModifiedDate + '" (at "' + path_lastModifiedDate + '")');
+        }
+        const obj_managedContentId = obj.managedContentId;
+        const path_managedContentId = path + '.managedContentId';
+        if (typeof obj_managedContentId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_managedContentId + '" (at "' + path_managedContentId + '")');
+        }
+        const obj_managedContentVariantId = obj.managedContentVariantId;
+        const path_managedContentVariantId = path + '.managedContentVariantId';
+        if (typeof obj_managedContentVariantId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_managedContentVariantId + '" (at "' + path_managedContentVariantId + '")');
+        }
+        const obj_managedContentVersionId = obj.managedContentVersionId;
+        const path_managedContentVersionId = path + '.managedContentVersionId';
+        if (typeof obj_managedContentVersionId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_managedContentVersionId + '" (at "' + path_managedContentVersionId + '")');
+        }
+        if (obj.status !== undefined) {
+            const obj_status = obj.status;
+            const path_status = path + '.status';
+            let obj_status_union0 = null;
+            const obj_status_union0_error = (() => {
+                const referencepath_statusValidationError = validate$L(obj_status, path_status);
+                if (referencepath_statusValidationError !== null) {
+                    let message = 'Object doesn\'t match ManagedContentVariantStatusRepresentation (at "' + path_status + '")\n';
+                    message += referencepath_statusValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            })();
+            if (obj_status_union0_error != null) {
+                obj_status_union0 = obj_status_union0_error.message;
+            }
+            let obj_status_union1 = null;
+            const obj_status_union1_error = (() => {
+                if (obj_status !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_status + '" (at "' + path_status + '")');
+                }
+            })();
+            if (obj_status_union1_error != null) {
+                obj_status_union1 = obj_status_union1_error.message;
+            }
+            if (obj_status_union0 && obj_status_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_status + '")';
+                message += '\n' + obj_status_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_status_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_title = obj.title;
+        const path_title = path + '.title';
+        if (typeof obj_title !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_title + '" (at "' + path_title + '")');
+        }
+        const obj_urlName = obj.urlName;
+        const path_urlName = path + '.urlName';
+        if (typeof obj_urlName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_urlName + '" (at "' + path_urlName + '")');
+        }
+        const obj_version = obj.version;
+        const path_version = path + '.version';
+        if (typeof obj_version !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_version + '" (at "' + path_version + '")');
+        }
+        const obj_versionNumber = obj.versionNumber;
+        const path_versionNumber = path + '.versionNumber';
+        let obj_versionNumber_union0 = null;
+        const obj_versionNumber_union0_error = (() => {
+            if (typeof obj_versionNumber !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_versionNumber + '" (at "' + path_versionNumber + '")');
+            }
+        })();
+        if (obj_versionNumber_union0_error != null) {
+            obj_versionNumber_union0 = obj_versionNumber_union0_error.message;
+        }
+        let obj_versionNumber_union1 = null;
+        const obj_versionNumber_union1_error = (() => {
+            if (obj_versionNumber !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_versionNumber + '" (at "' + path_versionNumber + '")');
+            }
+        })();
+        if (obj_versionNumber_union1_error != null) {
+            obj_versionNumber_union1 = obj_versionNumber_union1_error.message;
+        }
+        if (obj_versionNumber_union0 && obj_versionNumber_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_versionNumber + '")';
+            message += '\n' + obj_versionNumber_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_versionNumber_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$j = 'ManagedContentDocumentRepresentation';
+function keyBuilder$E(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$j + ':' + config.content_key + ':' + config.language + ':' + config.version;
+}
+function keyBuilderFromType$9(luvio, object) {
+    const keyParams = {
+        content_key: object.contentKey,
+        language: object.language,
+        version: object.version
+    };
+    return keyBuilder$E(luvio, keyParams);
+}
+function normalize$j(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$M = function ManagedContentDocumentRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$k,
+        private: [],
+        opaque: true
+    };
+};
+function equals$k(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
+const ingest$j = function ManagedContentDocumentRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$K(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$9(luvio, input);
+    const ttlToUse = TTL$j;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$j, "CMSAuthoring", VERSION$k, RepresentationType$j, equals$k);
+    return createLink(key);
+};
+function getTypeCacheKeys$j(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$9(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$j,
+        mergeable: false
+    });
+}
+
+function select$L(luvio, params) {
+    return select$M();
+}
+function getResponseCacheKeys$s(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$j(storeKeyMap, luvio, response);
+}
+function ingestSuccess$s(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$9(luvio, body);
+    luvio.storeIngest(key, ingest$j, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$L(),
+        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');
+        }
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
+}
+function createResourceRequest$s(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v61.0',
+        basePath: '/connect/cms/contents',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+function ingestSuccess$r(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$s(luvio, resourceParams, response);
+}
+
+const adapterName$s = 'createManagedContent';
+const createManagedContent_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('ManagedContentInputParam', true, 2 /* Body */, 4 /* Unsupported */),
+];
+const createManagedContent_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$s, createManagedContent_ConfigPropertyMetadata);
+const createResourceParams$s = /*#__PURE__*/ createResourceParams$C(createManagedContent_ConfigPropertyMetadata);
+function typeCheckConfig$s(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_ManagedContentInputParam = untrustedConfig.ManagedContentInputParam;
+    const referenceManagedContentInputRepresentationValidationError = validate$O(untrustedConfig_ManagedContentInputParam);
+    if (referenceManagedContentInputRepresentationValidationError === null) {
+        config.ManagedContentInputParam = untrustedConfig_ManagedContentInputParam;
+    }
+    return config;
+}
+function validateAdapterConfig$s(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$s(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$s(luvio, config, options) {
+    const resourceParams = createResourceParams$s(config);
+    const request = createResourceRequest$s(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$r(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$s(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const createManagedContentAdapterFactory = (luvio) => {
+    return function createManagedContent(untrustedConfig) {
+        const config = validateAdapterConfig$s(untrustedConfig, createManagedContent_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "createManagedContent"');
+        }
+        return buildNetworkSnapshot$s(luvio, config);
+    };
+};
+
+function validate$J(obj, path = 'ManagedContentCloneItemRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_contentKeyOrId = obj.contentKeyOrId;
+        const path_contentKeyOrId = path + '.contentKeyOrId';
+        if (typeof obj_contentKeyOrId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contentKeyOrId + '" (at "' + path_contentKeyOrId + '")');
+        }
+        if (obj.title !== undefined) {
+            const obj_title = obj.title;
+            const path_title = path + '.title';
+            if (typeof obj_title !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_title + '" (at "' + path_title + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$I(obj, path = 'ManagedContentCloneStatusRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
         }
-        const obj_createdBy = obj.createdBy;
-        const path_createdBy = path + '.createdBy';
-        const referencepath_createdByValidationError = validate$$(obj_createdBy, path_createdBy);
-        if (referencepath_createdByValidationError !== null) {
-            let message = 'Object doesn\'t match ManagedContentUserSummaryRepresentation (at "' + path_createdBy + '")\n';
-            message += referencepath_createdByValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
-            return new TypeError(message);
+        const obj_label = obj.label;
+        const path_label = path + '.label';
+        if (typeof obj_label !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_label + '" (at "' + path_label + '")');
         }
-        const obj_createdDate = obj.createdDate;
-        const path_createdDate = path + '.createdDate';
-        if (typeof obj_createdDate !== 'string') {
-            return new TypeError('Expected "string" but received "' + typeof obj_createdDate + '" (at "' + path_createdDate + '")');
+        const obj_status = obj.status;
+        const path_status = path + '.status';
+        if (typeof obj_status !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_status + '" (at "' + path_status + '")');
         }
-        const obj_folder = obj.folder;
-        const path_folder = path + '.folder';
-        const referencepath_folderValidationError = validate$G(obj_folder, path_folder);
-        if (referencepath_folderValidationError !== null) {
-            let message = 'Object doesn\'t match ManagedContentFolderSummaryRepresentation (at "' + path_folder + '")\n';
-            message += referencepath_folderValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
-            return new TypeError(message);
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$H(obj, path = 'ManagedContentFailedVariantsRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
         }
-        const obj_isPublished = obj.isPublished;
-        const path_isPublished = path + '.isPublished';
-        if (typeof obj_isPublished !== 'boolean') {
-            return new TypeError('Expected "boolean" but received "' + typeof obj_isPublished + '" (at "' + path_isPublished + '")');
+        const obj_errorMessage = obj.errorMessage;
+        const path_errorMessage = path + '.errorMessage';
+        if (typeof obj_errorMessage !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_errorMessage + '" (at "' + path_errorMessage + '")');
         }
         const obj_language = obj.language;
         const path_language = path + '.language';
         if (typeof obj_language !== 'string') {
             return new TypeError('Expected "string" but received "' + typeof obj_language + '" (at "' + path_language + '")');
         }
-        const obj_lastModifiedBy = obj.lastModifiedBy;
-        const path_lastModifiedBy = path + '.lastModifiedBy';
-        const referencepath_lastModifiedByValidationError = validate$$(obj_lastModifiedBy, path_lastModifiedBy);
-        if (referencepath_lastModifiedByValidationError !== null) {
-            let message = 'Object doesn\'t match ManagedContentUserSummaryRepresentation (at "' + path_lastModifiedBy + '")\n';
-            message += referencepath_lastModifiedByValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
-            return new TypeError(message);
+        const obj_sourceManagedContentVariantId = obj.sourceManagedContentVariantId;
+        const path_sourceManagedContentVariantId = path + '.sourceManagedContentVariantId';
+        if (typeof obj_sourceManagedContentVariantId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_sourceManagedContentVariantId + '" (at "' + path_sourceManagedContentVariantId + '")');
         }
-        const obj_lastModifiedDate = obj.lastModifiedDate;
-        const path_lastModifiedDate = path + '.lastModifiedDate';
-        if (typeof obj_lastModifiedDate !== 'string') {
-            return new TypeError('Expected "string" but received "' + typeof obj_lastModifiedDate + '" (at "' + path_lastModifiedDate + '")');
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$G(obj, path = 'ManagedContentCloneVariantsRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
         }
-        const obj_managedContentId = obj.managedContentId;
-        const path_managedContentId = path + '.managedContentId';
-        if (typeof obj_managedContentId !== 'string') {
-            return new TypeError('Expected "string" but received "' + typeof obj_managedContentId + '" (at "' + path_managedContentId + '")');
+        const obj_language = obj.language;
+        const path_language = path + '.language';
+        if (typeof obj_language !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_language + '" (at "' + path_language + '")');
         }
         const obj_managedContentVariantId = obj.managedContentVariantId;
         const path_managedContentVariantId = path + '.managedContentVariantId';
         if (typeof obj_managedContentVariantId !== 'string') {
             return new TypeError('Expected "string" but received "' + typeof obj_managedContentVariantId + '" (at "' + path_managedContentVariantId + '")');
         }
-        const obj_managedContentVersionId = obj.managedContentVersionId;
-        const path_managedContentVersionId = path + '.managedContentVersionId';
-        if (typeof obj_managedContentVersionId !== 'string') {
-            return new TypeError('Expected "string" but received "' + typeof obj_managedContentVersionId + '" (at "' + path_managedContentVersionId + '")');
+        const obj_resourceURL = obj.resourceURL;
+        const path_resourceURL = path + '.resourceURL';
+        let obj_resourceURL_union0 = null;
+        const obj_resourceURL_union0_error = (() => {
+            if (typeof obj_resourceURL !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_resourceURL + '" (at "' + path_resourceURL + '")');
+            }
+        })();
+        if (obj_resourceURL_union0_error != null) {
+            obj_resourceURL_union0 = obj_resourceURL_union0_error.message;
         }
-        if (obj.status !== undefined) {
-            const obj_status = obj.status;
-            const path_status = path + '.status';
-            let obj_status_union0 = null;
-            const obj_status_union0_error = (() => {
-                const referencepath_statusValidationError = validate$F(obj_status, path_status);
-                if (referencepath_statusValidationError !== null) {
-                    let message = 'Object doesn\'t match ManagedContentVariantStatusRepresentation (at "' + path_status + '")\n';
-                    message += referencepath_statusValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+        let obj_resourceURL_union1 = null;
+        const obj_resourceURL_union1_error = (() => {
+            if (obj_resourceURL !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_resourceURL + '" (at "' + path_resourceURL + '")');
+            }
+        })();
+        if (obj_resourceURL_union1_error != null) {
+            obj_resourceURL_union1 = obj_resourceURL_union1_error.message;
+        }
+        if (obj_resourceURL_union0 && obj_resourceURL_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_resourceURL + '")';
+            message += '\n' + obj_resourceURL_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_resourceURL_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$F(obj, path = 'ManagedContentCloneRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_cloneStatus = obj.cloneStatus;
+        const path_cloneStatus = path + '.cloneStatus';
+        const referencepath_cloneStatusValidationError = validate$I(obj_cloneStatus, path_cloneStatus);
+        if (referencepath_cloneStatusValidationError !== null) {
+            let message = 'Object doesn\'t match ManagedContentCloneStatusRepresentation (at "' + path_cloneStatus + '")\n';
+            message += referencepath_cloneStatusValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        if (obj.contentKey !== undefined) {
+            const obj_contentKey = obj.contentKey;
+            const path_contentKey = path + '.contentKey';
+            let obj_contentKey_union0 = null;
+            const obj_contentKey_union0_error = (() => {
+                if (typeof obj_contentKey !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_contentKey + '" (at "' + path_contentKey + '")');
+                }
+            })();
+            if (obj_contentKey_union0_error != null) {
+                obj_contentKey_union0 = obj_contentKey_union0_error.message;
+            }
+            let obj_contentKey_union1 = null;
+            const obj_contentKey_union1_error = (() => {
+                if (obj_contentKey !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_contentKey + '" (at "' + path_contentKey + '")');
+                }
+            })();
+            if (obj_contentKey_union1_error != null) {
+                obj_contentKey_union1 = obj_contentKey_union1_error.message;
+            }
+            if (obj_contentKey_union0 && obj_contentKey_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_contentKey + '")';
+                message += '\n' + obj_contentKey_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_contentKey_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.errorMessage !== undefined) {
+            const obj_errorMessage = obj.errorMessage;
+            const path_errorMessage = path + '.errorMessage';
+            let obj_errorMessage_union0 = null;
+            const obj_errorMessage_union0_error = (() => {
+                if (typeof obj_errorMessage !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_errorMessage + '" (at "' + path_errorMessage + '")');
+                }
+            })();
+            if (obj_errorMessage_union0_error != null) {
+                obj_errorMessage_union0 = obj_errorMessage_union0_error.message;
+            }
+            let obj_errorMessage_union1 = null;
+            const obj_errorMessage_union1_error = (() => {
+                if (obj_errorMessage !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_errorMessage + '" (at "' + path_errorMessage + '")');
+                }
+            })();
+            if (obj_errorMessage_union1_error != null) {
+                obj_errorMessage_union1 = obj_errorMessage_union1_error.message;
+            }
+            if (obj_errorMessage_union0 && obj_errorMessage_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_errorMessage + '")';
+                message += '\n' + obj_errorMessage_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_errorMessage_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.failedVariants !== undefined) {
+            const obj_failedVariants = obj.failedVariants;
+            const path_failedVariants = path + '.failedVariants';
+            let obj_failedVariants_union0 = null;
+            const obj_failedVariants_union0_error = (() => {
+                const referencepath_failedVariantsValidationError = validate$H(obj_failedVariants, path_failedVariants);
+                if (referencepath_failedVariantsValidationError !== null) {
+                    let message = 'Object doesn\'t match ManagedContentFailedVariantsRepresentation (at "' + path_failedVariants + '")\n';
+                    message += referencepath_failedVariantsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
                     return new TypeError(message);
                 }
             })();
-            if (obj_status_union0_error != null) {
-                obj_status_union0 = obj_status_union0_error.message;
+            if (obj_failedVariants_union0_error != null) {
+                obj_failedVariants_union0 = obj_failedVariants_union0_error.message;
             }
-            let obj_status_union1 = null;
-            const obj_status_union1_error = (() => {
-                if (obj_status !== null) {
-                    return new TypeError('Expected "null" but received "' + typeof obj_status + '" (at "' + path_status + '")');
+            let obj_failedVariants_union1 = null;
+            const obj_failedVariants_union1_error = (() => {
+                if (obj_failedVariants !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_failedVariants + '" (at "' + path_failedVariants + '")');
                 }
             })();
-            if (obj_status_union1_error != null) {
-                obj_status_union1 = obj_status_union1_error.message;
+            if (obj_failedVariants_union1_error != null) {
+                obj_failedVariants_union1 = obj_failedVariants_union1_error.message;
             }
-            if (obj_status_union0 && obj_status_union1) {
-                let message = 'Object doesn\'t match union (at "' + path_status + '")';
-                message += '\n' + obj_status_union0.split('\n').map((line) => '\t' + line).join('\n');
-                message += '\n' + obj_status_union1.split('\n').map((line) => '\t' + line).join('\n');
+            if (obj_failedVariants_union0 && obj_failedVariants_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_failedVariants + '")';
+                message += '\n' + obj_failedVariants_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_failedVariants_union1.split('\n').map((line) => '\t' + line).join('\n');
                 return new TypeError(message);
             }
         }
-        const obj_title = obj.title;
-        const path_title = path + '.title';
-        if (typeof obj_title !== 'string') {
-            return new TypeError('Expected "string" but received "' + typeof obj_title + '" (at "' + path_title + '")');
+        if (obj.managedContentId !== undefined) {
+            const obj_managedContentId = obj.managedContentId;
+            const path_managedContentId = path + '.managedContentId';
+            let obj_managedContentId_union0 = null;
+            const obj_managedContentId_union0_error = (() => {
+                if (typeof obj_managedContentId !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_managedContentId + '" (at "' + path_managedContentId + '")');
+                }
+            })();
+            if (obj_managedContentId_union0_error != null) {
+                obj_managedContentId_union0 = obj_managedContentId_union0_error.message;
+            }
+            let obj_managedContentId_union1 = null;
+            const obj_managedContentId_union1_error = (() => {
+                if (obj_managedContentId !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_managedContentId + '" (at "' + path_managedContentId + '")');
+                }
+            })();
+            if (obj_managedContentId_union1_error != null) {
+                obj_managedContentId_union1 = obj_managedContentId_union1_error.message;
+            }
+            if (obj_managedContentId_union0 && obj_managedContentId_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_managedContentId + '")';
+                message += '\n' + obj_managedContentId_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_managedContentId_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
         }
-        const obj_urlName = obj.urlName;
-        const path_urlName = path + '.urlName';
-        if (typeof obj_urlName !== 'string') {
-            return new TypeError('Expected "string" but received "' + typeof obj_urlName + '" (at "' + path_urlName + '")');
+        if (obj.resourceURL !== undefined) {
+            const obj_resourceURL = obj.resourceURL;
+            const path_resourceURL = path + '.resourceURL';
+            let obj_resourceURL_union0 = null;
+            const obj_resourceURL_union0_error = (() => {
+                if (typeof obj_resourceURL !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_resourceURL + '" (at "' + path_resourceURL + '")');
+                }
+            })();
+            if (obj_resourceURL_union0_error != null) {
+                obj_resourceURL_union0 = obj_resourceURL_union0_error.message;
+            }
+            let obj_resourceURL_union1 = null;
+            const obj_resourceURL_union1_error = (() => {
+                if (obj_resourceURL !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_resourceURL + '" (at "' + path_resourceURL + '")');
+                }
+            })();
+            if (obj_resourceURL_union1_error != null) {
+                obj_resourceURL_union1 = obj_resourceURL_union1_error.message;
+            }
+            if (obj_resourceURL_union0 && obj_resourceURL_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_resourceURL + '")';
+                message += '\n' + obj_resourceURL_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_resourceURL_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
         }
-        const obj_version = obj.version;
-        const path_version = path + '.version';
-        if (typeof obj_version !== 'string') {
-            return new TypeError('Expected "string" but received "' + typeof obj_version + '" (at "' + path_version + '")');
+        const obj_sourceContentKeyOrId = obj.sourceContentKeyOrId;
+        const path_sourceContentKeyOrId = path + '.sourceContentKeyOrId';
+        if (typeof obj_sourceContentKeyOrId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_sourceContentKeyOrId + '" (at "' + path_sourceContentKeyOrId + '")');
         }
-        const obj_versionNumber = obj.versionNumber;
-        const path_versionNumber = path + '.versionNumber';
-        let obj_versionNumber_union0 = null;
-        const obj_versionNumber_union0_error = (() => {
-            if (typeof obj_versionNumber !== 'string') {
-                return new TypeError('Expected "string" but received "' + typeof obj_versionNumber + '" (at "' + path_versionNumber + '")');
+        if (obj.title !== undefined) {
+            const obj_title = obj.title;
+            const path_title = path + '.title';
+            let obj_title_union0 = null;
+            const obj_title_union0_error = (() => {
+                if (typeof obj_title !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_title + '" (at "' + path_title + '")');
+                }
+            })();
+            if (obj_title_union0_error != null) {
+                obj_title_union0 = obj_title_union0_error.message;
+            }
+            let obj_title_union1 = null;
+            const obj_title_union1_error = (() => {
+                if (obj_title !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_title + '" (at "' + path_title + '")');
+                }
+            })();
+            if (obj_title_union1_error != null) {
+                obj_title_union1 = obj_title_union1_error.message;
+            }
+            if (obj_title_union0 && obj_title_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_title + '")';
+                message += '\n' + obj_title_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_title_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
             }
-        })();
-        if (obj_versionNumber_union0_error != null) {
-            obj_versionNumber_union0 = obj_versionNumber_union0_error.message;
         }
-        let obj_versionNumber_union1 = null;
-        const obj_versionNumber_union1_error = (() => {
-            if (obj_versionNumber !== null) {
-                return new TypeError('Expected "null" but received "' + typeof obj_versionNumber + '" (at "' + path_versionNumber + '")');
+        if (obj.variants !== undefined) {
+            const obj_variants = obj.variants;
+            const path_variants = path + '.variants';
+            if (!ArrayIsArray(obj_variants)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_variants + '" (at "' + path_variants + '")');
+            }
+            for (let i = 0; i < obj_variants.length; i++) {
+                const obj_variants_item = obj_variants[i];
+                const path_variants_item = path_variants + '[' + i + ']';
+                const referencepath_variants_itemValidationError = validate$G(obj_variants_item, path_variants_item);
+                if (referencepath_variants_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match ManagedContentCloneVariantsRepresentation (at "' + path_variants_item + '")\n';
+                    message += referencepath_variants_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
             }
-        })();
-        if (obj_versionNumber_union1_error != null) {
-            obj_versionNumber_union1 = obj_versionNumber_union1_error.message;
         }
-        if (obj_versionNumber_union0 && obj_versionNumber_union1) {
-            let message = 'Object doesn\'t match union (at "' + path_versionNumber + '")';
-            message += '\n' + obj_versionNumber_union0.split('\n').map((line) => '\t' + line).join('\n');
-            message += '\n' + obj_versionNumber_union1.split('\n').map((line) => '\t' + line).join('\n');
-            return new TypeError(message);
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+const TTL$i = 100;
+const VERSION$j = "cd2506a860c4f555d401c1c68ff97158";
+function validate$E(obj, path = 'ManagedContentCloneCollectionRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_contents = obj.contents;
+        const path_contents = path + '.contents';
+        if (!ArrayIsArray(obj_contents)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_contents + '" (at "' + path_contents + '")');
+        }
+        for (let i = 0; i < obj_contents.length; i++) {
+            const obj_contents_item = obj_contents[i];
+            const path_contents_item = path_contents + '[' + i + ']';
+            const referencepath_contents_itemValidationError = validate$F(obj_contents_item, path_contents_item);
+            if (referencepath_contents_itemValidationError !== null) {
+                let message = 'Object doesn\'t match ManagedContentCloneRepresentation (at "' + path_contents_item + '")\n';
+                message += referencepath_contents_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_id = obj.id;
+        const path_id = path + '.id';
+        if (typeof obj_id !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_id + '" (at "' + path_id + '")');
         }
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$i = 'ManagedContentDocumentRepresentation';
+const RepresentationType$i = 'ManagedContentCloneCollectionRepresentation';
 function keyBuilder$D(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$i + ':' + config.content_key + ':' + config.language + ':' + config.version;
+    return keyPrefix + '::' + RepresentationType$i + ':' + config.id;
 }
 function keyBuilderFromType$8(luvio, object) {
     const keyParams = {
-        content_key: object.contentKey,
-        language: object.language,
-        version: object.version
+        id: object.id
     };
     return keyBuilder$D(luvio, keyParams);
 }
 function normalize$i(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$K = function ManagedContentDocumentRepresentationSelect() {
+const select$K = function ManagedContentCloneCollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$j,
@@ -4299,7 +4798,7 @@ function equals$j(existing, incoming) {
     }
     return true;
 }
-const ingest$i = function ManagedContentDocumentRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$i = function ManagedContentCloneCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$E(input);
         if (validateError !== null) {
@@ -4327,7 +4826,7 @@ function select$J(luvio, params) {
 function getResponseCacheKeys$r(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$i(storeKeyMap, luvio, response);
 }
-function ingestSuccess$r(luvio, resourceParams, response) {
+function ingestSuccess$q(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$8(luvio, body);
     luvio.storeIngest(key, ingest$i, body);
@@ -4348,7 +4847,7 @@ function createResourceRequest$r(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
-        basePath: '/connect/cms/contents',
+        basePath: '/connect/cms/contents/clone',
         method: 'post',
         body: config.body,
         urlParams: {},
@@ -4358,25 +4857,28 @@ function createResourceRequest$r(config) {
     };
 }
 
-function ingestSuccess$q(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$r(luvio, resourceParams, response);
-}
-
-const adapterName$r = 'createManagedContent';
-const createManagedContent_ConfigPropertyMetadata = [
-    generateParamConfigMetadata('ManagedContentInputParam', true, 2 /* Body */, 4 /* Unsupported */),
+const adapterName$r = 'cloneManagedContents';
+const cloneManagedContents_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('contents', true, 2 /* Body */, 4 /* Unsupported */, true),
+    generateParamConfigMetadata('includeVariants', false, 2 /* Body */, 1 /* Boolean */),
+    generateParamConfigMetadata('targetContentSpaceOrFolderId', false, 2 /* Body */, 0 /* String */),
 ];
-const createManagedContent_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$r, createManagedContent_ConfigPropertyMetadata);
-const createResourceParams$r = /*#__PURE__*/ createResourceParams$B(createManagedContent_ConfigPropertyMetadata);
+const cloneManagedContents_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$r, cloneManagedContents_ConfigPropertyMetadata);
+const createResourceParams$r = /*#__PURE__*/ createResourceParams$C(cloneManagedContents_ConfigPropertyMetadata);
 function typeCheckConfig$r(untrustedConfig) {
     const config = {};
-    const untrustedConfig_ManagedContentInputParam = untrustedConfig.ManagedContentInputParam;
-    const referenceManagedContentInputRepresentationValidationError = validate$I(untrustedConfig_ManagedContentInputParam);
-    if (referenceManagedContentInputRepresentationValidationError === null) {
-        config.ManagedContentInputParam = untrustedConfig_ManagedContentInputParam;
+    typeCheckConfig$C(untrustedConfig, config, cloneManagedContents_ConfigPropertyMetadata);
+    const untrustedConfig_contents = untrustedConfig.contents;
+    if (ArrayIsArray$1(untrustedConfig_contents)) {
+        const untrustedConfig_contents_array = [];
+        for (let i = 0, arrayLength = untrustedConfig_contents.length; i < arrayLength; i++) {
+            const untrustedConfig_contents_item = untrustedConfig_contents[i];
+            const referenceManagedContentCloneItemRepresentationValidationError = validate$J(untrustedConfig_contents_item);
+            if (referenceManagedContentCloneItemRepresentationValidationError === null) {
+                untrustedConfig_contents_array.push(untrustedConfig_contents_item);
+            }
+        }
+        config.contents = untrustedConfig_contents_array;
     }
     return config;
 }
@@ -4411,12 +4913,12 @@ function buildNetworkSnapshot$r(luvio, config, options) {
         throw response;
     });
 }
-const createManagedContentAdapterFactory = (luvio) => {
-    return function createManagedContent(untrustedConfig) {
-        const config = validateAdapterConfig$r(untrustedConfig, createManagedContent_ConfigPropertyNames);
+const cloneManagedContentsAdapterFactory = (luvio) => {
+    return function cloneManagedContents(untrustedConfig) {
+        const config = validateAdapterConfig$r(untrustedConfig, cloneManagedContents_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error('Invalid config for "createManagedContent"');
+            throw new Error('Invalid config for "cloneManagedContents"');
         }
         return buildNetworkSnapshot$r(luvio, config);
     };
@@ -4631,7 +5133,7 @@ const publishManagedContent_ConfigPropertyMetadata = [
     generateParamConfigMetadata('publishInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const publishManagedContent_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$q, publishManagedContent_ConfigPropertyMetadata);
-const createResourceParams$q = /*#__PURE__*/ createResourceParams$B(publishManagedContent_ConfigPropertyMetadata);
+const createResourceParams$q = /*#__PURE__*/ createResourceParams$C(publishManagedContent_ConfigPropertyMetadata);
 function typeCheckConfig$q(untrustedConfig) {
     const config = {};
     const untrustedConfig_publishInput = untrustedConfig.publishInput;
@@ -4885,7 +5387,7 @@ const unpublishManagedContent_ConfigPropertyMetadata = [
     generateParamConfigMetadata('unpublishInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const unpublishManagedContent_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$p, unpublishManagedContent_ConfigPropertyMetadata);
-const createResourceParams$p = /*#__PURE__*/ createResourceParams$B(unpublishManagedContent_ConfigPropertyMetadata);
+const createResourceParams$p = /*#__PURE__*/ createResourceParams$C(unpublishManagedContent_ConfigPropertyMetadata);
 function typeCheckConfig$p(untrustedConfig) {
     const config = {};
     const untrustedConfig_unpublishInput = untrustedConfig.unpublishInput;
@@ -5012,7 +5514,7 @@ function validate$y(obj, path = 'ManagedContentVariantRepresentation') {
         }
         const obj_contentSpace = obj.contentSpace;
         const path_contentSpace = path + '.contentSpace';
-        const referencepath_contentSpaceValidationError = validate$H(obj_contentSpace, path_contentSpace);
+        const referencepath_contentSpaceValidationError = validate$N(obj_contentSpace, path_contentSpace);
         if (referencepath_contentSpaceValidationError !== null) {
             let message = 'Object doesn\'t match ManagedContentSpaceSummaryRepresentation (at "' + path_contentSpace + '")\n';
             message += referencepath_contentSpaceValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -5020,7 +5522,7 @@ function validate$y(obj, path = 'ManagedContentVariantRepresentation') {
         }
         const obj_contentType = obj.contentType;
         const path_contentType = path + '.contentType';
-        const referencepath_contentTypeValidationError = validate$12(obj_contentType, path_contentType);
+        const referencepath_contentTypeValidationError = validate$18(obj_contentType, path_contentType);
         if (referencepath_contentTypeValidationError !== null) {
             let message = 'Object doesn\'t match ManagedContentTypeSummaryRepresentation (at "' + path_contentType + '")\n';
             message += referencepath_contentTypeValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -5028,7 +5530,7 @@ function validate$y(obj, path = 'ManagedContentVariantRepresentation') {
         }
         const obj_createdBy = obj.createdBy;
         const path_createdBy = path + '.createdBy';
-        const referencepath_createdByValidationError = validate$$(obj_createdBy, path_createdBy);
+        const referencepath_createdByValidationError = validate$15(obj_createdBy, path_createdBy);
         if (referencepath_createdByValidationError !== null) {
             let message = 'Object doesn\'t match ManagedContentUserSummaryRepresentation (at "' + path_createdBy + '")\n';
             message += referencepath_createdByValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -5041,7 +5543,7 @@ function validate$y(obj, path = 'ManagedContentVariantRepresentation') {
         }
         const obj_folder = obj.folder;
         const path_folder = path + '.folder';
-        const referencepath_folderValidationError = validate$G(obj_folder, path_folder);
+        const referencepath_folderValidationError = validate$M(obj_folder, path_folder);
         if (referencepath_folderValidationError !== null) {
             let message = 'Object doesn\'t match ManagedContentFolderSummaryRepresentation (at "' + path_folder + '")\n';
             message += referencepath_folderValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -5059,7 +5561,7 @@ function validate$y(obj, path = 'ManagedContentVariantRepresentation') {
         }
         const obj_lastModifiedBy = obj.lastModifiedBy;
         const path_lastModifiedBy = path + '.lastModifiedBy';
-        const referencepath_lastModifiedByValidationError = validate$$(obj_lastModifiedBy, path_lastModifiedBy);
+        const referencepath_lastModifiedByValidationError = validate$15(obj_lastModifiedBy, path_lastModifiedBy);
         if (referencepath_lastModifiedByValidationError !== null) {
             let message = 'Object doesn\'t match ManagedContentUserSummaryRepresentation (at "' + path_lastModifiedBy + '")\n';
             message += referencepath_lastModifiedByValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -5087,7 +5589,7 @@ function validate$y(obj, path = 'ManagedContentVariantRepresentation') {
         }
         const obj_status = obj.status;
         const path_status = path + '.status';
-        const referencepath_statusValidationError = validate$F(obj_status, path_status);
+        const referencepath_statusValidationError = validate$L(obj_status, path_status);
         if (referencepath_statusValidationError !== null) {
             let message = 'Object doesn\'t match ManagedContentVariantStatusRepresentation (at "' + path_status + '")\n';
             message += referencepath_statusValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -5197,7 +5699,7 @@ const createManagedContentVariant_ConfigPropertyMetadata = [
     generateParamConfigMetadata('managedContentVariantInputParam', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const createManagedContentVariant_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$o, createManagedContentVariant_ConfigPropertyMetadata);
-const createResourceParams$o = /*#__PURE__*/ createResourceParams$B(createManagedContentVariant_ConfigPropertyMetadata);
+const createResourceParams$o = /*#__PURE__*/ createResourceParams$C(createManagedContentVariant_ConfigPropertyMetadata);
 function typeCheckConfig$o(untrustedConfig) {
     const config = {};
     const untrustedConfig_managedContentVariantInputParam = untrustedConfig.managedContentVariantInputParam;
@@ -5285,10 +5787,10 @@ const deleteManagedContentVariant_ConfigPropertyMetadata = [
     generateParamConfigMetadata('variantId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const deleteManagedContentVariant_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$n, deleteManagedContentVariant_ConfigPropertyMetadata);
-const createResourceParams$n = /*#__PURE__*/ createResourceParams$B(deleteManagedContentVariant_ConfigPropertyMetadata);
+const createResourceParams$n = /*#__PURE__*/ createResourceParams$C(deleteManagedContentVariant_ConfigPropertyMetadata);
 function typeCheckConfig$n(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, deleteManagedContentVariant_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, deleteManagedContentVariant_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$n(untrustedConfig, configPropertyNames) {
@@ -5392,14 +5894,14 @@ const getManagedContentVariant_ConfigPropertyMetadata = [
     generateParamConfigMetadata('variantId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getManagedContentVariant_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$m, getManagedContentVariant_ConfigPropertyMetadata);
-const createResourceParams$m = /*#__PURE__*/ createResourceParams$B(getManagedContentVariant_ConfigPropertyMetadata);
+const createResourceParams$m = /*#__PURE__*/ createResourceParams$C(getManagedContentVariant_ConfigPropertyMetadata);
 function keyBuilder$x(luvio, config) {
     const resourceParams = createResourceParams$m(config);
     return keyBuilder$y(luvio, resourceParams);
 }
 function typeCheckConfig$m(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getManagedContentVariant_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, getManagedContentVariant_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$m(untrustedConfig, configPropertyNames) {
@@ -5553,10 +6055,10 @@ const replaceManagedContentVariant_ConfigPropertyMetadata = [
     generateParamConfigMetadata('ManagedContentVariantInputParam', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const replaceManagedContentVariant_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$l, replaceManagedContentVariant_ConfigPropertyMetadata);
-const createResourceParams$l = /*#__PURE__*/ createResourceParams$B(replaceManagedContentVariant_ConfigPropertyMetadata);
+const createResourceParams$l = /*#__PURE__*/ createResourceParams$C(replaceManagedContentVariant_ConfigPropertyMetadata);
 function typeCheckConfig$l(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, replaceManagedContentVariant_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, replaceManagedContentVariant_ConfigPropertyMetadata);
     const untrustedConfig_ManagedContentVariantInputParam = untrustedConfig.ManagedContentVariantInputParam;
     const referenceManagedContentVariantUpdateInputRepresentationValidationError = validate$x(untrustedConfig_ManagedContentVariantInputParam);
     if (referenceManagedContentVariantUpdateInputRepresentationValidationError === null) {
@@ -5613,7 +6115,7 @@ function validate$w(obj, path = 'ManagedContentVariantVersionRepresentation') {
         }
         const obj_createdBy = obj.createdBy;
         const path_createdBy = path + '.createdBy';
-        const referencepath_createdByValidationError = validate$$(obj_createdBy, path_createdBy);
+        const referencepath_createdByValidationError = validate$15(obj_createdBy, path_createdBy);
         if (referencepath_createdByValidationError !== null) {
             let message = 'Object doesn\'t match ManagedContentUserSummaryRepresentation (at "' + path_createdBy + '")\n';
             message += referencepath_createdByValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -5626,7 +6128,7 @@ function validate$w(obj, path = 'ManagedContentVariantVersionRepresentation') {
         }
         const obj_lastModifiedBy = obj.lastModifiedBy;
         const path_lastModifiedBy = path + '.lastModifiedBy';
-        const referencepath_lastModifiedByValidationError = validate$$(obj_lastModifiedBy, path_lastModifiedBy);
+        const referencepath_lastModifiedByValidationError = validate$15(obj_lastModifiedBy, path_lastModifiedBy);
         if (referencepath_lastModifiedByValidationError !== null) {
             let message = 'Object doesn\'t match ManagedContentUserSummaryRepresentation (at "' + path_lastModifiedBy + '")\n';
             message += referencepath_lastModifiedByValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -5644,7 +6146,7 @@ function validate$w(obj, path = 'ManagedContentVariantVersionRepresentation') {
         }
         const obj_status = obj.status;
         const path_status = path + '.status';
-        const referencepath_statusValidationError = validate$F(obj_status, path_status);
+        const referencepath_statusValidationError = validate$L(obj_status, path_status);
         if (referencepath_statusValidationError !== null) {
             let message = 'Object doesn\'t match ManagedContentVariantStatusRepresentation (at "' + path_status + '")\n';
             message += referencepath_statusValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -5817,14 +6319,14 @@ const getManagedContentVariantVersions_ConfigPropertyMetadata = [
     generateParamConfigMetadata('status', false, 1 /* QueryParameter */, 0 /* String */, true),
 ];
 const getManagedContentVariantVersions_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$k, getManagedContentVariantVersions_ConfigPropertyMetadata);
-const createResourceParams$k = /*#__PURE__*/ createResourceParams$B(getManagedContentVariantVersions_ConfigPropertyMetadata);
+const createResourceParams$k = /*#__PURE__*/ createResourceParams$C(getManagedContentVariantVersions_ConfigPropertyMetadata);
 function keyBuilder$u(luvio, config) {
     const resourceParams = createResourceParams$k(config);
     return keyBuilder$v(luvio, resourceParams);
 }
 function typeCheckConfig$k(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getManagedContentVariantVersions_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, getManagedContentVariantVersions_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$k(untrustedConfig, configPropertyNames) {
@@ -6137,10 +6639,10 @@ const updateManagedContentWebUrl_ConfigPropertyMetadata = [
     generateParamConfigMetadata('urlAlias', false, 2 /* Body */, 0 /* String */),
 ];
 const updateManagedContentWebUrl_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$j, updateManagedContentWebUrl_ConfigPropertyMetadata);
-const createResourceParams$j = /*#__PURE__*/ createResourceParams$B(updateManagedContentWebUrl_ConfigPropertyMetadata);
+const createResourceParams$j = /*#__PURE__*/ createResourceParams$C(updateManagedContentWebUrl_ConfigPropertyMetadata);
 function typeCheckConfig$j(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, updateManagedContentWebUrl_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, updateManagedContentWebUrl_ConfigPropertyMetadata);
     const untrustedConfig_redirectInfo = untrustedConfig.redirectInfo;
     const referenceManagedContentWebUrlRedirectInfoInputRepresentationValidationError = validate$u(untrustedConfig_redirectInfo);
     if (referenceManagedContentWebUrlRedirectInfoInputRepresentationValidationError === null) {
@@ -6191,22 +6693,22 @@ const updateManagedContentWebUrlAdapterFactory = (luvio) => {
 };
 
 function select$w(luvio, params) {
-    return select$K();
+    return select$M();
 }
 function keyBuilder$s(luvio, params) {
-    return keyBuilder$D(luvio, {
+    return keyBuilder$E(luvio, {
         content_key: params.urlParams.contentKeyOrId,
         language: params.queryParams.language || '',
         version: params.queryParams.version || ''
     });
 }
 function getResponseCacheKeys$i(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$i(storeKeyMap, luvio, response);
+    getTypeCacheKeys$j(storeKeyMap, luvio, response);
 }
 function ingestSuccess$i(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
     const key = keyBuilder$s(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$i, body);
+    luvio.storeIngest(key, ingest$j, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
         node: select$w(),
@@ -6224,10 +6726,10 @@ function ingestError$c(luvio, params, error, snapshotRefresh) {
     const key = keyBuilder$s(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$i,
+        ttl: TTL$j,
         namespace: keyPrefix,
-        version: VERSION$j,
-        representationName: RepresentationType$i
+        version: VERSION$k,
+        representationName: RepresentationType$j
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
@@ -6305,14 +6807,14 @@ const getManagedContent_ConfigPropertyMetadata = [
     generateParamConfigMetadata('version', false, 1 /* QueryParameter */, 0 /* String */),
 ];
 const getManagedContent_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$i, getManagedContent_ConfigPropertyMetadata);
-const createResourceParams$i = /*#__PURE__*/ createResourceParams$B(getManagedContent_ConfigPropertyMetadata);
+const createResourceParams$i = /*#__PURE__*/ createResourceParams$C(getManagedContent_ConfigPropertyMetadata);
 function keyBuilder$r(luvio, config) {
     const resourceParams = createResourceParams$i(config);
     return keyBuilder$s(luvio, resourceParams);
 }
 function typeCheckConfig$i(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getManagedContent_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, getManagedContent_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$i(untrustedConfig, configPropertyNames) {
@@ -6540,14 +7042,14 @@ const getManagedContentVariantRendition_ConfigPropertyMetadata = [
     generateParamConfigMetadata('version', false, 1 /* QueryParameter */, 0 /* String */),
 ];
 const getManagedContentVariantRendition_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$h, getManagedContentVariantRendition_ConfigPropertyMetadata);
-const createResourceParams$h = /*#__PURE__*/ createResourceParams$B(getManagedContentVariantRendition_ConfigPropertyMetadata);
+const createResourceParams$h = /*#__PURE__*/ createResourceParams$C(getManagedContentVariantRendition_ConfigPropertyMetadata);
 function keyBuilder$p(luvio, config) {
     const resourceParams = createResourceParams$h(config);
     return keyBuilder$q(luvio, resourceParams);
 }
 function typeCheckConfig$h(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getManagedContentVariantRendition_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, getManagedContentVariantRendition_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$h(untrustedConfig, configPropertyNames) {
@@ -6745,14 +7247,14 @@ const getWebUrls_ConfigPropertyMetadata = [
     generateParamConfigMetadata('pageSize', false, 1 /* QueryParameter */, 3 /* Integer */),
 ];
 const getWebUrls_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$g, getWebUrls_ConfigPropertyMetadata);
-const createResourceParams$g = /*#__PURE__*/ createResourceParams$B(getWebUrls_ConfigPropertyMetadata);
+const createResourceParams$g = /*#__PURE__*/ createResourceParams$C(getWebUrls_ConfigPropertyMetadata);
 function keyBuilder$n(luvio, config) {
     const resourceParams = createResourceParams$g(config);
     return keyBuilder$o(luvio, resourceParams);
 }
 function typeCheckConfig$g(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getWebUrls_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, getWebUrls_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$g(untrustedConfig, configPropertyNames) {
@@ -6834,7 +7336,7 @@ function validate$n(obj, path = 'AbstractManagedContentReferencedByItemRepresent
         if (obj.contentType !== undefined) {
             const obj_contentType = obj.contentType;
             const path_contentType = path + '.contentType';
-            const referencepath_contentTypeValidationError = validate$12(obj_contentType, path_contentType);
+            const referencepath_contentTypeValidationError = validate$18(obj_contentType, path_contentType);
             if (referencepath_contentTypeValidationError !== null) {
                 let message = 'Object doesn\'t match ManagedContentTypeSummaryRepresentation (at "' + path_contentType + '")\n';
                 message += referencepath_contentTypeValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -7055,14 +7557,14 @@ const getManagedContentReferencedBy_ConfigPropertyMetadata = [
     generateParamConfigMetadata('referenceType', false, 1 /* QueryParameter */, 0 /* String */),
 ];
 const getManagedContentReferencedBy_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$f, getManagedContentReferencedBy_ConfigPropertyMetadata);
-const createResourceParams$f = /*#__PURE__*/ createResourceParams$B(getManagedContentReferencedBy_ConfigPropertyMetadata);
+const createResourceParams$f = /*#__PURE__*/ createResourceParams$C(getManagedContentReferencedBy_ConfigPropertyMetadata);
 function keyBuilder$l(luvio, config) {
     const resourceParams = createResourceParams$f(config);
     return keyBuilder$m(luvio, resourceParams);
 }
 function typeCheckConfig$f(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getManagedContentReferencedBy_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, getManagedContentReferencedBy_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$f(untrustedConfig, configPropertyNames) {
@@ -7167,7 +7669,7 @@ function validate$k(obj, path = 'ManagedContentVariantReferenceDetailsRepresenta
         }
         const obj_contentType = obj.contentType;
         const path_contentType = path + '.contentType';
-        const referencepath_contentTypeValidationError = validate$12(obj_contentType, path_contentType);
+        const referencepath_contentTypeValidationError = validate$18(obj_contentType, path_contentType);
         if (referencepath_contentTypeValidationError !== null) {
             let message = 'Object doesn\'t match ManagedContentTypeSummaryRepresentation (at "' + path_contentType + '")\n';
             message += referencepath_contentTypeValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -7175,7 +7677,7 @@ function validate$k(obj, path = 'ManagedContentVariantReferenceDetailsRepresenta
         }
         const obj_createdBy = obj.createdBy;
         const path_createdBy = path + '.createdBy';
-        const referencepath_createdByValidationError = validate$$(obj_createdBy, path_createdBy);
+        const referencepath_createdByValidationError = validate$15(obj_createdBy, path_createdBy);
         if (referencepath_createdByValidationError !== null) {
             let message = 'Object doesn\'t match ManagedContentUserSummaryRepresentation (at "' + path_createdBy + '")\n';
             message += referencepath_createdByValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -7201,7 +7703,7 @@ function validate$k(obj, path = 'ManagedContentVariantReferenceDetailsRepresenta
         }
         const obj_lastModifiedBy = obj.lastModifiedBy;
         const path_lastModifiedBy = path + '.lastModifiedBy';
-        const referencepath_lastModifiedByValidationError = validate$$(obj_lastModifiedBy, path_lastModifiedBy);
+        const referencepath_lastModifiedByValidationError = validate$15(obj_lastModifiedBy, path_lastModifiedBy);
         if (referencepath_lastModifiedByValidationError !== null) {
             let message = 'Object doesn\'t match ManagedContentUserSummaryRepresentation (at "' + path_lastModifiedBy + '")\n';
             message += referencepath_lastModifiedByValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -7224,7 +7726,7 @@ function validate$k(obj, path = 'ManagedContentVariantReferenceDetailsRepresenta
         }
         const obj_status = obj.status;
         const path_status = path + '.status';
-        const referencepath_statusValidationError = validate$F(obj_status, path_status);
+        const referencepath_statusValidationError = validate$L(obj_status, path_status);
         if (referencepath_statusValidationError !== null) {
             let message = 'Object doesn\'t match ManagedContentVariantStatusRepresentation (at "' + path_status + '")\n';
             message += referencepath_statusValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -7371,14 +7873,14 @@ const getManagedContentVariantReferences_ConfigPropertyMetadata = [
     generateParamConfigMetadata('variantIds', false, 1 /* QueryParameter */, 0 /* String */, true),
 ];
 const getManagedContentVariantReferences_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$e, getManagedContentVariantReferences_ConfigPropertyMetadata);
-const createResourceParams$e = /*#__PURE__*/ createResourceParams$B(getManagedContentVariantReferences_ConfigPropertyMetadata);
+const createResourceParams$e = /*#__PURE__*/ createResourceParams$C(getManagedContentVariantReferences_ConfigPropertyMetadata);
 function keyBuilder$j(luvio, config) {
     const resourceParams = createResourceParams$e(config);
     return keyBuilder$k(luvio, resourceParams);
 }
 function typeCheckConfig$e(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getManagedContentVariantReferences_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, getManagedContentVariantReferences_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$e(untrustedConfig, configPropertyNames) {
@@ -7603,14 +8105,14 @@ const getManagedContentSpaceFolder_ConfigPropertyMetadata = [
     generateParamConfigMetadata('folderId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getManagedContentSpaceFolder_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$d, getManagedContentSpaceFolder_ConfigPropertyMetadata);
-const createResourceParams$d = /*#__PURE__*/ createResourceParams$B(getManagedContentSpaceFolder_ConfigPropertyMetadata);
+const createResourceParams$d = /*#__PURE__*/ createResourceParams$C(getManagedContentSpaceFolder_ConfigPropertyMetadata);
 function keyBuilder$h(luvio, config) {
     const resourceParams = createResourceParams$d(config);
     return keyBuilder$i(luvio, resourceParams);
 }
 function typeCheckConfig$d(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getManagedContentSpaceFolder_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, getManagedContentSpaceFolder_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$d(untrustedConfig, configPropertyNames) {
@@ -7699,7 +8201,7 @@ function validate$g(obj, path = 'ManagedContentSpaceFolderItemRepresentation') {
         if (obj.contentType !== undefined) {
             const obj_contentType = obj.contentType;
             const path_contentType = path + '.contentType';
-            const referencepath_contentTypeValidationError = validate$12(obj_contentType, path_contentType);
+            const referencepath_contentTypeValidationError = validate$18(obj_contentType, path_contentType);
             if (referencepath_contentTypeValidationError !== null) {
                 let message = 'Object doesn\'t match ManagedContentTypeSummaryRepresentation (at "' + path_contentType + '")\n';
                 message += referencepath_contentTypeValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -7953,14 +8455,14 @@ const getManagedContentByFolderId_ConfigPropertyMetadata = [
     generateParamConfigMetadata('showPublishedOnly', false, 1 /* QueryParameter */, 1 /* Boolean */),
 ];
 const getManagedContentByFolderId_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$c, getManagedContentByFolderId_ConfigPropertyMetadata);
-const createResourceParams$c = /*#__PURE__*/ createResourceParams$B(getManagedContentByFolderId_ConfigPropertyMetadata);
+const createResourceParams$c = /*#__PURE__*/ createResourceParams$C(getManagedContentByFolderId_ConfigPropertyMetadata);
 function keyBuilder$f(luvio, config) {
     const resourceParams = createResourceParams$c(config);
     return keyBuilder$g(luvio, resourceParams);
 }
 function typeCheckConfig$c(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getManagedContentByFolderId_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, getManagedContentByFolderId_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$c(untrustedConfig, configPropertyNames) {
@@ -8041,7 +8543,7 @@ function validate$e(obj, path = 'AbstractManagedContentSearchResultRepresentatio
         }
         const obj_createdBy = obj.createdBy;
         const path_createdBy = path + '.createdBy';
-        const referencepath_createdByValidationError = validate$$(obj_createdBy, path_createdBy);
+        const referencepath_createdByValidationError = validate$15(obj_createdBy, path_createdBy);
         if (referencepath_createdByValidationError !== null) {
             let message = 'Object doesn\'t match ManagedContentUserSummaryRepresentation (at "' + path_createdBy + '")\n';
             message += referencepath_createdByValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -8054,7 +8556,7 @@ function validate$e(obj, path = 'AbstractManagedContentSearchResultRepresentatio
         }
         const obj_folder = obj.folder;
         const path_folder = path + '.folder';
-        const referencepath_folderValidationError = validate$G(obj_folder, path_folder);
+        const referencepath_folderValidationError = validate$M(obj_folder, path_folder);
         if (referencepath_folderValidationError !== null) {
             let message = 'Object doesn\'t match ManagedContentFolderSummaryRepresentation (at "' + path_folder + '")\n';
             message += referencepath_folderValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -8067,7 +8569,7 @@ function validate$e(obj, path = 'AbstractManagedContentSearchResultRepresentatio
         }
         const obj_lastModifiedBy = obj.lastModifiedBy;
         const path_lastModifiedBy = path + '.lastModifiedBy';
-        const referencepath_lastModifiedByValidationError = validate$$(obj_lastModifiedBy, path_lastModifiedBy);
+        const referencepath_lastModifiedByValidationError = validate$15(obj_lastModifiedBy, path_lastModifiedBy);
         if (referencepath_lastModifiedByValidationError !== null) {
             let message = 'Object doesn\'t match ManagedContentUserSummaryRepresentation (at "' + path_lastModifiedBy + '")\n';
             message += referencepath_lastModifiedByValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -8235,14 +8737,14 @@ const getSearchResults_ConfigPropertyMetadata = [
     generateParamConfigMetadata('scope', false, 1 /* QueryParameter */, 0 /* String */),
 ];
 const getSearchResults_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$b, getSearchResults_ConfigPropertyMetadata);
-const createResourceParams$b = /*#__PURE__*/ createResourceParams$B(getSearchResults_ConfigPropertyMetadata);
+const createResourceParams$b = /*#__PURE__*/ createResourceParams$C(getSearchResults_ConfigPropertyMetadata);
 function keyBuilder$d(luvio, config) {
     const resourceParams = createResourceParams$b(config);
     return keyBuilder$e(luvio, resourceParams);
 }
 function typeCheckConfig$b(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getSearchResults_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, getSearchResults_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$b(untrustedConfig, configPropertyNames) {
@@ -8317,15 +8819,15 @@ const getSearchResultsAdapterFactory = (luvio) => function CMSAuthoring__getSear
 };
 
 function select$h(luvio, params) {
-    return select$13();
+    return select$15();
 }
 function getResponseCacheKeys$a(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$s(storeKeyMap, luvio, response);
+    getTypeCacheKeys$t(storeKeyMap, luvio, response);
 }
 function ingestSuccess$a(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$d(luvio, body);
-    luvio.storeIngest(key, ingest$s, body);
+    const key = keyBuilderFromType$e(luvio, body);
+    luvio.storeIngest(key, ingest$t, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
         node: select$h(),
@@ -8366,10 +8868,10 @@ const createSchedule_ConfigPropertyMetadata = [
     generateParamConfigMetadata('versionIds', false, 2 /* Body */, 0 /* String */, true),
 ];
 const createSchedule_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$a, createSchedule_ConfigPropertyMetadata);
-const createResourceParams$a = /*#__PURE__*/ createResourceParams$B(createSchedule_ConfigPropertyMetadata);
+const createResourceParams$a = /*#__PURE__*/ createResourceParams$C(createSchedule_ConfigPropertyMetadata);
 function typeCheckConfig$a(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, createSchedule_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, createSchedule_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$a(untrustedConfig, configPropertyNames) {
@@ -8415,15 +8917,15 @@ const createScheduleAdapterFactory = (luvio) => {
 };
 
 function select$g(luvio, params) {
-    return select$13();
+    return select$15();
 }
 function getResponseCacheKeys$9(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$s(storeKeyMap, luvio, response);
+    getTypeCacheKeys$t(storeKeyMap, luvio, response);
 }
 function ingestSuccess$9(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$d(luvio, body);
-    luvio.storeIngest(key, ingest$s, body);
+    const key = keyBuilderFromType$e(luvio, body);
+    luvio.storeIngest(key, ingest$t, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
         node: select$g(),
@@ -8458,10 +8960,10 @@ const updateDeployment_ConfigPropertyMetadata = [
     generateParamConfigMetadata('scheduleDate', false, 1 /* QueryParameter */, 0 /* String */),
 ];
 const updateDeployment_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$9, updateDeployment_ConfigPropertyMetadata);
-const createResourceParams$9 = /*#__PURE__*/ createResourceParams$B(updateDeployment_ConfigPropertyMetadata);
+const createResourceParams$9 = /*#__PURE__*/ createResourceParams$C(updateDeployment_ConfigPropertyMetadata);
 function typeCheckConfig$9(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, updateDeployment_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, updateDeployment_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
@@ -8868,14 +9370,14 @@ const getManagedContentSpaces_ConfigPropertyMetadata = [
     generateParamConfigMetadata('nameFragment', false, 1 /* QueryParameter */, 0 /* String */),
 ];
 const getManagedContentSpaces_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$8, getManagedContentSpaces_ConfigPropertyMetadata);
-const createResourceParams$8 = /*#__PURE__*/ createResourceParams$B(getManagedContentSpaces_ConfigPropertyMetadata);
+const createResourceParams$8 = /*#__PURE__*/ createResourceParams$C(getManagedContentSpaces_ConfigPropertyMetadata);
 function keyBuilder$a(luvio, config) {
     const resourceParams = createResourceParams$8(config);
     return keyBuilder$b(luvio, resourceParams);
 }
 function typeCheckConfig$8(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getManagedContentSpaces_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, getManagedContentSpaces_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
@@ -9008,14 +9510,14 @@ const getManagedContentSpace_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contentSpaceId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getManagedContentSpace_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$7, getManagedContentSpace_ConfigPropertyMetadata);
-const createResourceParams$7 = /*#__PURE__*/ createResourceParams$B(getManagedContentSpace_ConfigPropertyMetadata);
+const createResourceParams$7 = /*#__PURE__*/ createResourceParams$C(getManagedContentSpace_ConfigPropertyMetadata);
 function keyBuilder$8(luvio, config) {
     const resourceParams = createResourceParams$7(config);
     return keyBuilder$9(luvio, resourceParams);
 }
 function typeCheckConfig$7(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getManagedContentSpace_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, getManagedContentSpace_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
@@ -9225,10 +9727,10 @@ const patchManagedContentSpace_ConfigPropertyMetadata = [
     generateParamConfigMetadata('ManagedContentSpaceInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const patchManagedContentSpace_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$6, patchManagedContentSpace_ConfigPropertyMetadata);
-const createResourceParams$6 = /*#__PURE__*/ createResourceParams$B(patchManagedContentSpace_ConfigPropertyMetadata);
+const createResourceParams$6 = /*#__PURE__*/ createResourceParams$C(patchManagedContentSpace_ConfigPropertyMetadata);
 function typeCheckConfig$6(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, patchManagedContentSpace_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, patchManagedContentSpace_ConfigPropertyMetadata);
     const untrustedConfig_ManagedContentSpaceInput = untrustedConfig.ManagedContentSpaceInput;
     const referenceManagedContentSpaceInputRepresentationValidationError = validate$9(untrustedConfig_ManagedContentSpaceInput);
     if (referenceManagedContentSpaceInputRepresentationValidationError === null) {
@@ -9452,14 +9954,14 @@ const getManagedContentSpaceOrchestratorConfig_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contentSpaceId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getManagedContentSpaceOrchestratorConfig_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, getManagedContentSpaceOrchestratorConfig_ConfigPropertyMetadata);
-const createResourceParams$5 = /*#__PURE__*/ createResourceParams$B(getManagedContentSpaceOrchestratorConfig_ConfigPropertyMetadata);
+const createResourceParams$5 = /*#__PURE__*/ createResourceParams$C(getManagedContentSpaceOrchestratorConfig_ConfigPropertyMetadata);
 function keyBuilder$5(luvio, config) {
     const resourceParams = createResourceParams$5(config);
     return keyBuilder$6(luvio, resourceParams);
 }
 function typeCheckConfig$5(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getManagedContentSpaceOrchestratorConfig_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, getManagedContentSpaceOrchestratorConfig_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
@@ -9597,10 +10099,10 @@ const putManagedContentSpaceOrchestratorConfig_ConfigPropertyMetadata = [
     generateParamConfigMetadata('mContentOrchConfigInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const putManagedContentSpaceOrchestratorConfig_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, putManagedContentSpaceOrchestratorConfig_ConfigPropertyMetadata);
-const createResourceParams$4 = /*#__PURE__*/ createResourceParams$B(putManagedContentSpaceOrchestratorConfig_ConfigPropertyMetadata);
+const createResourceParams$4 = /*#__PURE__*/ createResourceParams$C(putManagedContentSpaceOrchestratorConfig_ConfigPropertyMetadata);
 function typeCheckConfig$4(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, putManagedContentSpaceOrchestratorConfig_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, putManagedContentSpaceOrchestratorConfig_ConfigPropertyMetadata);
     const untrustedConfig_mContentOrchConfigInput = untrustedConfig.mContentOrchConfigInput;
     const referenceManagedContentOrchestratorConfigInputRepresentationValidationError = validate$6(untrustedConfig_mContentOrchConfigInput);
     if (referenceManagedContentOrchestratorConfigInputRepresentationValidationError === null) {
@@ -9665,7 +10167,7 @@ function validate$5(obj, path = 'ManagedContentTypeSummaryCollectionRepresentati
         for (let i = 0; i < obj_contentTypes.length; i++) {
             const obj_contentTypes_item = obj_contentTypes[i];
             const path_contentTypes_item = path_contentTypes + '[' + i + ']';
-            const referencepath_contentTypes_itemValidationError = validate$12(obj_contentTypes_item, path_contentTypes_item);
+            const referencepath_contentTypes_itemValidationError = validate$18(obj_contentTypes_item, path_contentTypes_item);
             if (referencepath_contentTypes_itemValidationError !== null) {
                 let message = 'Object doesn\'t match ManagedContentTypeSummaryRepresentation (at "' + path_contentTypes_item + '")\n';
                 message += referencepath_contentTypes_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -9685,7 +10187,7 @@ function normalize$2(input, existing, path, luvio, store, timestamp) {
     return input;
 }
 const select$7 = function ManagedContentTypeSummaryCollectionRepresentationSelect() {
-    const { selections: ManagedContentTypeSummaryRepresentation__selections, opaque: ManagedContentTypeSummaryRepresentation__opaque, } = select$17();
+    const { selections: ManagedContentTypeSummaryRepresentation__selections, opaque: ManagedContentTypeSummaryRepresentation__opaque, } = select$19();
     return {
         kind: 'Fragment',
         version: VERSION$3,
@@ -9713,7 +10215,7 @@ function equals$3(existing, incoming) {
     const existing_contentTypes = existing.contentTypes;
     const incoming_contentTypes = incoming.contentTypes;
     const equals_contentTypes_items = equalsArray(existing_contentTypes, incoming_contentTypes, (existing_contentTypes_item, incoming_contentTypes_item) => {
-        if (!(equals$z(existing_contentTypes_item, incoming_contentTypes_item))) {
+        if (!(equals$A(existing_contentTypes_item, incoming_contentTypes_item))) {
             return false;
         }
     });
@@ -9802,14 +10304,14 @@ const getManagedContentTypesForMixin_ConfigPropertyMetadata = [
     generateParamConfigMetadata('mixinFQN', false, 1 /* QueryParameter */, 0 /* String */),
 ];
 const getManagedContentTypesForMixin_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, getManagedContentTypesForMixin_ConfigPropertyMetadata);
-const createResourceParams$3 = /*#__PURE__*/ createResourceParams$B(getManagedContentTypesForMixin_ConfigPropertyMetadata);
+const createResourceParams$3 = /*#__PURE__*/ createResourceParams$C(getManagedContentTypesForMixin_ConfigPropertyMetadata);
 function keyBuilder$3(luvio, config) {
     const resourceParams = createResourceParams$3(config);
     return keyBuilder$4(luvio, resourceParams);
 }
 function typeCheckConfig$3(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getManagedContentTypesForMixin_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, getManagedContentTypesForMixin_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
@@ -10182,10 +10684,10 @@ const createManagedContentExportV2Job_ConfigPropertyMetadata = [
     generateParamConfigMetadata('managedContentV2JobRequest', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const createManagedContentExportV2Job_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, createManagedContentExportV2Job_ConfigPropertyMetadata);
-const createResourceParams$2 = /*#__PURE__*/ createResourceParams$B(createManagedContentExportV2Job_ConfigPropertyMetadata);
+const createResourceParams$2 = /*#__PURE__*/ createResourceParams$C(createManagedContentExportV2Job_ConfigPropertyMetadata);
 function typeCheckConfig$2(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, createManagedContentExportV2Job_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, createManagedContentExportV2Job_ConfigPropertyMetadata);
     const untrustedConfig_managedContentV2JobRequest = untrustedConfig.managedContentV2JobRequest;
     const referenceManagedContentExportContentV2JobRequestInputRepresentationValidationError = validate$4(untrustedConfig_managedContentV2JobRequest);
     if (referenceManagedContentExportContentV2JobRequestInputRepresentationValidationError === null) {
@@ -10302,10 +10804,10 @@ const createManagedContentImportV2Job_ConfigPropertyMetadata = [
     generateParamConfigMetadata('managedContentV2JobRequest', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const createManagedContentImportV2Job_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, createManagedContentImportV2Job_ConfigPropertyMetadata);
-const createResourceParams$1 = /*#__PURE__*/ createResourceParams$B(createManagedContentImportV2Job_ConfigPropertyMetadata);
+const createResourceParams$1 = /*#__PURE__*/ createResourceParams$C(createManagedContentImportV2Job_ConfigPropertyMetadata);
 function typeCheckConfig$1(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, createManagedContentImportV2Job_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, createManagedContentImportV2Job_ConfigPropertyMetadata);
     const untrustedConfig_managedContentV2JobRequest = untrustedConfig.managedContentV2JobRequest;
     const referenceManagedContentV2JobRequestInputRepresentationValidationError = validate$2(untrustedConfig_managedContentV2JobRequest);
     if (referenceManagedContentV2JobRequestInputRepresentationValidationError === null) {
@@ -10586,14 +11088,14 @@ const getManagedContentPreviews_ConfigPropertyMetadata = [
     generateParamConfigMetadata('managedContentTypeName', false, 1 /* QueryParameter */, 0 /* String */),
 ];
 const getManagedContentPreviews_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, getManagedContentPreviews_ConfigPropertyMetadata);
-const createResourceParams = /*#__PURE__*/ createResourceParams$B(getManagedContentPreviews_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$C(getManagedContentPreviews_ConfigPropertyMetadata);
 function keyBuilder(luvio, config) {
     const resourceParams = createResourceParams(config);
     return keyBuilder$1(luvio, resourceParams);
 }
 function typeCheckConfig(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getManagedContentPreviews_ConfigPropertyMetadata);
+    typeCheckConfig$C(untrustedConfig, config, getManagedContentPreviews_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig(untrustedConfig, configPropertyNames) {
@@ -10667,4 +11169,4 @@ const getManagedContentPreviewsAdapterFactory = (luvio) => function CMSAuthoring
     buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
 };
 
-export { createDeploymentAdapterFactory, createManagedContentAdapterFactory, createManagedContentExportV2JobAdapterFactory, createManagedContentImportV2JobAdapterFactory, createManagedContentVariantAdapterFactory, createScheduleAdapterFactory, createTranslationV2JobAdapterFactory, deleteManagedContentVariantAdapterFactory, getAllCMSJobsForSpaceAdapterFactory, getCMSJobForSpaceAdapterFactory, getCollectionItemsAdapterFactory, getDeploymentsAdapterFactory, getManagedContentAdapterFactory, getManagedContentByFolderIdAdapterFactory, getManagedContentPreviewsAdapterFactory, getManagedContentReferencedByAdapterFactory, getManagedContentSpaceAdapterFactory, getManagedContentSpaceFolderAdapterFactory, getManagedContentSpaceFolderItemsV1AdapterFactory, getManagedContentSpaceOrchestratorConfigAdapterFactory, getManagedContentSpacesAdapterFactory, getManagedContentTaxonomyTermsAdapterFactory, getManagedContentTypesForMixinAdapterFactory, getManagedContentVariantAdapterFactory, getManagedContentVariantReferencesAdapterFactory, getManagedContentVariantRenditionAdapterFactory, getManagedContentVariantVersionsAdapterFactory, getSearchResultsAdapterFactory, getWebUrlsAdapterFactory, patchManagedContentSpaceAdapterFactory, publishManagedContentAdapterFactory, putManagedContentSpaceOrchestratorConfigAdapterFactory, replaceManagedContentVariantAdapterFactory, unpublishManagedContentAdapterFactory, updateDeploymentAdapterFactory, updateManagedContentTaxonomyTermsAdapterFactory, updateManagedContentWebUrlAdapterFactory };
+export { cloneManagedContentsAdapterFactory, createDeploymentAdapterFactory, createManagedContentAdapterFactory, createManagedContentExportV2JobAdapterFactory, createManagedContentImportV2JobAdapterFactory, createManagedContentVariantAdapterFactory, createScheduleAdapterFactory, createTranslationV2JobAdapterFactory, deleteManagedContentVariantAdapterFactory, getAllCMSJobsForSpaceAdapterFactory, getCMSJobForSpaceAdapterFactory, getCollectionItemsAdapterFactory, getDeploymentsAdapterFactory, getManagedContentAdapterFactory, getManagedContentByFolderIdAdapterFactory, getManagedContentPreviewsAdapterFactory, getManagedContentReferencedByAdapterFactory, getManagedContentSpaceAdapterFactory, getManagedContentSpaceFolderAdapterFactory, getManagedContentSpaceFolderItemsV1AdapterFactory, getManagedContentSpaceOrchestratorConfigAdapterFactory, getManagedContentSpacesAdapterFactory, getManagedContentTaxonomyTermsAdapterFactory, getManagedContentTypesForMixinAdapterFactory, getManagedContentVariantAdapterFactory, getManagedContentVariantReferencesAdapterFactory, getManagedContentVariantRenditionAdapterFactory, getManagedContentVariantVersionsAdapterFactory, getSearchResultsAdapterFactory, getWebUrlsAdapterFactory, patchManagedContentSpaceAdapterFactory, publishManagedContentAdapterFactory, putManagedContentSpaceOrchestratorConfigAdapterFactory, replaceManagedContentVariantAdapterFactory, unpublishManagedContentAdapterFactory, updateDeploymentAdapterFactory, updateManagedContentTaxonomyTermsAdapterFactory, updateManagedContentWebUrlAdapterFactory };