@salesforce/lds-adapters-cms-authoring 1.289.0 → 1.291.0

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

@@ -651,7 +651,7 @@ function equals$B(existing, incoming) {
     return true;
 }
 
-const TTL$w = 100;
+const TTL$x = 100;
 const VERSION$A = "f7e3c655efe77a7c9968ade15a6029b1";
 function validate$18(obj, path = 'ManagedContentDeploymentRepresentation') {
     const v_error = (() => {
@@ -841,14 +841,14 @@ function validate$18(obj, path = 'ManagedContentDeploymentRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$x = 'ManagedContentDeploymentRepresentation';
-function keyBuilder$13(luvio, config) {
+function keyBuilder$14(luvio, config) {
     return keyPrefix + '::' + RepresentationType$x + ':' + config.id;
 }
-function keyBuilderFromType$g(luvio, object) {
+function keyBuilderFromType$h(luvio, object) {
     const keyParams = {
         id: object.deploymentId
     };
-    return keyBuilder$13(luvio, keyParams);
+    return keyBuilder$14(luvio, keyParams);
 }
 function normalize$x(input, existing, path, luvio, store, timestamp) {
     return input;
@@ -958,14 +958,14 @@ const ingest$x = function ManagedContentDeploymentRepresentationIngest(input, pa
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$g(luvio, input);
-    const ttlToUse = TTL$w;
+    const key = keyBuilderFromType$h(luvio, input);
+    const ttlToUse = TTL$x;
     ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$x, "CMSAuthoring", VERSION$A, RepresentationType$x, equals$A);
     return createLink(key);
 };
 function getTypeCacheKeys$x(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$g(luvio, input);
+    const rootKey = keyBuilderFromType$h(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
         representationName: RepresentationType$x,
@@ -973,7 +973,7 @@ function getTypeCacheKeys$x(rootKeySet, luvio, input, fullPathFactory) {
     });
 }
 
-const TTL$v = 100;
+const TTL$w = 100;
 const VERSION$z = "b2c15aa80814ecd854e68bf635879e35";
 function validate$17(obj, path = 'ManagedContentDeploymentCollectionRepresentation') {
     const v_error = (() => {
@@ -1135,7 +1135,7 @@ const ingest$w = function ManagedContentDeploymentCollectionRepresentationIngest
         }
     }
     const key = path.fullPath;
-    const ttlToUse = TTL$v;
+    const ttlToUse = TTL$w;
     ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$w, "CMSAuthoring", VERSION$z, RepresentationType$w, equals$z);
     return createLink(key);
 };
@@ -1156,15 +1156,15 @@ function getTypeCacheKeys$w(rootKeySet, luvio, input, fullPathFactory) {
 function select$1d(luvio, params) {
     return select$1e();
 }
-function keyBuilder$12(luvio, params) {
+function keyBuilder$13(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$H(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$w(storeKeyMap, luvio, response, () => keyBuilder$12(luvio, resourceParams));
+    getTypeCacheKeys$w(storeKeyMap, luvio, response, () => keyBuilder$13(luvio, resourceParams));
 }
 function ingestSuccess$H(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$12(luvio, resourceParams);
+    const key = keyBuilder$13(luvio, resourceParams);
     luvio.storeIngest(key, ingest$w, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
@@ -1180,10 +1180,10 @@ function ingestSuccess$H(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$o(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$12(luvio, params);
+    const key = keyBuilder$13(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$v,
+        ttl: TTL$w,
         namespace: keyPrefix,
         version: VERSION$z,
         representationName: RepresentationType$w
@@ -1194,7 +1194,7 @@ function ingestError$o(luvio, params, error, snapshotRefresh) {
 function createResourceRequest$H(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/cms/deployments',
         method: 'get',
         body: null,
@@ -1224,9 +1224,9 @@ const getDeployments_ConfigPropertyMetadata = [
 ];
 const getDeployments_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$H, getDeployments_ConfigPropertyMetadata);
 const createResourceParams$H = /*#__PURE__*/ createResourceParams$I(getDeployments_ConfigPropertyMetadata);
-function keyBuilder$11(luvio, config) {
+function keyBuilder$12(luvio, config) {
     const resourceParams = createResourceParams$H(config);
-    return keyBuilder$12(luvio, resourceParams);
+    return keyBuilder$13(luvio, resourceParams);
 }
 function typeCheckConfig$H(untrustedConfig) {
     const config = {};
@@ -1290,7 +1290,7 @@ function buildNetworkSnapshotCachePolicy$o(context, coercedAdapterRequestContext
 function buildCachedSnapshotCachePolicy$o(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$11(luvio, config),
+        recordId: keyBuilder$12(luvio, config),
         node: adapterFragment$o(luvio, config),
         variables: {},
     };
@@ -1402,7 +1402,7 @@ function getResponseCacheKeys$G(storeKeyMap, luvio, resourceParams, response) {
 }
 function ingestSuccess$G(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$g(luvio, body);
+    const key = keyBuilderFromType$h(luvio, body);
     luvio.storeIngest(key, ingest$x, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
@@ -1420,7 +1420,7 @@ function ingestSuccess$G(luvio, resourceParams, response) {
 function createResourceRequest$G(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/cms/deployments',
         method: 'post',
         body: config.body,
@@ -1620,7 +1620,7 @@ function equals$x(existing, incoming) {
     return true;
 }
 
-const TTL$u = 100;
+const TTL$v = 100;
 const VERSION$w = "9c2de7843d4d4e7784d56c7f83c58f0e";
 function validate$13(obj, path = 'ManagedContentV2JobDetailRepresentation') {
     const v_error = (() => {
@@ -1726,14 +1726,14 @@ function validate$13(obj, path = 'ManagedContentV2JobDetailRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$v = 'ManagedContentV2JobDetailRepresentation';
-function keyBuilder$10(luvio, config) {
+function keyBuilder$11(luvio, config) {
     return keyPrefix + '::' + RepresentationType$v + ':' + config.id;
 }
-function keyBuilderFromType$f(luvio, object) {
+function keyBuilderFromType$g(luvio, object) {
     const keyParams = {
         id: object.id
     };
-    return keyBuilder$10(luvio, keyParams);
+    return keyBuilder$11(luvio, keyParams);
 }
 function normalize$v(input, existing, path, luvio, store, timestamp) {
     return input;
@@ -1853,14 +1853,14 @@ const ingest$v = function ManagedContentV2JobDetailRepresentationIngest(input, p
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$f(luvio, input);
-    const ttlToUse = TTL$u;
+    const key = keyBuilderFromType$g(luvio, input);
+    const ttlToUse = TTL$v;
     ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$v, "CMSAuthoring", VERSION$w, RepresentationType$v, equals$w);
     return createLink(key);
 };
 function getTypeCacheKeys$v(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$f(luvio, input);
+    const rootKey = keyBuilderFromType$g(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
         representationName: RepresentationType$v,
@@ -1868,7 +1868,7 @@ function getTypeCacheKeys$v(rootKeySet, luvio, input, fullPathFactory) {
     });
 }
 
-const TTL$t = 100;
+const TTL$u = 100;
 const VERSION$v = "75cfd71e168144693d36fa16f7d8f4d0";
 function validate$12(obj, path = 'ManagedContentJobCollectionRepresentation') {
     const v_error = (() => {
@@ -2030,7 +2030,7 @@ const ingest$u = function ManagedContentJobCollectionRepresentationIngest(input,
         }
     }
     const key = path.fullPath;
-    const ttlToUse = TTL$t;
+    const ttlToUse = TTL$u;
     ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$u, "CMSAuthoring", VERSION$v, RepresentationType$u, equals$v);
     return createLink(key);
 };
@@ -2051,15 +2051,15 @@ function getTypeCacheKeys$u(rootKeySet, luvio, input, fullPathFactory) {
 function select$17(luvio, params) {
     return select$18();
 }
-function keyBuilder$$(luvio, params) {
+function keyBuilder$10(luvio, params) {
     return keyPrefix + '::ManagedContentJobCollectionRepresentation:(' + 'jobType:' + params.queryParams.jobType + ',' + 'page:' + params.queryParams.page + ',' + 'pageSize:' + params.queryParams.pageSize + ',' + 'contentSpaceId:' + params.urlParams.contentSpaceId + ')';
 }
 function getResponseCacheKeys$F(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$u(storeKeyMap, luvio, response, () => keyBuilder$$(luvio, resourceParams));
+    getTypeCacheKeys$u(storeKeyMap, luvio, response, () => keyBuilder$10(luvio, resourceParams));
 }
 function ingestSuccess$F(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$$(luvio, resourceParams);
+    const key = keyBuilder$10(luvio, resourceParams);
     luvio.storeIngest(key, ingest$u, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
@@ -2075,10 +2075,10 @@ function ingestSuccess$F(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$n(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$$(luvio, params);
+    const key = keyBuilder$10(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$t,
+        ttl: TTL$u,
         namespace: keyPrefix,
         version: VERSION$v,
         representationName: RepresentationType$u
@@ -2089,7 +2089,7 @@ function ingestError$n(luvio, params, error, snapshotRefresh) {
 function createResourceRequest$F(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/cms/spaces/' + config.urlParams.contentSpaceId + '/jobs',
         method: 'get',
         body: null,
@@ -2109,9 +2109,9 @@ const getAllCMSJobsForSpace_ConfigPropertyMetadata = [
 ];
 const getAllCMSJobsForSpace_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$F, getAllCMSJobsForSpace_ConfigPropertyMetadata);
 const createResourceParams$F = /*#__PURE__*/ createResourceParams$I(getAllCMSJobsForSpace_ConfigPropertyMetadata);
-function keyBuilder$_(luvio, config) {
+function keyBuilder$$(luvio, config) {
     const resourceParams = createResourceParams$F(config);
-    return keyBuilder$$(luvio, resourceParams);
+    return keyBuilder$10(luvio, resourceParams);
 }
 function typeCheckConfig$F(untrustedConfig) {
     const config = {};
@@ -2169,7 +2169,7 @@ function buildNetworkSnapshotCachePolicy$n(context, coercedAdapterRequestContext
 function buildCachedSnapshotCachePolicy$n(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$_(luvio, config),
+        recordId: keyBuilder$$(luvio, config),
         node: adapterFragment$n(luvio, config),
         variables: {},
     };
@@ -2192,8 +2192,8 @@ const getAllCMSJobsForSpaceAdapterFactory = (luvio) => function CMSAuthoring__ge
 function select$16(luvio, params) {
     return select$19();
 }
-function keyBuilder$Z(luvio, params) {
-    return keyBuilder$10(luvio, {
+function keyBuilder$_(luvio, params) {
+    return keyBuilder$11(luvio, {
         id: params.urlParams.jobId
     });
 }
@@ -2202,7 +2202,7 @@ function getResponseCacheKeys$E(storeKeyMap, luvio, resourceParams, response) {
 }
 function ingestSuccess$E(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$Z(luvio, resourceParams);
+    const key = keyBuilder$_(luvio, resourceParams);
     luvio.storeIngest(key, ingest$v, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
@@ -2218,10 +2218,10 @@ function ingestSuccess$E(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$m(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$Z(luvio, params);
+    const key = keyBuilder$_(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$u,
+        ttl: TTL$v,
         namespace: keyPrefix,
         version: VERSION$w,
         representationName: RepresentationType$v
@@ -2232,7 +2232,7 @@ function ingestError$m(luvio, params, error, snapshotRefresh) {
 function createResourceRequest$E(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/cms/spaces/' + config.urlParams.contentSpaceId + '/jobs/' + config.urlParams.jobId + '',
         method: 'get',
         body: null,
@@ -2250,9 +2250,9 @@ const getCMSJobForSpace_ConfigPropertyMetadata = [
 ];
 const getCMSJobForSpace_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$E, getCMSJobForSpace_ConfigPropertyMetadata);
 const createResourceParams$E = /*#__PURE__*/ createResourceParams$I(getCMSJobForSpace_ConfigPropertyMetadata);
-function keyBuilder$Y(luvio, config) {
+function keyBuilder$Z(luvio, config) {
     const resourceParams = createResourceParams$E(config);
-    return keyBuilder$Z(luvio, resourceParams);
+    return keyBuilder$_(luvio, resourceParams);
 }
 function typeCheckConfig$E(untrustedConfig) {
     const config = {};
@@ -2310,7 +2310,7 @@ function buildNetworkSnapshotCachePolicy$m(context, coercedAdapterRequestContext
 function buildCachedSnapshotCachePolicy$m(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$Y(luvio, config),
+        recordId: keyBuilder$Z(luvio, config),
         node: adapterFragment$m(luvio, config),
         variables: {},
     };
@@ -2418,7 +2418,7 @@ function validate$11(obj, path = 'ManagedContentSpaceFolderItemV1Representation'
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$s = 100;
+const TTL$t = 100;
 const VERSION$u = "df1370994ae2e57cdebc5f5125930e2d";
 function validate$10(obj, path = 'ManagedContentSpaceFolderItemV1CollectionRepresentation') {
     const v_error = (() => {
@@ -2500,7 +2500,7 @@ const ingest$t = function ManagedContentSpaceFolderItemV1CollectionRepresentatio
         }
     }
     const key = path.fullPath;
-    const ttlToUse = TTL$s;
+    const ttlToUse = TTL$t;
     ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$t, "CMSAuthoring", VERSION$u, RepresentationType$t, equals$u);
     return createLink(key);
 };
@@ -2517,15 +2517,15 @@ function getTypeCacheKeys$t(rootKeySet, luvio, input, fullPathFactory) {
 function select$14(luvio, params) {
     return select$15();
 }
-function keyBuilder$X(luvio, params) {
+function keyBuilder$Y(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$D(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$t(storeKeyMap, luvio, response, () => keyBuilder$X(luvio, resourceParams));
+    getTypeCacheKeys$t(storeKeyMap, luvio, response, () => keyBuilder$Y(luvio, resourceParams));
 }
 function ingestSuccess$D(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$X(luvio, resourceParams);
+    const key = keyBuilder$Y(luvio, resourceParams);
     luvio.storeIngest(key, ingest$t, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
@@ -2541,10 +2541,10 @@ function ingestSuccess$D(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$l(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$X(luvio, params);
+    const key = keyBuilder$Y(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$s,
+        ttl: TTL$t,
         namespace: keyPrefix,
         version: VERSION$u,
         representationName: RepresentationType$t
@@ -2555,7 +2555,7 @@ function ingestError$l(luvio, params, error, snapshotRefresh) {
 function createResourceRequest$D(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/cms/folders/' + config.urlParams.folderId + '/items',
         method: 'get',
         body: null,
@@ -2582,9 +2582,9 @@ const getManagedContentSpaceFolderItemsV1_ConfigPropertyMetadata = [
 ];
 const getManagedContentSpaceFolderItemsV1_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$D, getManagedContentSpaceFolderItemsV1_ConfigPropertyMetadata);
 const createResourceParams$D = /*#__PURE__*/ createResourceParams$I(getManagedContentSpaceFolderItemsV1_ConfigPropertyMetadata);
-function keyBuilder$W(luvio, config) {
+function keyBuilder$X(luvio, config) {
     const resourceParams = createResourceParams$D(config);
-    return keyBuilder$X(luvio, resourceParams);
+    return keyBuilder$Y(luvio, resourceParams);
 }
 function typeCheckConfig$D(untrustedConfig) {
     const config = {};
@@ -2642,7 +2642,7 @@ function buildNetworkSnapshotCachePolicy$l(context, coercedAdapterRequestContext
 function buildCachedSnapshotCachePolicy$l(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$W(luvio, config),
+        recordId: keyBuilder$X(luvio, config),
         node: adapterFragment$l(luvio, config),
         variables: {},
     };
@@ -2722,7 +2722,7 @@ function validate$_(obj, path = 'ManagedContentCollectionItemRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$r = 100;
+const TTL$s = 100;
 const VERSION$t = "eeea454f1268ece5c3e24c986688b876";
 function validate$Z(obj, path = 'ManagedContentCollectionDetailRepresentation') {
     const v_error = (() => {
@@ -2796,16 +2796,16 @@ function validate$Z(obj, path = 'ManagedContentCollectionDetailRepresentation')
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$s = 'ManagedContentCollectionDetailRepresentation';
-function keyBuilder$V(luvio, config) {
+function keyBuilder$W(luvio, config) {
     return keyPrefix + '::' + RepresentationType$s + ':' + config.collection_key + ':' + config.language + ':' + config.version;
 }
-function keyBuilderFromType$e(luvio, object) {
+function keyBuilderFromType$f(luvio, object) {
     const keyParams = {
         collection_key: object.collectionKey,
         language: object.language,
         version: object.versionNumber
     };
-    return keyBuilder$V(luvio, keyParams);
+    return keyBuilder$W(luvio, keyParams);
 }
 function normalize$s(input, existing, path, luvio, store, timestamp) {
     return input;
@@ -2831,14 +2831,14 @@ const ingest$s = function ManagedContentCollectionDetailRepresentationIngest(inp
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$e(luvio, input);
-    const ttlToUse = TTL$r;
+    const key = keyBuilderFromType$f(luvio, input);
+    const ttlToUse = TTL$s;
     ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$s, "CMSAuthoring", VERSION$t, RepresentationType$s, equals$t);
     return createLink(key);
 };
 function getTypeCacheKeys$s(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$e(luvio, input);
+    const rootKey = keyBuilderFromType$f(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
         representationName: RepresentationType$s,
@@ -2849,8 +2849,8 @@ function getTypeCacheKeys$s(rootKeySet, luvio, input, fullPathFactory) {
 function select$12(luvio, params) {
     return select$13();
 }
-function keyBuilder$U(luvio, params) {
-    return keyBuilder$V(luvio, {
+function keyBuilder$V(luvio, params) {
+    return keyBuilder$W(luvio, {
         collection_key: params.urlParams.collectionKeyOrId,
         language: params.queryParams.language || '',
         version: params.queryParams.version || ''
@@ -2861,7 +2861,7 @@ function getResponseCacheKeys$C(storeKeyMap, luvio, resourceParams, response) {
 }
 function ingestSuccess$C(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$U(luvio, resourceParams);
+    const key = keyBuilder$V(luvio, resourceParams);
     luvio.storeIngest(key, ingest$s, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
@@ -2877,10 +2877,10 @@ function ingestSuccess$C(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$k(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$U(luvio, params);
+    const key = keyBuilder$V(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$r,
+        ttl: TTL$s,
         namespace: keyPrefix,
         version: VERSION$t,
         representationName: RepresentationType$s
@@ -2891,7 +2891,7 @@ function ingestError$k(luvio, params, error, snapshotRefresh) {
 function createResourceRequest$C(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/collections/' + config.urlParams.collectionKeyOrId + '',
         method: 'get',
         body: null,
@@ -2925,9 +2925,9 @@ const getCollectionItems_ConfigPropertyMetadata = [
 ];
 const getCollectionItems_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$C, getCollectionItems_ConfigPropertyMetadata);
 const createResourceParams$C = /*#__PURE__*/ createResourceParams$I(getCollectionItems_ConfigPropertyMetadata);
-function keyBuilder$T(luvio, config) {
+function keyBuilder$U(luvio, config) {
     const resourceParams = createResourceParams$C(config);
-    return keyBuilder$U(luvio, resourceParams);
+    return keyBuilder$V(luvio, resourceParams);
 }
 function typeCheckConfig$C(untrustedConfig) {
     const config = {};
@@ -2985,7 +2985,7 @@ function buildNetworkSnapshotCachePolicy$k(context, coercedAdapterRequestContext
 function buildCachedSnapshotCachePolicy$k(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$T(luvio, config),
+        recordId: keyBuilder$U(luvio, config),
         node: adapterFragment$k(luvio, config),
         variables: {},
     };
@@ -3075,7 +3075,7 @@ function validate$Y(obj, path = 'ManagedContentTranslationV2RequestInputRep') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$q = 100;
+const TTL$r = 100;
 const VERSION$s = "52e643b998d6763482c6d74542b38408";
 function validate$X(obj, path = 'ManagedContentTranslationV2Representation') {
     const v_error = (() => {
@@ -3235,14 +3235,14 @@ function validate$X(obj, path = 'ManagedContentTranslationV2Representation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$r = 'ManagedContentTranslationV2Representation';
-function keyBuilder$S(luvio, config) {
+function keyBuilder$T(luvio, config) {
     return keyPrefix + '::' + RepresentationType$r + ':' + config.id;
 }
-function keyBuilderFromType$d(luvio, object) {
+function keyBuilderFromType$e(luvio, object) {
     const keyParams = {
         id: object.id
     };
-    return keyBuilder$S(luvio, keyParams);
+    return keyBuilder$T(luvio, keyParams);
 }
 function normalize$r(input, existing, path, luvio, store, timestamp) {
     return input;
@@ -3268,14 +3268,14 @@ const ingest$r = function ManagedContentTranslationV2RepresentationIngest(input,
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$d(luvio, input);
-    const ttlToUse = TTL$q;
+    const key = keyBuilderFromType$e(luvio, input);
+    const ttlToUse = TTL$r;
     ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$r, "CMSAuthoring", VERSION$s, RepresentationType$r, equals$s);
     return createLink(key);
 };
 function getTypeCacheKeys$r(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$r,
@@ -3291,7 +3291,7 @@ function getResponseCacheKeys$B(storeKeyMap, luvio, resourceParams, response) {
 }
 function ingestSuccess$B(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$d(luvio, body);
+    const key = keyBuilderFromType$e(luvio, body);
     luvio.storeIngest(key, ingest$r, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
@@ -3309,7 +3309,7 @@ function ingestSuccess$B(luvio, resourceParams, response) {
 function createResourceRequest$B(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/content/spaces/' + config.urlParams.contentSpaceId + '/translation',
         method: 'post',
         body: config.body,
@@ -3483,7 +3483,7 @@ function validate$T(obj, path = 'ManagedContentVariantStatusRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$p = 100;
+const TTL$q = 100;
 const VERSION$r = "32da7ab9bec2902e7f2b1d1e9aa618f1";
 function validate$S(obj, path = 'ManagedContentDocumentRepresentation') {
     const v_error = (() => {
@@ -3688,16 +3688,16 @@ function validate$S(obj, path = 'ManagedContentDocumentRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$q = 'ManagedContentDocumentRepresentation';
-function keyBuilder$R(luvio, config) {
+function keyBuilder$S(luvio, config) {
     return keyPrefix + '::' + RepresentationType$q + ':' + config.content_key + ':' + config.language + ':' + config.version;
 }
-function keyBuilderFromType$c(luvio, object) {
+function keyBuilderFromType$d(luvio, object) {
     const keyParams = {
         content_key: object.contentKey,
         language: object.language,
         version: object.version
     };
-    return keyBuilder$R(luvio, keyParams);
+    return keyBuilder$S(luvio, keyParams);
 }
 function normalize$q(input, existing, path, luvio, store, timestamp) {
     return input;
@@ -3723,14 +3723,14 @@ const ingest$q = function ManagedContentDocumentRepresentationIngest(input, path
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$c(luvio, input);
-    const ttlToUse = TTL$p;
+    const key = keyBuilderFromType$d(luvio, input);
+    const ttlToUse = TTL$q;
     ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$q, "CMSAuthoring", VERSION$r, RepresentationType$q, equals$r);
     return createLink(key);
 };
 function getTypeCacheKeys$q(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,
@@ -3746,7 +3746,7 @@ function getResponseCacheKeys$A(storeKeyMap, luvio, resourceParams, response) {
 }
 function ingestSuccess$A(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$c(luvio, body);
+    const key = keyBuilderFromType$d(luvio, body);
     luvio.storeIngest(key, ingest$q, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
@@ -3764,7 +3764,7 @@ function ingestSuccess$A(luvio, resourceParams, response) {
 function createResourceRequest$A(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/contents',
         method: 'post',
         body: config.body,
@@ -3839,7 +3839,7 @@ const createManagedContentAdapterFactory = (luvio) => {
     };
 };
 
-const TTL$o = 100;
+const TTL$p = 100;
 const VERSION$q = "17d0c7553970a191d9ac970ac0cd8666";
 function validate$R(obj, path = 'ManagedContentFileUploadRepresentation') {
     const v_error = (() => {
@@ -3901,7 +3901,7 @@ const ingest$p = function ManagedContentFileUploadRepresentationIngest(input, pa
         }
     }
     const key = path.fullPath;
-    const ttlToUse = TTL$o;
+    const ttlToUse = TTL$p;
     ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$p, "CMSAuthoring", VERSION$q, RepresentationType$p, equals$q);
     return createLink(key);
 };
@@ -3918,15 +3918,15 @@ function getTypeCacheKeys$p(rootKeySet, luvio, input, fullPathFactory) {
 function select$Y(luvio, params) {
     return select$Z();
 }
-function keyBuilder$Q(luvio, params) {
+function keyBuilder$R(luvio, params) {
     return keyPrefix + '::ManagedContentFileUploadRepresentation:(' + ')';
 }
 function getResponseCacheKeys$z(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$p(storeKeyMap, luvio, response, () => keyBuilder$Q());
+    getTypeCacheKeys$p(storeKeyMap, luvio, response, () => keyBuilder$R());
 }
 function ingestSuccess$y(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$Q();
+    const key = keyBuilder$R();
     luvio.storeIngest(key, ingest$p, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
@@ -3942,10 +3942,10 @@ function ingestSuccess$y(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$j(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$Q();
+    const key = keyBuilder$R();
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$o,
+        ttl: TTL$p,
         namespace: keyPrefix,
         version: VERSION$q,
         representationName: RepresentationType$p
@@ -3956,7 +3956,7 @@ function ingestError$j(luvio, params, error, snapshotRefresh) {
 function createResourceRequest$z(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/contents/file/upload',
         method: 'get',
         body: null,
@@ -3971,9 +3971,9 @@ const adapterName$z = 'getManagedContentFileUploadConfig';
 const getManagedContentFileUploadConfig_ConfigPropertyMetadata = [];
 const getManagedContentFileUploadConfig_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$z, getManagedContentFileUploadConfig_ConfigPropertyMetadata);
 const createResourceParams$z = /*#__PURE__*/ createResourceParams$I(getManagedContentFileUploadConfig_ConfigPropertyMetadata);
-function keyBuilder$P(luvio, config) {
+function keyBuilder$Q(luvio, config) {
     createResourceParams$z(config);
-    return keyBuilder$Q();
+    return keyBuilder$R();
 }
 function typeCheckConfig$z(untrustedConfig) {
     const config = {};
@@ -4030,7 +4030,7 @@ function buildNetworkSnapshotCachePolicy$j(context, coercedAdapterRequestContext
 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: {},
     };
@@ -4108,7 +4108,7 @@ function validate$Q(obj, path = 'ManagedContentPublishInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$n = 100;
+const TTL$o = 100;
 const VERSION$p = "789bce2e581ff7969982fbf2ffbfd9a5";
 function validate$P(obj, path = 'ManagedContentPublishOutputRepresentation') {
     const v_error = (() => {
@@ -4176,14 +4176,14 @@ function validate$P(obj, path = 'ManagedContentPublishOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$o = 'ManagedContentPublishOutputRepresentation';
-function keyBuilder$O(luvio, config) {
+function keyBuilder$P(luvio, config) {
     return keyPrefix + '::' + RepresentationType$o + ':' + config.id;
 }
-function keyBuilderFromType$b(luvio, object) {
+function keyBuilderFromType$c(luvio, object) {
     const keyParams = {
         id: object.deploymentId
     };
-    return keyBuilder$O(luvio, keyParams);
+    return keyBuilder$P(luvio, keyParams);
 }
 function normalize$o(input, existing, path, luvio, store, timestamp) {
     return input;
@@ -4209,14 +4209,14 @@ const ingest$o = function ManagedContentPublishOutputRepresentationIngest(input,
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$b(luvio, input);
-    const ttlToUse = TTL$n;
+    const key = keyBuilderFromType$c(luvio, input);
+    const ttlToUse = TTL$o;
     ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$o, "CMSAuthoring", VERSION$p, RepresentationType$o, equals$p);
     return createLink(key);
 };
 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$o,
@@ -4232,7 +4232,7 @@ function getResponseCacheKeys$y(storeKeyMap, luvio, resourceParams, response) {
 }
 function ingestSuccess$x(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$b(luvio, body);
+    const key = keyBuilderFromType$c(luvio, body);
     luvio.storeIngest(key, ingest$o, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
@@ -4250,7 +4250,7 @@ function ingestSuccess$x(luvio, resourceParams, response) {
 function createResourceRequest$y(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/contents/publish',
         method: 'post',
         body: config.body,
@@ -4362,7 +4362,7 @@ function validate$O(obj, path = 'ManagedContentUnpublishInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$m = 100;
+const TTL$n = 100;
 const VERSION$o = "2f473ff12e87a4fc2336695104ab8567";
 function validate$N(obj, path = 'ManagedContentUnpublishOutputRepresentation') {
     const v_error = (() => {
@@ -4430,14 +4430,14 @@ function validate$N(obj, path = 'ManagedContentUnpublishOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$n = 'ManagedContentUnpublishOutputRepresentation';
-function keyBuilder$N(luvio, config) {
+function keyBuilder$O(luvio, config) {
     return keyPrefix + '::' + RepresentationType$n + ':' + config.id;
 }
-function keyBuilderFromType$a(luvio, object) {
+function keyBuilderFromType$b(luvio, object) {
     const keyParams = {
         id: object.deploymentId
     };
-    return keyBuilder$N(luvio, keyParams);
+    return keyBuilder$O(luvio, keyParams);
 }
 function normalize$n(input, existing, path, luvio, store, timestamp) {
     return input;
@@ -4463,14 +4463,14 @@ const ingest$n = function ManagedContentUnpublishOutputRepresentationIngest(inpu
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$a(luvio, input);
-    const ttlToUse = TTL$m;
+    const key = keyBuilderFromType$b(luvio, input);
+    const ttlToUse = TTL$n;
     ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$n, "CMSAuthoring", VERSION$o, RepresentationType$n, equals$o);
     return createLink(key);
 };
 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$n,
@@ -4486,7 +4486,7 @@ function getResponseCacheKeys$x(storeKeyMap, luvio, resourceParams, response) {
 }
 function ingestSuccess$w(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$a(luvio, body);
+    const key = keyBuilderFromType$b(luvio, body);
     luvio.storeIngest(key, ingest$n, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
@@ -4504,7 +4504,7 @@ function ingestSuccess$w(luvio, resourceParams, response) {
 function createResourceRequest$x(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/contents/unpublish',
         method: 'post',
         body: config.body,
@@ -4619,7 +4619,7 @@ function validate$M(obj, path = 'ManagedContentVariantInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$l = 3600000;
+const TTL$m = 3600000;
 const VERSION$n = "7752c6a8bb6b113a02bfde83f39e5957";
 function validate$L(obj, path = 'ManagedContentVariantRepresentation') {
     const v_error = (() => {
@@ -4742,14 +4742,14 @@ function validate$L(obj, path = 'ManagedContentVariantRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$m = 'ManagedContentVariantRepresentation';
-function keyBuilder$M(luvio, config) {
+function keyBuilder$N(luvio, config) {
     return keyPrefix + '::' + RepresentationType$m + ':' + config.id;
 }
-function keyBuilderFromType$9(luvio, object) {
+function keyBuilderFromType$a(luvio, object) {
     const keyParams = {
         id: object.managedContentVariantId
     };
-    return keyBuilder$M(luvio, keyParams);
+    return keyBuilder$N(luvio, keyParams);
 }
 function normalize$m(input, existing, path, luvio, store, timestamp) {
     return input;
@@ -4775,14 +4775,14 @@ const ingest$m = function ManagedContentVariantRepresentationIngest(input, path,
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$9(luvio, input);
-    const ttlToUse = TTL$l;
+    const key = keyBuilderFromType$a(luvio, input);
+    const ttlToUse = TTL$m;
     ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$m, "CMSAuthoring", VERSION$n, RepresentationType$m, equals$n);
     return createLink(key);
 };
 function getTypeCacheKeys$m(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$m,
@@ -4798,7 +4798,7 @@ function getResponseCacheKeys$w(storeKeyMap, luvio, resourceParams, response) {
 }
 function ingestSuccess$v(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$9(luvio, body);
+    const key = keyBuilderFromType$a(luvio, body);
     luvio.storeIngest(key, ingest$m, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
@@ -4816,7 +4816,7 @@ function ingestSuccess$v(luvio, resourceParams, response) {
 function createResourceRequest$w(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/contents/variants',
         method: 'post',
         body: config.body,
@@ -4884,13 +4884,13 @@ const createManagedContentVariantAdapterFactory = (luvio) => {
     };
 };
 
-function keyBuilder$L(luvio, params) {
-    return keyBuilder$M(luvio, {
+function keyBuilder$M(luvio, params) {
+    return keyBuilder$N(luvio, {
         id: params.urlParams.variantId
     });
 }
 function getResponseCacheKeys$v(cacheKeyMap, luvio, resourceParams) {
-    const key = keyBuilder$L(luvio, resourceParams);
+    const key = keyBuilder$M(luvio, resourceParams);
     cacheKeyMap.set(key, {
         namespace: keyPrefix,
         representationName: RepresentationType$m,
@@ -4898,13 +4898,13 @@ function getResponseCacheKeys$v(cacheKeyMap, luvio, resourceParams) {
     });
 }
 function evictSuccess(luvio, resourceParams) {
-    const key = keyBuilder$L(luvio, resourceParams);
+    const key = keyBuilder$M(luvio, resourceParams);
     luvio.storeEvict(key);
 }
 function createResourceRequest$v(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/contents/variants/' + config.urlParams.variantId + '',
         method: 'delete',
         body: null,
@@ -4971,8 +4971,8 @@ const deleteManagedContentVariantAdapterFactory = (luvio) => {
 function select$R(luvio, params) {
     return select$T();
 }
-function keyBuilder$K(luvio, params) {
-    return keyBuilder$M(luvio, {
+function keyBuilder$L(luvio, params) {
+    return keyBuilder$N(luvio, {
         id: params.urlParams.variantId
     });
 }
@@ -4981,7 +4981,7 @@ function getResponseCacheKeys$u(storeKeyMap, luvio, resourceParams, response) {
 }
 function ingestSuccess$u(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$K(luvio, resourceParams);
+    const key = keyBuilder$L(luvio, resourceParams);
     luvio.storeIngest(key, ingest$m, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
@@ -4997,10 +4997,10 @@ function ingestSuccess$u(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$i(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$K(luvio, params);
+    const key = keyBuilder$L(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$l,
+        ttl: TTL$m,
         namespace: keyPrefix,
         version: VERSION$n,
         representationName: RepresentationType$m
@@ -5011,7 +5011,7 @@ function ingestError$i(luvio, params, error, snapshotRefresh) {
 function createResourceRequest$u(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/contents/variants/' + config.urlParams.variantId + '',
         method: 'get',
         body: null,
@@ -5028,9 +5028,9 @@ const getManagedContentVariant_ConfigPropertyMetadata = [
 ];
 const getManagedContentVariant_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$u, getManagedContentVariant_ConfigPropertyMetadata);
 const createResourceParams$u = /*#__PURE__*/ createResourceParams$I(getManagedContentVariant_ConfigPropertyMetadata);
-function keyBuilder$J(luvio, config) {
+function keyBuilder$K(luvio, config) {
     const resourceParams = createResourceParams$u(config);
-    return keyBuilder$K(luvio, resourceParams);
+    return keyBuilder$L(luvio, resourceParams);
 }
 function typeCheckConfig$u(untrustedConfig) {
     const config = {};
@@ -5088,7 +5088,7 @@ function buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext
 function buildCachedSnapshotCachePolicy$i(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$J(luvio, config),
+        recordId: keyBuilder$K(luvio, config),
         node: adapterFragment$i(luvio, config),
         variables: {},
     };
@@ -5153,7 +5153,7 @@ function getResponseCacheKeys$t(storeKeyMap, luvio, resourceParams, response) {
 }
 function ingestSuccess$t(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$9(luvio, body);
+    const key = keyBuilderFromType$a(luvio, body);
     luvio.storeIngest(key, ingest$m, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
@@ -5171,7 +5171,7 @@ function ingestSuccess$t(luvio, resourceParams, response) {
 function createResourceRequest$t(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/contents/variants/' + config.urlParams.variantId + '',
         method: 'put',
         body: config.body,
@@ -5299,7 +5299,7 @@ function validate$J(obj, path = 'ManagedContentVariantVersionRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$k = 100;
+const TTL$l = 100;
 const VERSION$m = "993f4fe3a5b12699f037079dbe30610b";
 function validate$I(obj, path = 'ManagedContentVariantVersionCollectionRepresentation') {
     const v_error = (() => {
@@ -5342,14 +5342,14 @@ function validate$I(obj, path = 'ManagedContentVariantVersionCollectionRepresent
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$l = 'ManagedContentVariantVersionCollectionRepresentation';
-function keyBuilder$I(luvio, config) {
+function keyBuilder$J(luvio, config) {
     return keyPrefix + '::' + RepresentationType$l + ':' + config.variantId;
 }
-function keyBuilderFromType$8(luvio, object) {
+function keyBuilderFromType$9(luvio, object) {
     const keyParams = {
         variantId: object.managedContentVariantId
     };
-    return keyBuilder$I(luvio, keyParams);
+    return keyBuilder$J(luvio, keyParams);
 }
 function normalize$l(input, existing, path, luvio, store, timestamp) {
     return input;
@@ -5375,14 +5375,14 @@ const ingest$l = function ManagedContentVariantVersionCollectionRepresentationIn
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$8(luvio, input);
-    const ttlToUse = TTL$k;
+    const key = keyBuilderFromType$9(luvio, input);
+    const ttlToUse = TTL$l;
     ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$l, "CMSAuthoring", VERSION$m, RepresentationType$l, equals$m);
     return createLink(key);
 };
 function getTypeCacheKeys$l(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$8(luvio, input);
+    const rootKey = keyBuilderFromType$9(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
         representationName: RepresentationType$l,
@@ -5393,8 +5393,8 @@ function getTypeCacheKeys$l(rootKeySet, luvio, input, fullPathFactory) {
 function select$O(luvio, params) {
     return select$P();
 }
-function keyBuilder$H(luvio, params) {
-    return keyBuilder$I(luvio, {
+function keyBuilder$I(luvio, params) {
+    return keyBuilder$J(luvio, {
         variantId: params.urlParams.variantId
     });
 }
@@ -5403,7 +5403,7 @@ function getResponseCacheKeys$s(storeKeyMap, luvio, resourceParams, response) {
 }
 function ingestSuccess$s(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$H(luvio, resourceParams);
+    const key = keyBuilder$I(luvio, resourceParams);
     luvio.storeIngest(key, ingest$l, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
@@ -5419,10 +5419,10 @@ function ingestSuccess$s(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$h(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$H(luvio, params);
+    const key = keyBuilder$I(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$k,
+        ttl: TTL$l,
         namespace: keyPrefix,
         version: VERSION$m,
         representationName: RepresentationType$l
@@ -5433,7 +5433,7 @@ function ingestError$h(luvio, params, error, snapshotRefresh) {
 function createResourceRequest$s(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/contents/variants/' + config.urlParams.variantId + '/versions',
         method: 'get',
         body: null,
@@ -5453,9 +5453,9 @@ const getManagedContentVariantVersions_ConfigPropertyMetadata = [
 ];
 const getManagedContentVariantVersions_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$s, getManagedContentVariantVersions_ConfigPropertyMetadata);
 const createResourceParams$s = /*#__PURE__*/ createResourceParams$I(getManagedContentVariantVersions_ConfigPropertyMetadata);
-function keyBuilder$G(luvio, config) {
+function keyBuilder$H(luvio, config) {
     const resourceParams = createResourceParams$s(config);
-    return keyBuilder$H(luvio, resourceParams);
+    return keyBuilder$I(luvio, resourceParams);
 }
 function typeCheckConfig$s(untrustedConfig) {
     const config = {};
@@ -5513,7 +5513,7 @@ function buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext
 function buildCachedSnapshotCachePolicy$h(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$G(luvio, config),
+        recordId: keyBuilder$H(luvio, config),
         node: adapterFragment$h(luvio, config),
         variables: {},
     };
@@ -5625,7 +5625,7 @@ function validate$E(obj, path = 'ManagedContentWebUrlInfoRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$j = 100;
+const TTL$k = 100;
 const VERSION$l = "e55a316362ca4e75b43fa6c9c1b8a065";
 function validate$D(obj, path = 'ManagedContentWebUrlRepresentation') {
     const v_error = (() => {
@@ -5679,14 +5679,14 @@ function validate$D(obj, path = 'ManagedContentWebUrlRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$k = 'ManagedContentWebUrlRepresentation';
-function keyBuilder$F(luvio, config) {
+function keyBuilder$G(luvio, config) {
     return keyPrefix + '::' + RepresentationType$k + ':' + config.managedContentWebUrlId;
 }
-function keyBuilderFromType$7(luvio, object) {
+function keyBuilderFromType$8(luvio, object) {
     const keyParams = {
         managedContentWebUrlId: object.id
     };
-    return keyBuilder$F(luvio, keyParams);
+    return keyBuilder$G(luvio, keyParams);
 }
 function normalize$k(input, existing, path, luvio, store, timestamp) {
     return input;
@@ -5712,14 +5712,14 @@ const ingest$k = function ManagedContentWebUrlRepresentationIngest(input, path,
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$7(luvio, input);
-    const ttlToUse = TTL$j;
+    const key = keyBuilderFromType$8(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$k(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$7(luvio, input);
+    const rootKey = keyBuilderFromType$8(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
         representationName: RepresentationType$k,
@@ -5735,7 +5735,7 @@ function getResponseCacheKeys$r(storeKeyMap, luvio, resourceParams, response) {
 }
 function ingestSuccess$r(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$7(luvio, body);
+    const key = keyBuilderFromType$8(luvio, body);
     luvio.storeIngest(key, ingest$k, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
@@ -5753,7 +5753,7 @@ function ingestSuccess$r(luvio, resourceParams, response) {
 function createResourceRequest$r(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/contents/web-urls/' + config.urlParams.managedContentWebUrlId + '',
         method: 'patch',
         body: config.body,
@@ -5828,8 +5828,8 @@ const updateManagedContentWebUrlAdapterFactory = (luvio) => {
 function select$L(luvio, params) {
     return select$$();
 }
-function keyBuilder$E(luvio, params) {
-    return keyBuilder$R(luvio, {
+function keyBuilder$F(luvio, params) {
+    return keyBuilder$S(luvio, {
         content_key: params.urlParams.contentKeyOrId,
         language: params.queryParams.language || '',
         version: params.queryParams.version || ''
@@ -5840,7 +5840,7 @@ function getResponseCacheKeys$q(storeKeyMap, luvio, resourceParams, response) {
 }
 function ingestSuccess$q(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$E(luvio, resourceParams);
+    const key = keyBuilder$F(luvio, resourceParams);
     luvio.storeIngest(key, ingest$q, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
@@ -5856,10 +5856,10 @@ function ingestSuccess$q(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$g(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$E(luvio, params);
+    const key = keyBuilder$F(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$p,
+        ttl: TTL$q,
         namespace: keyPrefix,
         version: VERSION$r,
         representationName: RepresentationType$q
@@ -5870,7 +5870,7 @@ function ingestError$g(luvio, params, error, snapshotRefresh) {
 function createResourceRequest$q(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/contents/' + config.urlParams.contentKeyOrId + '',
         method: 'get',
         body: null,
@@ -5941,9 +5941,9 @@ const getManagedContent_ConfigPropertyMetadata = [
 ];
 const getManagedContent_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$q, getManagedContent_ConfigPropertyMetadata);
 const createResourceParams$q = /*#__PURE__*/ createResourceParams$I(getManagedContent_ConfigPropertyMetadata);
-function keyBuilder$D(luvio, config) {
+function keyBuilder$E(luvio, config) {
     const resourceParams = createResourceParams$q(config);
-    return keyBuilder$E(luvio, resourceParams);
+    return keyBuilder$F(luvio, resourceParams);
 }
 function typeCheckConfig$q(untrustedConfig) {
     const config = {};
@@ -6001,7 +6001,7 @@ function buildNetworkSnapshotCachePolicy$g(context, coercedAdapterRequestContext
 function buildCachedSnapshotCachePolicy$g(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$D(luvio, config),
+        recordId: keyBuilder$E(luvio, config),
         node: adapterFragment$g(luvio, config),
         variables: {},
     };
@@ -6109,7 +6109,7 @@ function validate$A(obj, path = 'ManagedContentClonedVariantRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$i = 100;
+const TTL$j = 100;
 const VERSION$k = "7066162a0da609712a7a7b3fa365ed68";
 function validate$z(obj, path = 'ManagedContentDocumentCloneRepresentation') {
     const v_error = (() => {
@@ -6318,14 +6318,14 @@ function validate$z(obj, path = 'ManagedContentDocumentCloneRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$j = 'ManagedContentDocumentCloneRepresentation';
-function keyBuilder$C(luvio, config) {
+function keyBuilder$D(luvio, config) {
     return keyPrefix + '::' + RepresentationType$j + ':' + config.id;
 }
-function keyBuilderFromType$6(luvio, object) {
+function keyBuilderFromType$7(luvio, object) {
     const keyParams = {
         id: object.contentKey
     };
-    return keyBuilder$C(luvio, keyParams);
+    return keyBuilder$D(luvio, keyParams);
 }
 function normalize$j(input, existing, path, luvio, store, timestamp) {
     return input;
@@ -6351,14 +6351,14 @@ const ingest$j = function ManagedContentDocumentCloneRepresentationIngest(input,
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$6(luvio, input);
-    const ttlToUse = TTL$i;
+    const key = keyBuilderFromType$7(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$6(luvio, input);
+    const rootKey = keyBuilderFromType$7(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
         representationName: RepresentationType$j,
@@ -6374,7 +6374,7 @@ function getResponseCacheKeys$p(storeKeyMap, luvio, resourceParams, response) {
 }
 function ingestSuccess$p(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$6(luvio, body);
+    const key = keyBuilderFromType$7(luvio, body);
     luvio.storeIngest(key, ingest$j, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
@@ -6392,7 +6392,7 @@ function ingestSuccess$p(luvio, resourceParams, response) {
 function createResourceRequest$p(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/contents/' + config.urlParams.contentKeyOrId + '/clone',
         method: 'post',
         body: config.body,
@@ -6460,7 +6460,7 @@ const cloneManagedContentDocumentAdapterFactory = (luvio) => {
     };
 };
 
-const TTL$h = 1000;
+const TTL$i = 1000;
 const VERSION$j = "98edee4f058ced93570a7b0ce2293672";
 function validate$y(obj, path = 'ManagedContentRenditionRepresentation') {
     const v_error = (() => {
@@ -6539,7 +6539,7 @@ const ingest$i = function ManagedContentRenditionRepresentationIngest(input, pat
         }
     }
     const key = path.fullPath;
-    const ttlToUse = TTL$h;
+    const ttlToUse = TTL$i;
     ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$i, "CMSAuthoring", VERSION$j, RepresentationType$i, equals$j);
     return createLink(key);
 };
@@ -6556,15 +6556,15 @@ function getTypeCacheKeys$i(rootKeySet, luvio, input, fullPathFactory) {
 function select$H(luvio, params) {
     return select$I();
 }
-function keyBuilder$B(luvio, params) {
+function keyBuilder$C(luvio, params) {
     return keyPrefix + '::ManagedContentRenditionRepresentation:(' + 'channelIdOrApiName:' + params.queryParams.channelIdOrApiName + ',' + 'language:' + params.queryParams.language + ',' + 'version:' + params.queryParams.version + ',' + 'contentKeyOrId:' + params.urlParams.contentKeyOrId + ',' + 'renditionType:' + params.urlParams.renditionType + ')';
 }
 function getResponseCacheKeys$o(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$i(storeKeyMap, luvio, response, () => keyBuilder$B(luvio, resourceParams));
+    getTypeCacheKeys$i(storeKeyMap, luvio, response, () => keyBuilder$C(luvio, resourceParams));
 }
 function ingestSuccess$o(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$B(luvio, resourceParams);
+    const key = keyBuilder$C(luvio, resourceParams);
     luvio.storeIngest(key, ingest$i, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
@@ -6580,10 +6580,10 @@ function ingestSuccess$o(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$f(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$B(luvio, params);
+    const key = keyBuilder$C(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$h,
+        ttl: TTL$i,
         namespace: keyPrefix,
         version: VERSION$j,
         representationName: RepresentationType$i
@@ -6594,7 +6594,7 @@ function ingestError$f(luvio, params, error, snapshotRefresh) {
 function createResourceRequest$o(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/contents/' + config.urlParams.contentKeyOrId + '/renditions/' + config.urlParams.renditionType + '',
         method: 'get',
         body: null,
@@ -6615,9 +6615,9 @@ const getManagedContentVariantRendition_ConfigPropertyMetadata = [
 ];
 const getManagedContentVariantRendition_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$o, getManagedContentVariantRendition_ConfigPropertyMetadata);
 const createResourceParams$o = /*#__PURE__*/ createResourceParams$I(getManagedContentVariantRendition_ConfigPropertyMetadata);
-function keyBuilder$A(luvio, config) {
+function keyBuilder$B(luvio, config) {
     const resourceParams = createResourceParams$o(config);
-    return keyBuilder$B(luvio, resourceParams);
+    return keyBuilder$C(luvio, resourceParams);
 }
 function typeCheckConfig$o(untrustedConfig) {
     const config = {};
@@ -6675,7 +6675,7 @@ function buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext
 function buildCachedSnapshotCachePolicy$f(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$A(luvio, config),
+        recordId: keyBuilder$B(luvio, config),
         node: adapterFragment$f(luvio, config),
         variables: {},
     };
@@ -6714,7 +6714,7 @@ function validate$x(obj, path = 'ManagedContentTaxonomyPathFragmentRepresentatio
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$g = 100;
+const TTL$h = 100;
 const VERSION$i = "861a01549e9c8877564cf9109fe8af72";
 function validate$w(obj, path = 'ManagedContentTaxonomyPathRepresentation') {
     const v_error = (() => {
@@ -6778,7 +6778,7 @@ const ingest$h = function ManagedContentTaxonomyPathRepresentationIngest(input,
         }
     }
     const key = path.fullPath;
-    const ttlToUse = TTL$g;
+    const ttlToUse = TTL$h;
     ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$h, "CMSAuthoring", VERSION$i, RepresentationType$h, equals$i);
     return createLink(key);
 };
@@ -6792,7 +6792,8 @@ function getTypeCacheKeys$h(rootKeySet, luvio, input, fullPathFactory) {
     });
 }
 
-const VERSION$h = "05c4867cd20f87930367aa80db4baab5";
+const TTL$g = 100;
+const VERSION$h = "ac799a7cee04dda27b43cff95ee1aee5";
 function validate$v(obj, path = 'ManagedContentTaxonomyTermRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -6824,6 +6825,15 @@ function validate$v(obj, path = 'ManagedContentTaxonomyTermRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$g = 'ManagedContentTaxonomyTermRepresentation';
+function keyBuilder$A(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$g + ':' + config.id;
+}
+function keyBuilderFromType$6(luvio, object) {
+    const keyParams = {
+        id: object.id
+    };
+    return keyBuilder$A(luvio, keyParams);
+}
 function normalize$g(input, existing, path, luvio, store, timestamp) {
     const input_pathsFromRoot = input.pathsFromRoot;
     const input_pathsFromRoot_id = path.fullPath + '__pathsFromRoot';
@@ -6896,14 +6906,14 @@ const ingest$g = function ManagedContentTaxonomyTermRepresentationIngest(input,
             throw validateError;
         }
     }
-    const key = path.fullPath;
-    const ttlToUse = path.ttl;
+    const key = keyBuilderFromType$6(luvio, input);
+    const ttlToUse = TTL$g;
     ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$g, "CMSAuthoring", VERSION$h, RepresentationType$g, equals$h);
     return createLink(key);
 };
 function getTypeCacheKeys$g(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = fullPathFactory();
+    const rootKey = keyBuilderFromType$6(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
         representationName: RepresentationType$g,
@@ -7086,7 +7096,7 @@ function getTypeCacheKeys$f(rootKeySet, luvio, input, fullPathFactory) {
     });
     const input_taxonomyTerms_length = input.taxonomyTerms.length;
     for (let i = 0; i < input_taxonomyTerms_length; i++) {
-        getTypeCacheKeys$g(rootKeySet, luvio, input.taxonomyTerms[i], () => '');
+        getTypeCacheKeys$g(rootKeySet, luvio, input.taxonomyTerms[i]);
     }
 }
 
@@ -7133,7 +7143,7 @@ function ingestError$e(luvio, params, error, snapshotRefresh) {
 function createResourceRequest$n(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/contents/' + config.urlParams.contentKeyOrId + '/taxonomy-terms',
         method: 'get',
         body: null,
@@ -7256,7 +7266,7 @@ function ingestSuccess$m(luvio, resourceParams, response) {
 function createResourceRequest$m(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/contents/' + config.urlParams.contentKeyOrId + '/taxonomy-terms',
         method: 'patch',
         body: config.body,
@@ -7429,7 +7439,7 @@ function ingestError$d(luvio, params, error, snapshotRefresh) {
 function createResourceRequest$l(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/contents/' + config.urlParams.contentKeyOrId + '/web-urls',
         method: 'get',
         body: null,
@@ -7781,7 +7791,7 @@ function ingestError$c(luvio, params, error, snapshotRefresh) {
 function createResourceRequest$k(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/contents/' + config.urlParams.contentKeyOrId + '/referenced-by',
         method: 'get',
         body: null,
@@ -8115,7 +8125,7 @@ function ingestError$b(luvio, params, error, snapshotRefresh) {
 function createResourceRequest$j(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/contents/' + config.urlParams.contentKeyOrId + '/variants/references',
         method: 'get',
         body: null,
@@ -8334,7 +8344,7 @@ function ingestSuccess$i(luvio, resourceParams, response) {
 function createResourceRequest$i(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/folders',
         method: 'post',
         body: config.body,
@@ -8530,7 +8540,7 @@ function ingestError$a(luvio, params, error, snapshotRefresh) {
 function createResourceRequest$h(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/folders/' + config.urlParams.folderId + '',
         method: 'get',
         body: null,
@@ -8888,7 +8898,7 @@ function ingestError$9(luvio, params, error, snapshotRefresh) {
 function createResourceRequest$g(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/folders/' + config.urlParams.folderId + '/items',
         method: 'get',
         body: null,
@@ -9123,7 +9133,7 @@ function ingestError$8(luvio, params, error, snapshotRefresh) {
 function createResourceRequest$f(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/folders/' + config.urlParams.folderId + '/share-targets',
         method: 'get',
         body: null,
@@ -9368,7 +9378,7 @@ function ingestError$7(luvio, params, error, snapshotRefresh) {
 function createResourceRequest$e(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/folders/' + config.urlParams.folderId + '/shares',
         method: 'get',
         body: null,
@@ -9505,7 +9515,7 @@ function ingestSuccess$d(luvio, resourceParams, response) {
 function createResourceRequest$d(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/folders/' + config.urlParams.folderId + '/shares',
         method: 'patch',
         body: config.body,
@@ -9762,7 +9772,7 @@ function ingestError$6(luvio, params, error, snapshotRefresh) {
 function createResourceRequest$c(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/items/search',
         method: 'get',
         body: null,
@@ -9873,7 +9883,7 @@ function getResponseCacheKeys$b(storeKeyMap, luvio, resourceParams, response) {
 }
 function ingestSuccess$b(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$g(luvio, body);
+    const key = keyBuilderFromType$h(luvio, body);
     luvio.storeIngest(key, ingest$x, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
@@ -9891,7 +9901,7 @@ function ingestSuccess$b(luvio, resourceParams, response) {
 function createResourceRequest$b(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/schedules',
         method: 'post',
         body: config.body,
@@ -9971,7 +9981,7 @@ function getResponseCacheKeys$a(storeKeyMap, luvio, resourceParams, response) {
 }
 function ingestSuccess$a(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$g(luvio, body);
+    const key = keyBuilderFromType$h(luvio, body);
     luvio.storeIngest(key, ingest$x, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
@@ -9989,7 +9999,7 @@ function ingestSuccess$a(luvio, resourceParams, response) {
 function createResourceRequest$a(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/schedules/' + config.urlParams.deploymentId + '',
         method: 'patch',
         body: null,
@@ -10399,7 +10409,7 @@ function ingestError$5(luvio, params, error, snapshotRefresh) {
 function createResourceRequest$9(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/spaces',
         method: 'get',
         body: null,
@@ -10541,7 +10551,7 @@ function ingestError$4(luvio, params, error, snapshotRefresh) {
 function createResourceRequest$8(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/spaces/' + config.urlParams.contentSpaceId + '',
         method: 'get',
         body: null,
@@ -10757,7 +10767,7 @@ function ingestSuccess$7(luvio, resourceParams, response) {
 function createResourceRequest$7(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/spaces/' + config.urlParams.contentSpaceId + '',
         method: 'patch',
         body: config.body,
@@ -10985,7 +10995,7 @@ function ingestError$3(luvio, params, error, snapshotRefresh) {
 function createResourceRequest$6(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/spaces/' + config.urlParams.contentSpaceId + '/orchestrator-config',
         method: 'get',
         body: null,
@@ -11129,7 +11139,7 @@ function ingestSuccess$5(luvio, resourceParams, response) {
 function createResourceRequest$5(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/spaces/' + config.urlParams.contentSpaceId + '/orchestrator-config',
         method: 'put',
         body: config.body,
@@ -11334,7 +11344,7 @@ function ingestError$2(luvio, params, error, snapshotRefresh) {
 function createResourceRequest$4(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/spaces/' + config.urlParams.contentSpaceId + '/content-types',
         method: 'get',
         body: null,
@@ -11714,7 +11724,7 @@ function ingestSuccess$3(luvio, resourceParams, response) {
 function createResourceRequest$3(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/spaces/' + config.urlParams.contentSpaceId + '/contents/export',
         method: 'post',
         body: config.body,
@@ -11834,7 +11844,7 @@ function ingestSuccess$2(luvio, resourceParams, response) {
 function createResourceRequest$2(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/spaces/' + config.urlParams.contentSpaceId + '/contents/import',
         method: 'post',
         body: config.body,
@@ -12152,7 +12162,7 @@ function ingestError$1(luvio, params, error, snapshotRefresh) {
 function createResourceRequest$1(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/cms/spaces/' + config.urlParams.contentSpaceId + '/preview-endpoints',
         method: 'get',
         body: null,
@@ -12255,7 +12265,7 @@ function select(luvio, params) {
     return select$$();
 }
 function keyBuilder$1(luvio, params) {
-    return keyBuilder$R(luvio, {
+    return keyBuilder$S(luvio, {
         content_key: params.urlParams.contentKeyOrId,
         language: params.queryParams.language || '',
         version: params.queryParams.version || ''
@@ -12285,7 +12295,7 @@ function ingestError(luvio, params, error, snapshotRefresh) {
     const key = keyBuilder$1(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$p,
+        ttl: TTL$q,
         namespace: keyPrefix,
         version: VERSION$r,
         representationName: RepresentationType$q
@@ -12296,7 +12306,7 @@ function ingestError(luvio, params, error, snapshotRefresh) {
 function createResourceRequest(config) {
     const headers = {};
     return {
-        baseUri: '/services/data/v61.0',
+        baseUri: '/services/data/v62.0',
         basePath: '/connect/sites/' + config.urlParams.siteId + '/cms/contents/' + config.urlParams.contentKeyOrId + '',
         method: 'get',
         body: null,