@salesforce/lds-adapters-cms-authoring 1.281.0 → 1.283.0

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

@@ -3379,592 +3379,7 @@ const createTranslationV2JobAdapterFactory = (luvio) => {
     };
 };
 
-function validate$Y(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 + '")');
-        }
-        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 + '")');
-        }
-        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 + '")');
-        }
-    })();
-    return v_error === undefined ? null : v_error;
-}
-
-const TTL$p = 100;
-const VERSION$r = "861a01549e9c8877564cf9109fe8af72";
-function validate$X(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 + '")');
-        }
-        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_taxonomyFragment = obj.taxonomyFragment;
-        const path_taxonomyFragment = path + '.taxonomyFragment';
-        const referencepath_taxonomyFragmentValidationError = validate$Y(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');
-            return new TypeError(message);
-        }
-        const obj_termFragments = obj.termFragments;
-        const path_termFragments = path + '.termFragments';
-        if (!ArrayIsArray(obj_termFragments)) {
-            return new TypeError('Expected "array" but received "' + typeof obj_termFragments + '" (at "' + path_termFragments + '")');
-        }
-        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$Y(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');
-                return new TypeError(message);
-            }
-        }
-    })();
-    return v_error === undefined ? null : v_error;
-}
-const RepresentationType$q = 'ManagedContentTaxonomyPathRepresentation';
-function normalize$q(input, existing, path, luvio, store, timestamp) {
-    return input;
-}
-const select$$ = function ManagedContentTaxonomyPathRepresentationSelect() {
-    return {
-        kind: 'Fragment',
-        version: VERSION$r,
-        private: [],
-        opaque: true
-    };
-};
-function equals$r(existing, incoming) {
-    if (JSONStringify(incoming) !== JSONStringify(existing)) {
-        return false;
-    }
-    return true;
-}
-const ingest$q = function ManagedContentTaxonomyPathRepresentationIngest(input, path, luvio, store, timestamp) {
-    if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$X(input);
-        if (validateError !== null) {
-            throw validateError;
-        }
-    }
-    const key = path.fullPath;
-    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$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$q,
-        mergeable: false
-    });
-}
-
-const VERSION$q = "05c4867cd20f87930367aa80db4baab5";
-function validate$W(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 + '")');
-        }
-        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 + '")');
-        }
-        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_pathsFromRoot = obj.pathsFromRoot;
-        const path_pathsFromRoot = path + '.pathsFromRoot';
-        if (!ArrayIsArray(obj_pathsFromRoot)) {
-            return new TypeError('Expected "array" but received "' + typeof obj_pathsFromRoot + '" (at "' + path_pathsFromRoot + '")');
-        }
-        for (let i = 0; i < obj_pathsFromRoot.length; i++) {
-            const obj_pathsFromRoot_item = obj_pathsFromRoot[i];
-            const path_pathsFromRoot_item = path_pathsFromRoot + '[' + i + ']';
-            if (typeof obj_pathsFromRoot_item !== 'object') {
-                return new TypeError('Expected "object" but received "' + typeof obj_pathsFromRoot_item + '" (at "' + path_pathsFromRoot_item + '")');
-            }
-        }
-    })();
-    return v_error === undefined ? null : v_error;
-}
-const RepresentationType$p = 'ManagedContentTaxonomyTermRepresentation';
-function normalize$p(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$q(input_pathsFromRoot_item, {
-            fullPath: input_pathsFromRoot_item_id,
-            propertyName: i,
-            parent: {
-                data: input,
-                key: path.fullPath,
-                existing: existing,
-            },
-            ttl: path.ttl
-        }, luvio, store, timestamp);
-    }
-    return input;
-}
-const select$_ = function ManagedContentTaxonomyTermRepresentationSelect() {
-    return {
-        kind: 'Fragment',
-        version: VERSION$q,
-        private: [],
-        selections: [
-            {
-                name: 'id',
-                kind: 'Scalar'
-            },
-            {
-                name: 'label',
-                kind: 'Scalar'
-            },
-            {
-                name: 'pathsFromRoot',
-                kind: 'Link',
-                plural: true,
-                fragment: select$$()
-            }
-        ]
-    };
-};
-function equals$q(existing, incoming) {
-    const existing_id = existing.id;
-    const incoming_id = incoming.id;
-    if (!(existing_id === incoming_id)) {
-        return false;
-    }
-    const existing_label = existing.label;
-    const incoming_label = incoming.label;
-    if (!(existing_label === incoming_label)) {
-        return false;
-    }
-    const existing_pathsFromRoot = existing.pathsFromRoot;
-    const incoming_pathsFromRoot = incoming.pathsFromRoot;
-    const equals_pathsFromRoot_items = equalsArray(existing_pathsFromRoot, incoming_pathsFromRoot, (existing_pathsFromRoot_item, incoming_pathsFromRoot_item) => {
-        if (!(existing_pathsFromRoot_item.__ref === incoming_pathsFromRoot_item.__ref)) {
-            return false;
-        }
-    });
-    if (equals_pathsFromRoot_items === false) {
-        return false;
-    }
-    return true;
-}
-const ingest$p = function ManagedContentTaxonomyTermRepresentationIngest(input, path, luvio, store, timestamp) {
-    if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$W(input);
-        if (validateError !== null) {
-            throw validateError;
-        }
-    }
-    const key = path.fullPath;
-    const ttlToUse = path.ttl;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$p, "CMSAuthoring", VERSION$q, RepresentationType$p, equals$q);
-    return createLink(key);
-};
-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$p,
-        mergeable: false
-    });
-    const input_pathsFromRoot_length = input.pathsFromRoot.length;
-    for (let i = 0; i < input_pathsFromRoot_length; i++) {
-        getTypeCacheKeys$q(rootKeySet, luvio, input.pathsFromRoot[i], () => '');
-    }
-}
-
-const TTL$o = 100;
-const VERSION$p = "838bc0422b420be598cab667d4031ed0";
-function validate$V(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 + '")');
-        }
-        const obj_contentKey = obj.contentKey;
-        const path_contentKey = path + '.contentKey';
-        if (typeof obj_contentKey !== 'string') {
-            return new TypeError('Expected "string" but received "' + typeof obj_contentKey + '" (at "' + path_contentKey + '")');
-        }
-        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_taxonomyTerms = obj.taxonomyTerms;
-        const path_taxonomyTerms = path + '.taxonomyTerms';
-        if (!ArrayIsArray(obj_taxonomyTerms)) {
-            return new TypeError('Expected "array" but received "' + typeof obj_taxonomyTerms + '" (at "' + path_taxonomyTerms + '")');
-        }
-        for (let i = 0; i < obj_taxonomyTerms.length; i++) {
-            const obj_taxonomyTerms_item = obj_taxonomyTerms[i];
-            const path_taxonomyTerms_item = path_taxonomyTerms + '[' + i + ']';
-            if (typeof obj_taxonomyTerms_item !== 'object') {
-                return new TypeError('Expected "object" but received "' + typeof obj_taxonomyTerms_item + '" (at "' + path_taxonomyTerms_item + '")');
-            }
-        }
-    })();
-    return v_error === undefined ? null : v_error;
-}
-const RepresentationType$o = 'ManagedContentTaxonomyTermCollectionRepresentation';
-function keyBuilder$R(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$o + ':' + config.id;
-}
-function keyBuilderFromType$c(luvio, object) {
-    const keyParams = {
-        id: object.contentKey
-    };
-    return keyBuilder$R(luvio, keyParams);
-}
-function normalize$o(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$p(input_taxonomyTerms_item, {
-            fullPath: input_taxonomyTerms_item_id,
-            propertyName: i,
-            parent: {
-                data: input,
-                key: path.fullPath,
-                existing: existing,
-            },
-            ttl: path.ttl
-        }, luvio, store, timestamp);
-    }
-    return input;
-}
-const select$Z = function ManagedContentTaxonomyTermCollectionRepresentationSelect() {
-    return {
-        kind: 'Fragment',
-        version: VERSION$p,
-        private: [],
-        selections: [
-            {
-                name: 'contentKey',
-                kind: 'Scalar'
-            },
-            {
-                name: 'managedContentId',
-                kind: 'Scalar'
-            },
-            {
-                name: 'taxonomyTerms',
-                kind: 'Link',
-                plural: true,
-                fragment: select$_()
-            }
-        ]
-    };
-};
-function equals$p(existing, incoming) {
-    const existing_contentKey = existing.contentKey;
-    const incoming_contentKey = incoming.contentKey;
-    if (!(existing_contentKey === incoming_contentKey)) {
-        return false;
-    }
-    const existing_managedContentId = existing.managedContentId;
-    const incoming_managedContentId = incoming.managedContentId;
-    if (!(existing_managedContentId === incoming_managedContentId)) {
-        return false;
-    }
-    const existing_taxonomyTerms = existing.taxonomyTerms;
-    const incoming_taxonomyTerms = incoming.taxonomyTerms;
-    const equals_taxonomyTerms_items = equalsArray(existing_taxonomyTerms, incoming_taxonomyTerms, (existing_taxonomyTerms_item, incoming_taxonomyTerms_item) => {
-        if (!(existing_taxonomyTerms_item.__ref === incoming_taxonomyTerms_item.__ref)) {
-            return false;
-        }
-    });
-    if (equals_taxonomyTerms_items === false) {
-        return false;
-    }
-    return true;
-}
-const ingest$o = function ManagedContentTaxonomyTermCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
-    if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$V(input);
-        if (validateError !== null) {
-            throw validateError;
-        }
-    }
-    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$c(luvio, input);
-    rootKeySet.set(rootKey, {
-        namespace: keyPrefix,
-        representationName: RepresentationType$o,
-        mergeable: false
-    });
-    const input_taxonomyTerms_length = input.taxonomyTerms.length;
-    for (let i = 0; i < input_taxonomyTerms_length; i++) {
-        getTypeCacheKeys$p(rootKeySet, luvio, input.taxonomyTerms[i], () => '');
-    }
-}
-
-function select$Y(luvio, params) {
-    return select$Z();
-}
-function keyBuilder$Q(luvio, params) {
-    return keyBuilder$R(luvio, {
-        id: params.urlParams.contentKeyOrId
-    });
-}
-function getResponseCacheKeys$A(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$o(storeKeyMap, luvio, response);
-}
-function ingestSuccess$A(luvio, resourceParams, response, snapshotRefresh) {
-    const { body } = response;
-    const key = keyBuilder$Q(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$o, body);
-    const snapshot = luvio.storeLookup({
-        recordId: key,
-        node: select$Y(),
-        variables: {},
-    }, snapshotRefresh);
-    if (process.env.NODE_ENV !== 'production') {
-        if (snapshot.state !== 'Fulfilled') {
-            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
-        }
-    }
-    deepFreeze(snapshot.data);
-    return snapshot;
-}
-function ingestError$j(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$Q(luvio, params);
-    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
-    const storeMetadataParams = {
-        ttl: TTL$o,
-        namespace: keyPrefix,
-        version: VERSION$p,
-        representationName: RepresentationType$o
-    };
-    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
-    return errorSnapshot;
-}
-function createResourceRequest$A(config) {
-    const headers = {};
-    return {
-        baseUri: '/services/data/v61.0',
-        basePath: '/connect/cms/content/' + config.urlParams.contentKeyOrId + '/taxonomy-terms',
-        method: 'get',
-        body: null,
-        urlParams: config.urlParams,
-        queryParams: {},
-        headers,
-        priority: 'normal',
-    };
-}
-
-const adapterName$A = 'getManagedContentTaxonomyTerms';
-const getManagedContentTaxonomyTerms_ConfigPropertyMetadata = [
-    generateParamConfigMetadata('contentKeyOrId', true, 0 /* UrlParameter */, 0 /* String */),
-];
-const getManagedContentTaxonomyTerms_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$A, getManagedContentTaxonomyTerms_ConfigPropertyMetadata);
-const createResourceParams$A = /*#__PURE__*/ createResourceParams$I(getManagedContentTaxonomyTerms_ConfigPropertyMetadata);
-function keyBuilder$P(luvio, config) {
-    const resourceParams = createResourceParams$A(config);
-    return keyBuilder$Q(luvio, resourceParams);
-}
-function typeCheckConfig$A(untrustedConfig) {
-    const config = {};
-    typeCheckConfig$I(untrustedConfig, config, getManagedContentTaxonomyTerms_ConfigPropertyMetadata);
-    return config;
-}
-function validateAdapterConfig$A(untrustedConfig, configPropertyNames) {
-    if (!untrustedIsObject(untrustedConfig)) {
-        return null;
-    }
-    if (process.env.NODE_ENV !== 'production') {
-        validateConfig(untrustedConfig, configPropertyNames);
-    }
-    const config = typeCheckConfig$A(untrustedConfig);
-    if (!areRequiredParametersPresent(config, configPropertyNames)) {
-        return null;
-    }
-    return config;
-}
-function adapterFragment$j(luvio, config) {
-    createResourceParams$A(config);
-    return select$Y();
-}
-function onFetchResponseSuccess$l(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$A(luvio, resourceParams, response, {
-        config,
-        resolve: () => buildNetworkSnapshot$A(luvio, config, snapshotRefreshOptions)
-    });
-    return luvio.storeBroadcast().then(() => snapshot);
-}
-function onFetchResponseError$j(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$j(luvio, resourceParams, response, {
-        config,
-        resolve: () => buildNetworkSnapshot$A(luvio, config, snapshotRefreshOptions)
-    });
-    return luvio.storeBroadcast().then(() => snapshot);
-}
-function buildNetworkSnapshot$A(luvio, config, options) {
-    const resourceParams = createResourceParams$A(config);
-    const request = createResourceRequest$A(resourceParams);
-    return luvio.dispatchResourceRequest(request, options)
-        .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$l(luvio, config, resourceParams, response), () => {
-            const cache = new StoreKeyMap();
-            getResponseCacheKeys$A(cache, luvio, resourceParams, response.body);
-            return cache;
-        });
-    }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$j(luvio, config, resourceParams, response));
-    });
-}
-function buildNetworkSnapshotCachePolicy$j(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$p(context, coercedAdapterRequestContext, buildNetworkSnapshot$A, undefined, false);
-}
-function buildCachedSnapshotCachePolicy$j(context, storeLookup) {
-    const { luvio, config } = context;
-    const selector = {
-        recordId: keyBuilder$P(luvio, config),
-        node: adapterFragment$j(luvio, config),
-        variables: {},
-    };
-    const cacheSnapshot = storeLookup(selector, {
-        config,
-        resolve: () => buildNetworkSnapshot$A(luvio, config, snapshotRefreshOptions)
-    });
-    return cacheSnapshot;
-}
-const getManagedContentTaxonomyTermsAdapterFactory = (luvio) => function CMSAuthoring__getManagedContentTaxonomyTerms(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$A(untrustedConfig, getManagedContentTaxonomyTerms_ConfigPropertyNames);
-    // Invalid or incomplete config
-    if (config === null) {
-        return null;
-    }
-    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$j, buildNetworkSnapshotCachePolicy$j);
-};
-
-function select$X(luvio, params) {
-    return select$Z();
-}
-function getResponseCacheKeys$z(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$o(storeKeyMap, luvio, response);
-}
-function ingestSuccess$z(luvio, resourceParams, response) {
-    const { body } = response;
-    const key = keyBuilderFromType$c(luvio, body);
-    luvio.storeIngest(key, ingest$o, body);
-    const snapshot = luvio.storeLookup({
-        recordId: key,
-        node: select$X(),
-        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$z(config) {
-    const headers = {};
-    return {
-        baseUri: '/services/data/v61.0',
-        basePath: '/connect/cms/content/' + config.urlParams.contentKeyOrId + '/taxonomy-terms',
-        method: 'patch',
-        body: config.body,
-        urlParams: config.urlParams,
-        queryParams: {},
-        headers,
-        priority: 'normal',
-    };
-}
-
-const adapterName$z = '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$z, updateManagedContentTaxonomyTerms_ConfigPropertyMetadata);
-const createResourceParams$z = /*#__PURE__*/ createResourceParams$I(updateManagedContentTaxonomyTerms_ConfigPropertyMetadata);
-function typeCheckConfig$z(untrustedConfig) {
-    const config = {};
-    typeCheckConfig$I(untrustedConfig, config, updateManagedContentTaxonomyTerms_ConfigPropertyMetadata);
-    return config;
-}
-function validateAdapterConfig$z(untrustedConfig, configPropertyNames) {
-    if (!untrustedIsObject(untrustedConfig)) {
-        return null;
-    }
-    if (process.env.NODE_ENV !== 'production') {
-        validateConfig(untrustedConfig, configPropertyNames);
-    }
-    const config = typeCheckConfig$z(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);
-    return luvio.dispatchResourceRequest(request, options)
-        .then((response) => {
-        return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$z(luvio, resourceParams, response);
-            return luvio.storeBroadcast().then(() => snapshot);
-        }, () => {
-            const cache = new StoreKeyMap();
-            getResponseCacheKeys$z(cache, luvio, resourceParams, response.body);
-            return cache;
-        });
-    }, (response) => {
-        deepFreeze(response);
-        throw response;
-    });
-}
-const updateManagedContentTaxonomyTermsAdapterFactory = (luvio) => {
-    return function updateManagedContentTaxonomyTerms(untrustedConfig) {
-        const config = validateAdapterConfig$z(untrustedConfig, updateManagedContentTaxonomyTerms_ConfigPropertyNames);
-        // Invalid or incomplete config
-        if (config === null) {
-            throw new Error('Invalid config for "updateManagedContentTaxonomyTerms"');
-        }
-        return buildNetworkSnapshot$z(luvio, config);
-    };
-};
-
-function validate$U(obj, path = 'ManagedContentInputRepresentation') {
+function validate$Y(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 +3426,7 @@ function validate$U(obj, path = 'ManagedContentInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$T(obj, path = 'ManagedContentSpaceSummaryRepresentation') {
+function validate$X(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 +3445,7 @@ function validate$T(obj, path = 'ManagedContentSpaceSummaryRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$S(obj, path = 'ManagedContentFolderSummaryRepresentation') {
+function validate$W(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 +3464,7 @@ function validate$S(obj, path = 'ManagedContentFolderSummaryRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$R(obj, path = 'ManagedContentVariantStatusRepresentation') {
+function validate$V(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 +3483,9 @@ function validate$R(obj, path = 'ManagedContentVariantStatusRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$n = 100;
-const VERSION$o = "32da7ab9bec2902e7f2b1d1e9aa618f1";
-function validate$Q(obj, path = 'ManagedContentDocumentRepresentation') {
+const TTL$p = 100;
+const VERSION$r = "32da7ab9bec2902e7f2b1d1e9aa618f1";
+function validate$U(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 + '")');
@@ -4124,7 +3539,7 @@ function validate$Q(obj, path = 'ManagedContentDocumentRepresentation') {
         }
         const obj_contentSpace = obj.contentSpace;
         const path_contentSpace = path + '.contentSpace';
-        const referencepath_contentSpaceValidationError = validate$T(obj_contentSpace, path_contentSpace);
+        const referencepath_contentSpaceValidationError = validate$X(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');
@@ -4153,7 +3568,7 @@ function validate$Q(obj, path = 'ManagedContentDocumentRepresentation') {
         }
         const obj_folder = obj.folder;
         const path_folder = path + '.folder';
-        const referencepath_folderValidationError = validate$S(obj_folder, path_folder);
+        const referencepath_folderValidationError = validate$W(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');
@@ -4202,7 +3617,7 @@ function validate$Q(obj, path = 'ManagedContentDocumentRepresentation') {
             const path_status = path + '.status';
             let obj_status_union0 = null;
             const obj_status_union0_error = (() => {
-                const referencepath_statusValidationError = validate$R(obj_status, path_status);
+                const referencepath_statusValidationError = validate$V(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');
@@ -4272,70 +3687,70 @@ function validate$Q(obj, path = 'ManagedContentDocumentRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$n = 'ManagedContentDocumentRepresentation';
-function keyBuilder$O(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$n + ':' + config.content_key + ':' + config.language + ':' + config.version;
+const RepresentationType$q = 'ManagedContentDocumentRepresentation';
+function keyBuilder$R(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$q + ':' + config.content_key + ':' + config.language + ':' + config.version;
 }
-function keyBuilderFromType$b(luvio, object) {
+function keyBuilderFromType$c(luvio, object) {
     const keyParams = {
         content_key: object.contentKey,
         language: object.language,
         version: object.version
     };
-    return keyBuilder$O(luvio, keyParams);
+    return keyBuilder$R(luvio, keyParams);
 }
-function normalize$n(input, existing, path, luvio, store, timestamp) {
+function normalize$q(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$W = function ManagedContentDocumentRepresentationSelect() {
+const select$$ = function ManagedContentDocumentRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$o,
+        version: VERSION$r,
         private: [],
         opaque: true
     };
 };
-function equals$o(existing, incoming) {
+function equals$r(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$n = function ManagedContentDocumentRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$q = function ManagedContentDocumentRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$Q(input);
+        const validateError = validate$U(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    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);
+    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);
     return createLink(key);
 };
-function getTypeCacheKeys$n(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$q(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$q,
         mergeable: false
     });
 }
 
-function select$V(luvio, params) {
-    return select$W();
+function select$_(luvio, params) {
+    return select$$();
 }
-function getResponseCacheKeys$y(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$n(storeKeyMap, luvio, response);
+function getResponseCacheKeys$A(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$q(storeKeyMap, luvio, response);
 }
-function ingestSuccess$y(luvio, resourceParams, response) {
+function ingestSuccess$A(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$b(luvio, body);
-    luvio.storeIngest(key, ingest$n, body);
+    const key = keyBuilderFromType$c(luvio, body);
+    luvio.storeIngest(key, ingest$q, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$V(),
+        node: select$_(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -4346,7 +3761,7 @@ function ingestSuccess$y(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$y(config) {
+function createResourceRequest$A(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -4360,52 +3775,52 @@ function createResourceRequest$y(config) {
     };
 }
 
-function ingestSuccess$x(luvio, resourceParams, response) {
+function ingestSuccess$z(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$y(luvio, resourceParams, response);
+    return ingestSuccess$A(luvio, resourceParams, response);
 }
 
-const adapterName$y = 'createManagedContent';
+const adapterName$A = 'createManagedContent';
 const createManagedContent_ConfigPropertyMetadata = [
     generateParamConfigMetadata('ManagedContentInputParam', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const createManagedContent_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$y, createManagedContent_ConfigPropertyMetadata);
-const createResourceParams$y = /*#__PURE__*/ createResourceParams$I(createManagedContent_ConfigPropertyMetadata);
-function typeCheckConfig$y(untrustedConfig) {
+const createManagedContent_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$A, createManagedContent_ConfigPropertyMetadata);
+const createResourceParams$A = /*#__PURE__*/ createResourceParams$I(createManagedContent_ConfigPropertyMetadata);
+function typeCheckConfig$A(untrustedConfig) {
     const config = {};
     const untrustedConfig_ManagedContentInputParam = untrustedConfig.ManagedContentInputParam;
-    const referenceManagedContentInputRepresentationValidationError = validate$U(untrustedConfig_ManagedContentInputParam);
+    const referenceManagedContentInputRepresentationValidationError = validate$Y(untrustedConfig_ManagedContentInputParam);
     if (referenceManagedContentInputRepresentationValidationError === null) {
         config.ManagedContentInputParam = untrustedConfig_ManagedContentInputParam;
     }
     return config;
 }
-function validateAdapterConfig$y(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$A(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$y(untrustedConfig);
+    const config = typeCheckConfig$A(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$y(luvio, config, options) {
-    const resourceParams = createResourceParams$y(config);
-    const request = createResourceRequest$y(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$x(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$z(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$y(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$A(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -4415,16 +3830,16 @@ function buildNetworkSnapshot$y(luvio, config, options) {
 }
 const createManagedContentAdapterFactory = (luvio) => {
     return function createManagedContent(untrustedConfig) {
-        const config = validateAdapterConfig$y(untrustedConfig, createManagedContent_ConfigPropertyNames);
+        const config = validateAdapterConfig$A(untrustedConfig, createManagedContent_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createManagedContent"');
         }
-        return buildNetworkSnapshot$y(luvio, config);
+        return buildNetworkSnapshot$A(luvio, config);
     };
 };
 
-function validate$P(obj, path = 'ManagedContentCloneItemRepresentation') {
+function validate$T(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 + '")');
@@ -4445,7 +3860,7 @@ function validate$P(obj, path = 'ManagedContentCloneItemRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$O(obj, path = 'ManagedContentCloneStatusRepresentation') {
+function validate$S(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 + '")');
@@ -4464,7 +3879,7 @@ function validate$O(obj, path = 'ManagedContentCloneStatusRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$N(obj, path = 'ManagedContentFailedVariantsRepresentation') {
+function validate$R(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 + '")');
@@ -4488,7 +3903,7 @@ function validate$N(obj, path = 'ManagedContentFailedVariantsRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$M(obj, path = 'ManagedContentClonedVariantRepresentation') {
+function validate$Q(obj, path = 'ManagedContentClonedVariantRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4533,14 +3948,14 @@ function validate$M(obj, path = 'ManagedContentClonedVariantRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$L(obj, path = 'ManagedContentCloneRepresentation') {
+function validate$P(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$O(obj_cloneStatus, path_cloneStatus);
+        const referencepath_cloneStatusValidationError = validate$S(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');
@@ -4611,7 +4026,7 @@ function validate$L(obj, path = 'ManagedContentCloneRepresentation') {
             for (let i = 0; i < obj_failedVariants.length; i++) {
                 const obj_failedVariants_item = obj_failedVariants[i];
                 const path_failedVariants_item = path_failedVariants + '[' + i + ']';
-                const referencepath_failedVariants_itemValidationError = validate$N(obj_failedVariants_item, path_failedVariants_item);
+                const referencepath_failedVariants_itemValidationError = validate$R(obj_failedVariants_item, path_failedVariants_item);
                 if (referencepath_failedVariants_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ManagedContentFailedVariantsRepresentation (at "' + path_failedVariants_item + '")\n';
                     message += referencepath_failedVariants_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -4717,7 +4132,7 @@ function validate$L(obj, path = 'ManagedContentCloneRepresentation') {
             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$M(obj_variants_item, path_variants_item);
+                const referencepath_variants_itemValidationError = validate$Q(obj_variants_item, path_variants_item);
                 if (referencepath_variants_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ManagedContentClonedVariantRepresentation (at "' + path_variants_item + '")\n';
                     message += referencepath_variants_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -4729,9 +4144,9 @@ function validate$L(obj, path = 'ManagedContentCloneRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$m = 100;
-const VERSION$n = "cd2506a860c4f555d401c1c68ff97158";
-function validate$K(obj, path = 'ManagedContentCloneCollectionRepresentation') {
+const TTL$o = 100;
+const VERSION$q = "cd2506a860c4f555d401c1c68ff97158";
+function validate$O(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 + '")');
@@ -4744,7 +4159,7 @@ function validate$K(obj, path = 'ManagedContentCloneCollectionRepresentation') {
         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$L(obj_contents_item, path_contents_item);
+            const referencepath_contents_itemValidationError = validate$P(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');
@@ -4759,68 +4174,68 @@ function validate$K(obj, path = 'ManagedContentCloneCollectionRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$m = 'ManagedContentCloneCollectionRepresentation';
-function keyBuilder$N(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$m + ':' + config.id;
+const RepresentationType$p = 'ManagedContentCloneCollectionRepresentation';
+function keyBuilder$Q(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$p + ':' + config.id;
 }
-function keyBuilderFromType$a(luvio, object) {
+function keyBuilderFromType$b(luvio, object) {
     const keyParams = {
         id: object.id
     };
-    return keyBuilder$N(luvio, keyParams);
+    return keyBuilder$Q(luvio, keyParams);
 }
-function normalize$m(input, existing, path, luvio, store, timestamp) {
+function normalize$p(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$U = function ManagedContentCloneCollectionRepresentationSelect() {
+const select$Z = function ManagedContentCloneCollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$n,
+        version: VERSION$q,
         private: [],
         opaque: true
     };
 };
-function equals$n(existing, incoming) {
+function equals$q(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$m = function ManagedContentCloneCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$p = function ManagedContentCloneCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$K(input);
+        const validateError = validate$O(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    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);
+    const key = keyBuilderFromType$b(luvio, input);
+    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$m(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$p(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$p,
         mergeable: false
     });
 }
 
-function select$T(luvio, params) {
-    return select$U();
+function select$Y(luvio, params) {
+    return select$Z();
 }
-function getResponseCacheKeys$x(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$m(storeKeyMap, luvio, response);
+function getResponseCacheKeys$z(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$p(storeKeyMap, luvio, response);
 }
-function ingestSuccess$w(luvio, resourceParams, response) {
+function ingestSuccess$y(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$p, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$T(),
+        node: select$Y(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -4831,7 +4246,7 @@ function ingestSuccess$w(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$x(config) {
+function createResourceRequest$z(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -4845,15 +4260,15 @@ function createResourceRequest$x(config) {
     };
 }
 
-const adapterName$x = 'cloneManagedContents';
+const adapterName$z = '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 cloneManagedContents_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$x, cloneManagedContents_ConfigPropertyMetadata);
-const createResourceParams$x = /*#__PURE__*/ createResourceParams$I(cloneManagedContents_ConfigPropertyMetadata);
-function typeCheckConfig$x(untrustedConfig) {
+const cloneManagedContents_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$z, cloneManagedContents_ConfigPropertyMetadata);
+const createResourceParams$z = /*#__PURE__*/ createResourceParams$I(cloneManagedContents_ConfigPropertyMetadata);
+function typeCheckConfig$z(untrustedConfig) {
     const config = {};
     typeCheckConfig$I(untrustedConfig, config, cloneManagedContents_ConfigPropertyMetadata);
     const untrustedConfig_contents = untrustedConfig.contents;
@@ -4861,7 +4276,7 @@ function typeCheckConfig$x(untrustedConfig) {
         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$P(untrustedConfig_contents_item);
+            const referenceManagedContentCloneItemRepresentationValidationError = validate$T(untrustedConfig_contents_item);
             if (referenceManagedContentCloneItemRepresentationValidationError === null) {
                 untrustedConfig_contents_array.push(untrustedConfig_contents_item);
             }
@@ -4870,30 +4285,30 @@ function typeCheckConfig$x(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$x(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$z(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$x(untrustedConfig);
+    const config = typeCheckConfig$z(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$x(luvio, config, options) {
-    const resourceParams = createResourceParams$x(config);
-    const request = createResourceRequest$x(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(() => {
-            const snapshot = ingestSuccess$w(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$y(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$x(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$z(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -4903,18 +4318,18 @@ function buildNetworkSnapshot$x(luvio, config, options) {
 }
 const cloneManagedContentsAdapterFactory = (luvio) => {
     return function cloneManagedContents(untrustedConfig) {
-        const config = validateAdapterConfig$x(untrustedConfig, cloneManagedContents_ConfigPropertyNames);
+        const config = validateAdapterConfig$z(untrustedConfig, cloneManagedContents_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "cloneManagedContents"');
         }
-        return buildNetworkSnapshot$x(luvio, config);
+        return buildNetworkSnapshot$z(luvio, config);
     };
 };
 
-const TTL$l = 100;
-const VERSION$m = "17d0c7553970a191d9ac970ac0cd8666";
-function validate$J(obj, path = 'ManagedContentFileUploadRepresentation') {
+const TTL$n = 100;
+const VERSION$p = "17d0c7553970a191d9ac970ac0cd8666";
+function validate$N(obj, path = 'ManagedContentFileUploadRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4932,14 +4347,14 @@ function validate$J(obj, path = 'ManagedContentFileUploadRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$l = 'ManagedContentFileUploadRepresentation';
-function normalize$l(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$o = 'ManagedContentFileUploadRepresentation';
+function normalize$o(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$S = function ManagedContentFileUploadRepresentationSelect() {
+const select$X = function ManagedContentFileUploadRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$m,
+        version: VERSION$p,
         private: [],
         selections: [
             {
@@ -4953,7 +4368,7 @@ const select$S = function ManagedContentFileUploadRepresentationSelect() {
         ]
     };
 };
-function equals$m(existing, incoming) {
+function equals$p(existing, incoming) {
     const existing_token = existing.token;
     const incoming_token = incoming.token;
     if (!(existing_token === incoming_token)) {
@@ -4966,44 +4381,44 @@ function equals$m(existing, incoming) {
     }
     return true;
 }
-const ingest$l = function ManagedContentFileUploadRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$o = function ManagedContentFileUploadRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$J(input);
+        const validateError = validate$N(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = path.fullPath;
-    const ttlToUse = TTL$l;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$l, "CMSAuthoring", VERSION$m, RepresentationType$l, equals$m);
+    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$l(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$o(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$o,
         mergeable: false
     });
 }
 
-function select$R(luvio, params) {
-    return select$S();
+function select$W(luvio, params) {
+    return select$X();
 }
-function keyBuilder$M(luvio, params) {
+function keyBuilder$P(luvio, params) {
     return keyPrefix + '::ManagedContentFileUploadRepresentation:(' + ')';
 }
-function getResponseCacheKeys$w(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$l(storeKeyMap, luvio, response, () => keyBuilder$M());
+function getResponseCacheKeys$y(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$o(storeKeyMap, luvio, response, () => keyBuilder$P());
 }
-function ingestSuccess$v(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$x(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$M();
-    luvio.storeIngest(key, ingest$l, body);
+    const key = keyBuilder$P();
+    luvio.storeIngest(key, ingest$o, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$R(),
+        node: select$W(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -5014,19 +4429,19 @@ function ingestSuccess$v(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$i(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$M();
+function ingestError$j(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$P();
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$l,
+        ttl: TTL$n,
         namespace: keyPrefix,
-        version: VERSION$m,
-        representationName: RepresentationType$l
+        version: VERSION$p,
+        representationName: RepresentationType$o
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$w(config) {
+function createResourceRequest$y(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -5040,90 +4455,90 @@ function createResourceRequest$w(config) {
     };
 }
 
-const adapterName$w = 'getManagedContentFileUploadConfig';
+const adapterName$y = 'getManagedContentFileUploadConfig';
 const getManagedContentFileUploadConfig_ConfigPropertyMetadata = [];
-const getManagedContentFileUploadConfig_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$w, getManagedContentFileUploadConfig_ConfigPropertyMetadata);
-const createResourceParams$w = /*#__PURE__*/ createResourceParams$I(getManagedContentFileUploadConfig_ConfigPropertyMetadata);
-function keyBuilder$L(luvio, config) {
-    createResourceParams$w(config);
-    return keyBuilder$M();
+const getManagedContentFileUploadConfig_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$y, getManagedContentFileUploadConfig_ConfigPropertyMetadata);
+const createResourceParams$y = /*#__PURE__*/ createResourceParams$I(getManagedContentFileUploadConfig_ConfigPropertyMetadata);
+function keyBuilder$O(luvio, config) {
+    createResourceParams$y(config);
+    return keyBuilder$P();
 }
-function typeCheckConfig$w(untrustedConfig) {
+function typeCheckConfig$y(untrustedConfig) {
     const config = {};
     return config;
 }
-function validateAdapterConfig$w(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$y(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$w();
+    const config = typeCheckConfig$y();
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$i(luvio, config) {
-    createResourceParams$w(config);
-    return select$R();
+function adapterFragment$j(luvio, config) {
+    createResourceParams$y(config);
+    return select$W();
 }
-function onFetchResponseSuccess$k(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$v(luvio, resourceParams, response, {
+function onFetchResponseSuccess$l(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$x(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$w(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, {
+function onFetchResponseError$j(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$j(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$w(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$y(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$w(luvio, config, options) {
-    const resourceParams = createResourceParams$w(config);
-    const request = createResourceRequest$w();
+function buildNetworkSnapshot$y(luvio, config, options) {
+    const resourceParams = createResourceParams$y(config);
+    const request = createResourceRequest$y();
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$k(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$l(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$w(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$y(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$i(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$j(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$p(context, coercedAdapterRequestContext, buildNetworkSnapshot$w, undefined, false);
+function buildNetworkSnapshotCachePolicy$j(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$p(context, coercedAdapterRequestContext, buildNetworkSnapshot$y, undefined, false);
 }
-function buildCachedSnapshotCachePolicy$i(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$j(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$L(luvio, config),
-        node: adapterFragment$i(luvio, config),
+        recordId: keyBuilder$O(luvio, config),
+        node: adapterFragment$j(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$w(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$y(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getManagedContentFileUploadConfigAdapterFactory = (luvio) => function CMSAuthoring__getManagedContentFileUploadConfig(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$w(untrustedConfig, getManagedContentFileUploadConfig_ConfigPropertyNames);
+    const config = validateAdapterConfig$y(untrustedConfig, getManagedContentFileUploadConfig_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$i, buildNetworkSnapshotCachePolicy$i);
+    buildCachedSnapshotCachePolicy$j, buildNetworkSnapshotCachePolicy$j);
 };
 
-function validate$I(obj, path = 'ManagedContentPublishInputRepresentation') {
+function validate$M(obj, path = 'ManagedContentPublishInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5181,9 +4596,9 @@ function validate$I(obj, path = 'ManagedContentPublishInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$k = 100;
-const VERSION$l = "789bce2e581ff7969982fbf2ffbfd9a5";
-function validate$H(obj, path = 'ManagedContentPublishOutputRepresentation') {
+const TTL$m = 100;
+const VERSION$o = "789bce2e581ff7969982fbf2ffbfd9a5";
+function validate$L(obj, path = 'ManagedContentPublishOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5248,68 +4663,68 @@ function validate$H(obj, path = 'ManagedContentPublishOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$k = 'ManagedContentPublishOutputRepresentation';
-function keyBuilder$K(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$k + ':' + config.id;
+const RepresentationType$n = 'ManagedContentPublishOutputRepresentation';
+function keyBuilder$N(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$n + ':' + config.id;
 }
-function keyBuilderFromType$9(luvio, object) {
+function keyBuilderFromType$a(luvio, object) {
     const keyParams = {
         id: object.deploymentId
     };
-    return keyBuilder$K(luvio, keyParams);
+    return keyBuilder$N(luvio, keyParams);
 }
-function normalize$k(input, existing, path, luvio, store, timestamp) {
+function normalize$n(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$Q = function ManagedContentPublishOutputRepresentationSelect() {
+const select$V = function ManagedContentPublishOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$l,
+        version: VERSION$o,
         private: [],
         opaque: true
     };
 };
-function equals$l(existing, incoming) {
+function equals$o(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$k = function ManagedContentPublishOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$n = function ManagedContentPublishOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$H(input);
+        const validateError = validate$L(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$9(luvio, input);
-    const ttlToUse = TTL$k;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$k, "CMSAuthoring", VERSION$l, RepresentationType$k, equals$l);
+    const key = keyBuilderFromType$a(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$k(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$n(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$k,
+        representationName: RepresentationType$n,
         mergeable: false
     });
 }
 
-function select$P(luvio, params) {
-    return select$Q();
+function select$U(luvio, params) {
+    return select$V();
 }
-function getResponseCacheKeys$v(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$k(storeKeyMap, luvio, response);
+function getResponseCacheKeys$x(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$n(storeKeyMap, luvio, response);
 }
-function ingestSuccess$u(luvio, resourceParams, response) {
+function ingestSuccess$w(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$9(luvio, body);
-    luvio.storeIngest(key, ingest$k, body);
+    const key = keyBuilderFromType$a(luvio, body);
+    luvio.storeIngest(key, ingest$n, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$P(),
+        node: select$U(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -5320,7 +4735,7 @@ function ingestSuccess$u(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$v(config) {
+function createResourceRequest$x(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -5334,45 +4749,45 @@ function createResourceRequest$v(config) {
     };
 }
 
-const adapterName$v = 'publishManagedContent';
+const adapterName$x = 'publishManagedContent';
 const publishManagedContent_ConfigPropertyMetadata = [
     generateParamConfigMetadata('publishInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const publishManagedContent_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$v, publishManagedContent_ConfigPropertyMetadata);
-const createResourceParams$v = /*#__PURE__*/ createResourceParams$I(publishManagedContent_ConfigPropertyMetadata);
-function typeCheckConfig$v(untrustedConfig) {
+const publishManagedContent_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$x, publishManagedContent_ConfigPropertyMetadata);
+const createResourceParams$x = /*#__PURE__*/ createResourceParams$I(publishManagedContent_ConfigPropertyMetadata);
+function typeCheckConfig$x(untrustedConfig) {
     const config = {};
     const untrustedConfig_publishInput = untrustedConfig.publishInput;
-    const referenceManagedContentPublishInputRepresentationValidationError = validate$I(untrustedConfig_publishInput);
+    const referenceManagedContentPublishInputRepresentationValidationError = validate$M(untrustedConfig_publishInput);
     if (referenceManagedContentPublishInputRepresentationValidationError === null) {
         config.publishInput = untrustedConfig_publishInput;
     }
     return config;
 }
-function validateAdapterConfig$v(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$x(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$v(untrustedConfig);
+    const config = typeCheckConfig$x(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$v(luvio, config, options) {
-    const resourceParams = createResourceParams$v(config);
-    const request = createResourceRequest$v(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(() => {
-            const snapshot = ingestSuccess$u(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$w(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$v(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$x(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -5382,16 +4797,16 @@ function buildNetworkSnapshot$v(luvio, config, options) {
 }
 const publishManagedContentAdapterFactory = (luvio) => {
     return function publishManagedContent(untrustedConfig) {
-        const config = validateAdapterConfig$v(untrustedConfig, publishManagedContent_ConfigPropertyNames);
+        const config = validateAdapterConfig$x(untrustedConfig, publishManagedContent_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "publishManagedContent"');
         }
-        return buildNetworkSnapshot$v(luvio, config);
+        return buildNetworkSnapshot$x(luvio, config);
     };
 };
 
-function validate$G(obj, path = 'ManagedContentUnpublishInputRepresentation') {
+function validate$K(obj, path = 'ManagedContentUnpublishInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5435,9 +4850,9 @@ function validate$G(obj, path = 'ManagedContentUnpublishInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$j = 100;
-const VERSION$k = "2f473ff12e87a4fc2336695104ab8567";
-function validate$F(obj, path = 'ManagedContentUnpublishOutputRepresentation') {
+const TTL$l = 100;
+const VERSION$n = "2f473ff12e87a4fc2336695104ab8567";
+function validate$J(obj, path = 'ManagedContentUnpublishOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5502,68 +4917,68 @@ function validate$F(obj, path = 'ManagedContentUnpublishOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$j = 'ManagedContentUnpublishOutputRepresentation';
-function keyBuilder$J(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$j + ':' + config.id;
+const RepresentationType$m = 'ManagedContentUnpublishOutputRepresentation';
+function keyBuilder$M(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$m + ':' + config.id;
 }
-function keyBuilderFromType$8(luvio, object) {
+function keyBuilderFromType$9(luvio, object) {
     const keyParams = {
         id: object.deploymentId
     };
-    return keyBuilder$J(luvio, keyParams);
+    return keyBuilder$M(luvio, keyParams);
 }
-function normalize$j(input, existing, path, luvio, store, timestamp) {
+function normalize$m(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$O = function ManagedContentUnpublishOutputRepresentationSelect() {
+const select$T = function ManagedContentUnpublishOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$k,
+        version: VERSION$n,
         private: [],
         opaque: true
     };
 };
-function equals$k(existing, incoming) {
+function equals$n(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$j = function ManagedContentUnpublishOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$m = function ManagedContentUnpublishOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$F(input);
+        const validateError = validate$J(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$8(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$9(luvio, input);
+    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$j(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$m(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$j,
+        representationName: RepresentationType$m,
         mergeable: false
     });
 }
 
-function select$N(luvio, params) {
-    return select$O();
+function select$S(luvio, params) {
+    return select$T();
 }
-function getResponseCacheKeys$u(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$j(storeKeyMap, luvio, response);
+function getResponseCacheKeys$w(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$m(storeKeyMap, luvio, response);
 }
-function ingestSuccess$t(luvio, resourceParams, response) {
+function ingestSuccess$v(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$8(luvio, body);
-    luvio.storeIngest(key, ingest$j, body);
+    const key = keyBuilderFromType$9(luvio, body);
+    luvio.storeIngest(key, ingest$m, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$N(),
+        node: select$S(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -5574,7 +4989,7 @@ function ingestSuccess$t(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$u(config) {
+function createResourceRequest$w(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -5588,45 +5003,45 @@ function createResourceRequest$u(config) {
     };
 }
 
-const adapterName$u = 'unpublishManagedContent';
+const adapterName$w = 'unpublishManagedContent';
 const unpublishManagedContent_ConfigPropertyMetadata = [
     generateParamConfigMetadata('unpublishInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const unpublishManagedContent_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$u, unpublishManagedContent_ConfigPropertyMetadata);
-const createResourceParams$u = /*#__PURE__*/ createResourceParams$I(unpublishManagedContent_ConfigPropertyMetadata);
-function typeCheckConfig$u(untrustedConfig) {
+const unpublishManagedContent_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$w, unpublishManagedContent_ConfigPropertyMetadata);
+const createResourceParams$w = /*#__PURE__*/ createResourceParams$I(unpublishManagedContent_ConfigPropertyMetadata);
+function typeCheckConfig$w(untrustedConfig) {
     const config = {};
     const untrustedConfig_unpublishInput = untrustedConfig.unpublishInput;
-    const referenceManagedContentUnpublishInputRepresentationValidationError = validate$G(untrustedConfig_unpublishInput);
+    const referenceManagedContentUnpublishInputRepresentationValidationError = validate$K(untrustedConfig_unpublishInput);
     if (referenceManagedContentUnpublishInputRepresentationValidationError === null) {
         config.unpublishInput = untrustedConfig_unpublishInput;
     }
     return config;
 }
-function validateAdapterConfig$u(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$w(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$u(untrustedConfig);
+    const config = typeCheckConfig$w(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$w(luvio, config, options) {
+    const resourceParams = createResourceParams$w(config);
+    const request = createResourceRequest$w(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$t(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$w(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -5636,16 +5051,16 @@ function buildNetworkSnapshot$u(luvio, config, options) {
 }
 const unpublishManagedContentAdapterFactory = (luvio) => {
     return function unpublishManagedContent(untrustedConfig) {
-        const config = validateAdapterConfig$u(untrustedConfig, unpublishManagedContent_ConfigPropertyNames);
+        const config = validateAdapterConfig$w(untrustedConfig, unpublishManagedContent_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "unpublishManagedContent"');
         }
-        return buildNetworkSnapshot$u(luvio, config);
+        return buildNetworkSnapshot$w(luvio, config);
     };
 };
 
-function validate$E(obj, path = 'ManagedContentVariantInputRepresentation') {
+function validate$I(obj, path = 'ManagedContentVariantInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5692,9 +5107,9 @@ function validate$E(obj, path = 'ManagedContentVariantInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$i = 3600000;
-const VERSION$j = "7752c6a8bb6b113a02bfde83f39e5957";
-function validate$D(obj, path = 'ManagedContentVariantRepresentation') {
+const TTL$k = 3600000;
+const VERSION$m = "7752c6a8bb6b113a02bfde83f39e5957";
+function validate$H(obj, path = 'ManagedContentVariantRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5720,7 +5135,7 @@ function validate$D(obj, path = 'ManagedContentVariantRepresentation') {
         }
         const obj_contentSpace = obj.contentSpace;
         const path_contentSpace = path + '.contentSpace';
-        const referencepath_contentSpaceValidationError = validate$T(obj_contentSpace, path_contentSpace);
+        const referencepath_contentSpaceValidationError = validate$X(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');
@@ -5749,7 +5164,7 @@ function validate$D(obj, path = 'ManagedContentVariantRepresentation') {
         }
         const obj_folder = obj.folder;
         const path_folder = path + '.folder';
-        const referencepath_folderValidationError = validate$S(obj_folder, path_folder);
+        const referencepath_folderValidationError = validate$W(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');
@@ -5795,7 +5210,7 @@ function validate$D(obj, path = 'ManagedContentVariantRepresentation') {
         }
         const obj_status = obj.status;
         const path_status = path + '.status';
-        const referencepath_statusValidationError = validate$R(obj_status, path_status);
+        const referencepath_statusValidationError = validate$V(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');
@@ -5814,68 +5229,68 @@ function validate$D(obj, path = 'ManagedContentVariantRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$i = 'ManagedContentVariantRepresentation';
-function keyBuilder$I(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$i + ':' + config.id;
+const RepresentationType$l = 'ManagedContentVariantRepresentation';
+function keyBuilder$L(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$l + ':' + config.id;
 }
-function keyBuilderFromType$7(luvio, object) {
+function keyBuilderFromType$8(luvio, object) {
     const keyParams = {
         id: object.managedContentVariantId
     };
-    return keyBuilder$I(luvio, keyParams);
+    return keyBuilder$L(luvio, keyParams);
 }
-function normalize$i(input, existing, path, luvio, store, timestamp) {
+function normalize$l(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$M = function ManagedContentVariantRepresentationSelect() {
+const select$R = function ManagedContentVariantRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$j,
+        version: VERSION$m,
         private: [],
         opaque: true
     };
 };
-function equals$j(existing, incoming) {
+function equals$m(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$i = function ManagedContentVariantRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$l = function ManagedContentVariantRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$D(input);
+        const validateError = validate$H(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$7(luvio, input);
-    const ttlToUse = TTL$i;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$i, "CMSAuthoring", VERSION$j, RepresentationType$i, equals$j);
+    const key = keyBuilderFromType$8(luvio, input);
+    const ttlToUse = TTL$k;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$l, "CMSAuthoring", VERSION$m, RepresentationType$l, equals$m);
     return createLink(key);
 };
-function getTypeCacheKeys$i(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$l(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$i,
+        representationName: RepresentationType$l,
         mergeable: false
     });
 }
 
-function select$L(luvio, params) {
-    return select$M();
+function select$Q(luvio, params) {
+    return select$R();
 }
-function getResponseCacheKeys$t(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$i(storeKeyMap, luvio, response);
+function getResponseCacheKeys$v(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$l(storeKeyMap, luvio, response);
 }
-function ingestSuccess$s(luvio, resourceParams, response) {
+function ingestSuccess$u(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$7(luvio, body);
-    luvio.storeIngest(key, ingest$i, body);
+    const key = keyBuilderFromType$8(luvio, body);
+    luvio.storeIngest(key, ingest$l, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$L(),
+        node: select$Q(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -5886,7 +5301,7 @@ function ingestSuccess$s(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$t(config) {
+function createResourceRequest$v(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -5900,45 +5315,45 @@ function createResourceRequest$t(config) {
     };
 }
 
-const adapterName$t = 'createManagedContentVariant';
+const adapterName$v = 'createManagedContentVariant';
 const createManagedContentVariant_ConfigPropertyMetadata = [
     generateParamConfigMetadata('managedContentVariantInputParam', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const createManagedContentVariant_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$t, createManagedContentVariant_ConfigPropertyMetadata);
-const createResourceParams$t = /*#__PURE__*/ createResourceParams$I(createManagedContentVariant_ConfigPropertyMetadata);
-function typeCheckConfig$t(untrustedConfig) {
+const createManagedContentVariant_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$v, createManagedContentVariant_ConfigPropertyMetadata);
+const createResourceParams$v = /*#__PURE__*/ createResourceParams$I(createManagedContentVariant_ConfigPropertyMetadata);
+function typeCheckConfig$v(untrustedConfig) {
     const config = {};
     const untrustedConfig_managedContentVariantInputParam = untrustedConfig.managedContentVariantInputParam;
-    const referenceManagedContentVariantInputRepresentationValidationError = validate$E(untrustedConfig_managedContentVariantInputParam);
+    const referenceManagedContentVariantInputRepresentationValidationError = validate$I(untrustedConfig_managedContentVariantInputParam);
     if (referenceManagedContentVariantInputRepresentationValidationError === null) {
         config.managedContentVariantInputParam = untrustedConfig_managedContentVariantInputParam;
     }
     return config;
 }
-function validateAdapterConfig$t(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$v(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$t(untrustedConfig);
+    const config = typeCheckConfig$v(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$t(luvio, config, options) {
-    const resourceParams = createResourceParams$t(config);
-    const request = createResourceRequest$t(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$s(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$u(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$t(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$v(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -5948,33 +5363,33 @@ function buildNetworkSnapshot$t(luvio, config, options) {
 }
 const createManagedContentVariantAdapterFactory = (luvio) => {
     return function createManagedContentVariant(untrustedConfig) {
-        const config = validateAdapterConfig$t(untrustedConfig, createManagedContentVariant_ConfigPropertyNames);
+        const config = validateAdapterConfig$v(untrustedConfig, createManagedContentVariant_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createManagedContentVariant"');
         }
-        return buildNetworkSnapshot$t(luvio, config);
+        return buildNetworkSnapshot$v(luvio, config);
     };
 };
 
-function keyBuilder$H(luvio, params) {
-    return keyBuilder$I(luvio, {
+function keyBuilder$K(luvio, params) {
+    return keyBuilder$L(luvio, {
         id: params.urlParams.variantId
     });
 }
-function getResponseCacheKeys$s(cacheKeyMap, luvio, resourceParams) {
-    const key = keyBuilder$H(luvio, resourceParams);
+function getResponseCacheKeys$u(cacheKeyMap, luvio, resourceParams) {
+    const key = keyBuilder$K(luvio, resourceParams);
     cacheKeyMap.set(key, {
         namespace: keyPrefix,
-        representationName: RepresentationType$i,
+        representationName: RepresentationType$l,
         mergeable: false
     });
 }
 function evictSuccess(luvio, resourceParams) {
-    const key = keyBuilder$H(luvio, resourceParams);
+    const key = keyBuilder$K(luvio, resourceParams);
     luvio.storeEvict(key);
 }
-function createResourceRequest$s(config) {
+function createResourceRequest$u(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -5988,33 +5403,33 @@ function createResourceRequest$s(config) {
     };
 }
 
-const adapterName$s = 'deleteManagedContentVariant';
+const adapterName$u = 'deleteManagedContentVariant';
 const deleteManagedContentVariant_ConfigPropertyMetadata = [
     generateParamConfigMetadata('variantId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const deleteManagedContentVariant_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$s, deleteManagedContentVariant_ConfigPropertyMetadata);
-const createResourceParams$s = /*#__PURE__*/ createResourceParams$I(deleteManagedContentVariant_ConfigPropertyMetadata);
-function typeCheckConfig$s(untrustedConfig) {
+const deleteManagedContentVariant_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$u, deleteManagedContentVariant_ConfigPropertyMetadata);
+const createResourceParams$u = /*#__PURE__*/ createResourceParams$I(deleteManagedContentVariant_ConfigPropertyMetadata);
+function typeCheckConfig$u(untrustedConfig) {
     const config = {};
     typeCheckConfig$I(untrustedConfig, config, deleteManagedContentVariant_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$s(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$u(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$s(untrustedConfig);
+    const config = typeCheckConfig$u(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$u(luvio, config, options) {
+    const resourceParams = createResourceParams$u(config);
+    const request = createResourceRequest$u(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then(() => {
         return luvio.handleSuccessResponse(() => {
@@ -6022,7 +5437,7 @@ function buildNetworkSnapshot$s(luvio, config, options) {
             return luvio.storeBroadcast();
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$s(cache, luvio, resourceParams);
+            getResponseCacheKeys$u(cache, luvio, resourceParams);
             return cache;
         });
     }, (response) => {
@@ -6032,33 +5447,33 @@ function buildNetworkSnapshot$s(luvio, config, options) {
 }
 const deleteManagedContentVariantAdapterFactory = (luvio) => {
     return function CMSAuthoringdeleteManagedContentVariant(untrustedConfig) {
-        const config = validateAdapterConfig$s(untrustedConfig, deleteManagedContentVariant_ConfigPropertyNames);
+        const config = validateAdapterConfig$u(untrustedConfig, deleteManagedContentVariant_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error(`Invalid config for "${adapterName$s}"`);
+            throw new Error(`Invalid config for "${adapterName$u}"`);
         }
-        return buildNetworkSnapshot$s(luvio, config);
+        return buildNetworkSnapshot$u(luvio, config);
     };
 };
 
-function select$K(luvio, params) {
-    return select$M();
+function select$P(luvio, params) {
+    return select$R();
 }
-function keyBuilder$G(luvio, params) {
-    return keyBuilder$I(luvio, {
+function keyBuilder$J(luvio, params) {
+    return keyBuilder$L(luvio, {
         id: params.urlParams.variantId
     });
 }
-function getResponseCacheKeys$r(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$i(storeKeyMap, luvio, response);
+function getResponseCacheKeys$t(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$l(storeKeyMap, luvio, response);
 }
-function ingestSuccess$r(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$t(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$G(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$i, body);
+    const key = keyBuilder$J(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$l, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$K(),
+        node: select$P(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -6069,19 +5484,19 @@ function ingestSuccess$r(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$h(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$G(luvio, params);
+function ingestError$i(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$J(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$i,
+        ttl: TTL$k,
         namespace: keyPrefix,
-        version: VERSION$j,
-        representationName: RepresentationType$i
+        version: VERSION$m,
+        representationName: RepresentationType$l
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$r(config) {
+function createResourceRequest$t(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -6095,93 +5510,93 @@ function createResourceRequest$r(config) {
     };
 }
 
-const adapterName$r = 'getManagedContentVariant';
+const adapterName$t = 'getManagedContentVariant';
 const getManagedContentVariant_ConfigPropertyMetadata = [
     generateParamConfigMetadata('variantId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getManagedContentVariant_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$r, getManagedContentVariant_ConfigPropertyMetadata);
-const createResourceParams$r = /*#__PURE__*/ createResourceParams$I(getManagedContentVariant_ConfigPropertyMetadata);
-function keyBuilder$F(luvio, config) {
-    const resourceParams = createResourceParams$r(config);
-    return keyBuilder$G(luvio, resourceParams);
+const getManagedContentVariant_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$t, getManagedContentVariant_ConfigPropertyMetadata);
+const createResourceParams$t = /*#__PURE__*/ createResourceParams$I(getManagedContentVariant_ConfigPropertyMetadata);
+function keyBuilder$I(luvio, config) {
+    const resourceParams = createResourceParams$t(config);
+    return keyBuilder$J(luvio, resourceParams);
 }
-function typeCheckConfig$r(untrustedConfig) {
+function typeCheckConfig$t(untrustedConfig) {
     const config = {};
     typeCheckConfig$I(untrustedConfig, config, getManagedContentVariant_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$r(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$t(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$r(untrustedConfig);
+    const config = typeCheckConfig$t(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$h(luvio, config) {
-    createResourceParams$r(config);
-    return select$K();
+function adapterFragment$i(luvio, config) {
+    createResourceParams$t(config);
+    return select$P();
 }
-function onFetchResponseSuccess$j(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$r(luvio, resourceParams, response, {
+function onFetchResponseSuccess$k(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$t(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$r(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$t(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$h(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$h(luvio, resourceParams, response, {
+function onFetchResponseError$i(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$i(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$r(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$t(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$r(luvio, config, options) {
-    const resourceParams = createResourceParams$r(config);
-    const request = createResourceRequest$r(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(() => onFetchResponseSuccess$j(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$k(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$r(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$t(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$h(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$i(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$p(context, coercedAdapterRequestContext, buildNetworkSnapshot$r, undefined, false);
+function buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$p(context, coercedAdapterRequestContext, buildNetworkSnapshot$t, undefined, false);
 }
-function buildCachedSnapshotCachePolicy$h(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$i(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$F(luvio, config),
-        node: adapterFragment$h(luvio, config),
+        recordId: keyBuilder$I(luvio, config),
+        node: adapterFragment$i(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$r(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$t(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getManagedContentVariantAdapterFactory = (luvio) => function CMSAuthoring__getManagedContentVariant(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$r(untrustedConfig, getManagedContentVariant_ConfigPropertyNames);
+    const config = validateAdapterConfig$t(untrustedConfig, getManagedContentVariant_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$h, buildNetworkSnapshotCachePolicy$h);
+    buildCachedSnapshotCachePolicy$i, buildNetworkSnapshotCachePolicy$i);
 };
 
-function validate$C(obj, path = 'ManagedContentVariantUpdateInputRepresentation') {
+function validate$G(obj, path = 'ManagedContentVariantUpdateInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -6218,19 +5633,19 @@ function validate$C(obj, path = 'ManagedContentVariantUpdateInputRepresentation'
     return v_error === undefined ? null : v_error;
 }
 
-function select$J(luvio, params) {
-    return select$M();
+function select$O(luvio, params) {
+    return select$R();
 }
-function getResponseCacheKeys$q(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$i(storeKeyMap, luvio, response);
+function getResponseCacheKeys$s(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$l(storeKeyMap, luvio, response);
 }
-function ingestSuccess$q(luvio, resourceParams, response) {
+function ingestSuccess$s(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$7(luvio, body);
-    luvio.storeIngest(key, ingest$i, body);
+    const key = keyBuilderFromType$8(luvio, body);
+    luvio.storeIngest(key, ingest$l, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$J(),
+        node: select$O(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -6241,7 +5656,7 @@ function ingestSuccess$q(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$q(config) {
+function createResourceRequest$s(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -6255,47 +5670,47 @@ function createResourceRequest$q(config) {
     };
 }
 
-const adapterName$q = 'replaceManagedContentVariant';
+const adapterName$s = 'replaceManagedContentVariant';
 const replaceManagedContentVariant_ConfigPropertyMetadata = [
     generateParamConfigMetadata('variantId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('ManagedContentVariantInputParam', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const replaceManagedContentVariant_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$q, replaceManagedContentVariant_ConfigPropertyMetadata);
-const createResourceParams$q = /*#__PURE__*/ createResourceParams$I(replaceManagedContentVariant_ConfigPropertyMetadata);
-function typeCheckConfig$q(untrustedConfig) {
+const replaceManagedContentVariant_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$s, replaceManagedContentVariant_ConfigPropertyMetadata);
+const createResourceParams$s = /*#__PURE__*/ createResourceParams$I(replaceManagedContentVariant_ConfigPropertyMetadata);
+function typeCheckConfig$s(untrustedConfig) {
     const config = {};
     typeCheckConfig$I(untrustedConfig, config, replaceManagedContentVariant_ConfigPropertyMetadata);
     const untrustedConfig_ManagedContentVariantInputParam = untrustedConfig.ManagedContentVariantInputParam;
-    const referenceManagedContentVariantUpdateInputRepresentationValidationError = validate$C(untrustedConfig_ManagedContentVariantInputParam);
+    const referenceManagedContentVariantUpdateInputRepresentationValidationError = validate$G(untrustedConfig_ManagedContentVariantInputParam);
     if (referenceManagedContentVariantUpdateInputRepresentationValidationError === null) {
         config.ManagedContentVariantInputParam = untrustedConfig_ManagedContentVariantInputParam;
     }
     return config;
 }
-function validateAdapterConfig$q(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$s(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$q(untrustedConfig);
+    const config = typeCheckConfig$s(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$q(luvio, config, options) {
-    const resourceParams = createResourceParams$q(config);
-    const request = createResourceRequest$q(resourceParams);
+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$q(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$s(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$q(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$s(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -6305,16 +5720,16 @@ function buildNetworkSnapshot$q(luvio, config, options) {
 }
 const replaceManagedContentVariantAdapterFactory = (luvio) => {
     return function replaceManagedContentVariant(untrustedConfig) {
-        const config = validateAdapterConfig$q(untrustedConfig, replaceManagedContentVariant_ConfigPropertyNames);
+        const config = validateAdapterConfig$s(untrustedConfig, replaceManagedContentVariant_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "replaceManagedContentVariant"');
         }
-        return buildNetworkSnapshot$q(luvio, config);
+        return buildNetworkSnapshot$s(luvio, config);
     };
 };
 
-function validate$B(obj, path = 'ManagedContentVariantVersionRepresentation') {
+function validate$F(obj, path = 'ManagedContentVariantVersionRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -6352,7 +5767,7 @@ function validate$B(obj, path = 'ManagedContentVariantVersionRepresentation') {
         }
         const obj_status = obj.status;
         const path_status = path + '.status';
-        const referencepath_statusValidationError = validate$R(obj_status, path_status);
+        const referencepath_statusValidationError = validate$V(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');
@@ -6372,9 +5787,9 @@ function validate$B(obj, path = 'ManagedContentVariantVersionRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$h = 100;
-const VERSION$i = "993f4fe3a5b12699f037079dbe30610b";
-function validate$A(obj, path = 'ManagedContentVariantVersionCollectionRepresentation') {
+const TTL$j = 100;
+const VERSION$l = "993f4fe3a5b12699f037079dbe30610b";
+function validate$E(obj, path = 'ManagedContentVariantVersionCollectionRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -6404,7 +5819,7 @@ function validate$A(obj, path = 'ManagedContentVariantVersionCollectionRepresent
         for (let i = 0; i < obj_versions.length; i++) {
             const obj_versions_item = obj_versions[i];
             const path_versions_item = path_versions + '[' + i + ']';
-            const referencepath_versions_itemValidationError = validate$B(obj_versions_item, path_versions_item);
+            const referencepath_versions_itemValidationError = validate$F(obj_versions_item, path_versions_item);
             if (referencepath_versions_itemValidationError !== null) {
                 let message = 'Object doesn\'t match ManagedContentVariantVersionRepresentation (at "' + path_versions_item + '")\n';
                 message += referencepath_versions_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -6414,73 +5829,73 @@ function validate$A(obj, path = 'ManagedContentVariantVersionCollectionRepresent
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$h = 'ManagedContentVariantVersionCollectionRepresentation';
-function keyBuilder$E(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$h + ':' + config.variantId;
+const RepresentationType$k = 'ManagedContentVariantVersionCollectionRepresentation';
+function keyBuilder$H(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$k + ':' + config.variantId;
 }
-function keyBuilderFromType$6(luvio, object) {
+function keyBuilderFromType$7(luvio, object) {
     const keyParams = {
         variantId: object.managedContentVariantId
     };
-    return keyBuilder$E(luvio, keyParams);
+    return keyBuilder$H(luvio, keyParams);
 }
-function normalize$h(input, existing, path, luvio, store, timestamp) {
+function normalize$k(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$I = function ManagedContentVariantVersionCollectionRepresentationSelect() {
+const select$N = function ManagedContentVariantVersionCollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$i,
+        version: VERSION$l,
         private: [],
         opaque: true
     };
 };
-function equals$i(existing, incoming) {
+function equals$l(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$h = function ManagedContentVariantVersionCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$k = function ManagedContentVariantVersionCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$A(input);
+        const validateError = validate$E(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$6(luvio, input);
-    const ttlToUse = TTL$h;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$h, "CMSAuthoring", VERSION$i, RepresentationType$h, equals$i);
+    const key = keyBuilderFromType$7(luvio, input);
+    const ttlToUse = TTL$j;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$k, "CMSAuthoring", VERSION$l, RepresentationType$k, equals$l);
     return createLink(key);
 };
-function getTypeCacheKeys$h(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$k(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$h,
+        representationName: RepresentationType$k,
         mergeable: false
     });
 }
 
-function select$H(luvio, params) {
-    return select$I();
+function select$M(luvio, params) {
+    return select$N();
 }
-function keyBuilder$D(luvio, params) {
-    return keyBuilder$E(luvio, {
+function keyBuilder$G(luvio, params) {
+    return keyBuilder$H(luvio, {
         variantId: params.urlParams.variantId
     });
 }
-function getResponseCacheKeys$p(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$h(storeKeyMap, luvio, response);
+function getResponseCacheKeys$r(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$k(storeKeyMap, luvio, response);
 }
-function ingestSuccess$p(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$r(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$D(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$h, body);
+    const key = keyBuilder$G(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$k, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$H(),
+        node: select$M(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -6491,19 +5906,19 @@ function ingestSuccess$p(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$g(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$D(luvio, params);
+function ingestError$h(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$G(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$h,
+        ttl: TTL$j,
         namespace: keyPrefix,
-        version: VERSION$i,
-        representationName: RepresentationType$h
+        version: VERSION$l,
+        representationName: RepresentationType$k
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$p(config) {
+function createResourceRequest$r(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -6517,96 +5932,96 @@ function createResourceRequest$p(config) {
     };
 }
 
-const adapterName$p = 'getManagedContentVariantVersions';
+const adapterName$r = 'getManagedContentVariantVersions';
 const getManagedContentVariantVersions_ConfigPropertyMetadata = [
     generateParamConfigMetadata('variantId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('page', false, 1 /* QueryParameter */, 3 /* Integer */),
     generateParamConfigMetadata('pageSize', false, 1 /* QueryParameter */, 3 /* Integer */),
     generateParamConfigMetadata('status', false, 1 /* QueryParameter */, 0 /* String */, true),
 ];
-const getManagedContentVariantVersions_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$p, getManagedContentVariantVersions_ConfigPropertyMetadata);
-const createResourceParams$p = /*#__PURE__*/ createResourceParams$I(getManagedContentVariantVersions_ConfigPropertyMetadata);
-function keyBuilder$C(luvio, config) {
-    const resourceParams = createResourceParams$p(config);
-    return keyBuilder$D(luvio, resourceParams);
+const getManagedContentVariantVersions_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$r, getManagedContentVariantVersions_ConfigPropertyMetadata);
+const createResourceParams$r = /*#__PURE__*/ createResourceParams$I(getManagedContentVariantVersions_ConfigPropertyMetadata);
+function keyBuilder$F(luvio, config) {
+    const resourceParams = createResourceParams$r(config);
+    return keyBuilder$G(luvio, resourceParams);
 }
-function typeCheckConfig$p(untrustedConfig) {
+function typeCheckConfig$r(untrustedConfig) {
     const config = {};
     typeCheckConfig$I(untrustedConfig, config, getManagedContentVariantVersions_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$p(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$r(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$p(untrustedConfig);
+    const config = typeCheckConfig$r(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$g(luvio, config) {
-    createResourceParams$p(config);
-    return select$H();
+function adapterFragment$h(luvio, config) {
+    createResourceParams$r(config);
+    return select$M();
 }
-function onFetchResponseSuccess$i(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$p(luvio, resourceParams, response, {
+function onFetchResponseSuccess$j(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$r(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$p(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$r(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$g(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$g(luvio, resourceParams, response, {
+function onFetchResponseError$h(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$h(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$p(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$r(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$p(luvio, config, options) {
-    const resourceParams = createResourceParams$p(config);
-    const request = createResourceRequest$p(resourceParams);
+function buildNetworkSnapshot$r(luvio, config, options) {
+    const resourceParams = createResourceParams$r(config);
+    const request = createResourceRequest$r(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$i(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$j(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$p(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$r(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$g(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$h(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$g(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$p(context, coercedAdapterRequestContext, buildNetworkSnapshot$p, undefined, false);
+function buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$p(context, coercedAdapterRequestContext, buildNetworkSnapshot$r, undefined, false);
 }
-function buildCachedSnapshotCachePolicy$g(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$h(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$C(luvio, config),
-        node: adapterFragment$g(luvio, config),
+        recordId: keyBuilder$F(luvio, config),
+        node: adapterFragment$h(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$p(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$r(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getManagedContentVariantVersionsAdapterFactory = (luvio) => function CMSAuthoring__getManagedContentVariantVersions(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$p(untrustedConfig, getManagedContentVariantVersions_ConfigPropertyNames);
+    const config = validateAdapterConfig$r(untrustedConfig, getManagedContentVariantVersions_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$g, buildNetworkSnapshotCachePolicy$g);
+    buildCachedSnapshotCachePolicy$h, buildNetworkSnapshotCachePolicy$h);
 };
 
-function validate$z(obj, path = 'ManagedContentWebUrlRedirectInfoInputRepresentation') {
+function validate$D(obj, path = 'ManagedContentWebUrlRedirectInfoInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -6620,7 +6035,7 @@ function validate$z(obj, path = 'ManagedContentWebUrlRedirectInfoInputRepresenta
     return v_error === undefined ? null : v_error;
 }
 
-function validate$y(obj, path = 'ManagedContentWebUrlRedirectInfoOutputRepresentation') {
+function validate$C(obj, path = 'ManagedContentWebUrlRedirectInfoOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -6655,7 +6070,7 @@ function validate$y(obj, path = 'ManagedContentWebUrlRedirectInfoOutputRepresent
     return v_error === undefined ? null : v_error;
 }
 
-function validate$x(obj, path = 'ManagedContentSiteInfoRepresentation') {
+function validate$B(obj, path = 'ManagedContentSiteInfoRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -6674,7 +6089,7 @@ function validate$x(obj, path = 'ManagedContentSiteInfoRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$w(obj, path = 'ManagedContentWebUrlInfoRepresentation') {
+function validate$A(obj, path = 'ManagedContentWebUrlInfoRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -6682,7 +6097,7 @@ function validate$w(obj, path = 'ManagedContentWebUrlInfoRepresentation') {
         if (obj.siteInfo !== undefined) {
             const obj_siteInfo = obj.siteInfo;
             const path_siteInfo = path + '.siteInfo';
-            const referencepath_siteInfoValidationError = validate$x(obj_siteInfo, path_siteInfo);
+            const referencepath_siteInfoValidationError = validate$B(obj_siteInfo, path_siteInfo);
             if (referencepath_siteInfoValidationError !== null) {
                 let message = 'Object doesn\'t match ManagedContentSiteInfoRepresentation (at "' + path_siteInfo + '")\n';
                 message += referencepath_siteInfoValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -6698,9 +6113,9 @@ function validate$w(obj, path = 'ManagedContentWebUrlInfoRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$g = 100;
-const VERSION$h = "e55a316362ca4e75b43fa6c9c1b8a065";
-function validate$v(obj, path = 'ManagedContentWebUrlRepresentation') {
+const TTL$i = 100;
+const VERSION$k = "e55a316362ca4e75b43fa6c9c1b8a065";
+function validate$z(obj, path = 'ManagedContentWebUrlRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -6717,7 +6132,7 @@ function validate$v(obj, path = 'ManagedContentWebUrlRepresentation') {
         }
         const obj_redirectInfo = obj.redirectInfo;
         const path_redirectInfo = path + '.redirectInfo';
-        const referencepath_redirectInfoValidationError = validate$y(obj_redirectInfo, path_redirectInfo);
+        const referencepath_redirectInfoValidationError = validate$C(obj_redirectInfo, path_redirectInfo);
         if (referencepath_redirectInfoValidationError !== null) {
             let message = 'Object doesn\'t match ManagedContentWebUrlRedirectInfoOutputRepresentation (at "' + path_redirectInfo + '")\n';
             message += referencepath_redirectInfoValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -6741,7 +6156,7 @@ function validate$v(obj, path = 'ManagedContentWebUrlRepresentation') {
         for (let i = 0; i < obj_urls.length; i++) {
             const obj_urls_item = obj_urls[i];
             const path_urls_item = path_urls + '[' + i + ']';
-            const referencepath_urls_itemValidationError = validate$w(obj_urls_item, path_urls_item);
+            const referencepath_urls_itemValidationError = validate$A(obj_urls_item, path_urls_item);
             if (referencepath_urls_itemValidationError !== null) {
                 let message = 'Object doesn\'t match ManagedContentWebUrlInfoRepresentation (at "' + path_urls_item + '")\n';
                 message += referencepath_urls_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -6751,68 +6166,68 @@ function validate$v(obj, path = 'ManagedContentWebUrlRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$g = 'ManagedContentWebUrlRepresentation';
-function keyBuilder$B(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$g + ':' + config.managedContentWebUrlId;
+const RepresentationType$j = 'ManagedContentWebUrlRepresentation';
+function keyBuilder$E(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$j + ':' + config.managedContentWebUrlId;
 }
-function keyBuilderFromType$5(luvio, object) {
+function keyBuilderFromType$6(luvio, object) {
     const keyParams = {
         managedContentWebUrlId: object.id
     };
-    return keyBuilder$B(luvio, keyParams);
+    return keyBuilder$E(luvio, keyParams);
 }
-function normalize$g(input, existing, path, luvio, store, timestamp) {
+function normalize$j(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$G = function ManagedContentWebUrlRepresentationSelect() {
+const select$L = function ManagedContentWebUrlRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$h,
+        version: VERSION$k,
         private: [],
         opaque: true
     };
 };
-function equals$h(existing, incoming) {
+function equals$k(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$g = function ManagedContentWebUrlRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$j = function ManagedContentWebUrlRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$v(input);
+        const validateError = validate$z(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$5(luvio, input);
-    const ttlToUse = TTL$g;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$g, "CMSAuthoring", VERSION$h, RepresentationType$g, equals$h);
+    const key = keyBuilderFromType$6(luvio, input);
+    const ttlToUse = TTL$i;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$j, "CMSAuthoring", VERSION$k, RepresentationType$j, equals$k);
     return createLink(key);
 };
-function getTypeCacheKeys$g(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$j(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$5(luvio, input);
+    const rootKey = keyBuilderFromType$6(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$g,
+        representationName: RepresentationType$j,
         mergeable: false
     });
 }
 
-function select$F(luvio, params) {
-    return select$G();
+function select$K(luvio, params) {
+    return select$L();
 }
-function getResponseCacheKeys$o(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$g(storeKeyMap, luvio, response);
+function getResponseCacheKeys$q(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$j(storeKeyMap, luvio, response);
 }
-function ingestSuccess$o(luvio, resourceParams, response) {
+function ingestSuccess$q(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$5(luvio, body);
-    luvio.storeIngest(key, ingest$g, body);
+    const key = keyBuilderFromType$6(luvio, body);
+    luvio.storeIngest(key, ingest$j, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$F(),
+        node: select$K(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -6823,7 +6238,7 @@ function ingestSuccess$o(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$o(config) {
+function createResourceRequest$q(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -6837,49 +6252,49 @@ function createResourceRequest$o(config) {
     };
 }
 
-const adapterName$o = 'updateManagedContentWebUrl';
+const adapterName$q = 'updateManagedContentWebUrl';
 const updateManagedContentWebUrl_ConfigPropertyMetadata = [
     generateParamConfigMetadata('managedContentWebUrlId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('redirectInfo', false, 2 /* Body */, 4 /* Unsupported */),
     generateParamConfigMetadata('status', false, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('urlAlias', false, 2 /* Body */, 0 /* String */),
 ];
-const updateManagedContentWebUrl_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$o, updateManagedContentWebUrl_ConfigPropertyMetadata);
-const createResourceParams$o = /*#__PURE__*/ createResourceParams$I(updateManagedContentWebUrl_ConfigPropertyMetadata);
-function typeCheckConfig$o(untrustedConfig) {
+const updateManagedContentWebUrl_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$q, updateManagedContentWebUrl_ConfigPropertyMetadata);
+const createResourceParams$q = /*#__PURE__*/ createResourceParams$I(updateManagedContentWebUrl_ConfigPropertyMetadata);
+function typeCheckConfig$q(untrustedConfig) {
     const config = {};
     typeCheckConfig$I(untrustedConfig, config, updateManagedContentWebUrl_ConfigPropertyMetadata);
     const untrustedConfig_redirectInfo = untrustedConfig.redirectInfo;
-    const referenceManagedContentWebUrlRedirectInfoInputRepresentationValidationError = validate$z(untrustedConfig_redirectInfo);
+    const referenceManagedContentWebUrlRedirectInfoInputRepresentationValidationError = validate$D(untrustedConfig_redirectInfo);
     if (referenceManagedContentWebUrlRedirectInfoInputRepresentationValidationError === null) {
         config.redirectInfo = untrustedConfig_redirectInfo;
     }
     return config;
 }
-function validateAdapterConfig$o(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$q(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$o(untrustedConfig);
+    const config = typeCheckConfig$q(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$o(luvio, config, options) {
-    const resourceParams = createResourceParams$o(config);
-    const request = createResourceRequest$o(resourceParams);
+function buildNetworkSnapshot$q(luvio, config, options) {
+    const resourceParams = createResourceParams$q(config);
+    const request = createResourceRequest$q(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$o(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$q(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$o(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$q(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -6889,35 +6304,35 @@ function buildNetworkSnapshot$o(luvio, config, options) {
 }
 const updateManagedContentWebUrlAdapterFactory = (luvio) => {
     return function updateManagedContentWebUrl(untrustedConfig) {
-        const config = validateAdapterConfig$o(untrustedConfig, updateManagedContentWebUrl_ConfigPropertyNames);
+        const config = validateAdapterConfig$q(untrustedConfig, updateManagedContentWebUrl_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "updateManagedContentWebUrl"');
         }
-        return buildNetworkSnapshot$o(luvio, config);
+        return buildNetworkSnapshot$q(luvio, config);
     };
 };
 
-function select$E(luvio, params) {
-    return select$W();
+function select$J(luvio, params) {
+    return select$$();
 }
-function keyBuilder$A(luvio, params) {
-    return keyBuilder$O(luvio, {
+function keyBuilder$D(luvio, params) {
+    return keyBuilder$R(luvio, {
         content_key: params.urlParams.contentKeyOrId,
         language: params.queryParams.language || '',
         version: params.queryParams.version || ''
     });
 }
-function getResponseCacheKeys$n(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$n(storeKeyMap, luvio, response);
+function getResponseCacheKeys$p(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$q(storeKeyMap, luvio, response);
 }
-function ingestSuccess$n(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$p(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$A(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$n, body);
+    const key = keyBuilder$D(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$q, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$E(),
+        node: select$J(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -6928,19 +6343,19 @@ function ingestSuccess$n(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$f(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$A(luvio, params);
+function ingestError$g(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$D(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$n,
+        ttl: TTL$p,
         namespace: keyPrefix,
-        version: VERSION$o,
-        representationName: RepresentationType$n
+        version: VERSION$r,
+        representationName: RepresentationType$q
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$n(config) {
+function createResourceRequest$p(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
@@ -6954,7 +6369,7 @@ function createResourceRequest$n(config) {
     };
 }
 
-function onFetchResponseSuccess$h(luvio, config, resourceParams, response) {
+function onFetchResponseSuccess$i(luvio, config, resourceParams, response) {
     var _a;
     // Version can come either from versionNumber field in case of v2 content,
     // or managedContentVersionId field in case of v1 content.
@@ -7003,65 +6418,300 @@ function onFetchResponseSuccess$h(luvio, config, resourceParams, response) {
     // since this resource params are used to build a cache key to verify that
     // data was ingested into cache.
     (_a = resourceParams.queryParams).version || (_a.version = response.body.version);
-    return onFetchResponseSuccess$g(luvio, config, resourceParams, response);
+    return onFetchResponseSuccess$h(luvio, config, resourceParams, response);
+}
+
+const adapterName$p = 'getManagedContent';
+const getManagedContent_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('contentKeyOrId', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('language', false, 1 /* QueryParameter */, 0 /* String */),
+    generateParamConfigMetadata('version', false, 1 /* QueryParameter */, 0 /* String */),
+];
+const getManagedContent_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$p, getManagedContent_ConfigPropertyMetadata);
+const createResourceParams$p = /*#__PURE__*/ createResourceParams$I(getManagedContent_ConfigPropertyMetadata);
+function keyBuilder$C(luvio, config) {
+    const resourceParams = createResourceParams$p(config);
+    return keyBuilder$D(luvio, resourceParams);
+}
+function typeCheckConfig$p(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$I(untrustedConfig, config, getManagedContent_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig$p(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$p(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment$g(luvio, config) {
+    createResourceParams$p(config);
+    return select$J();
+}
+function onFetchResponseSuccess$h(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$p(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$p(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$p(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$p(luvio, config, options) {
+    const resourceParams = createResourceParams$p(config);
+    const request = createResourceRequest$p(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$i(luvio, config, resourceParams, response), () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$p(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$g(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$g(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$p(context, coercedAdapterRequestContext, buildNetworkSnapshot$p, undefined, false);
+}
+function buildCachedSnapshotCachePolicy$g(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$C(luvio, config),
+        node: adapterFragment$g(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$p(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getManagedContentAdapterFactory = (luvio) => function CMSAuthoring__getManagedContent(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$p(untrustedConfig, getManagedContent_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$g, buildNetworkSnapshotCachePolicy$g);
+};
+
+const TTL$h = 1000;
+const VERSION$j = "98edee4f058ced93570a7b0ce2293672";
+function validate$y(obj, path = 'ManagedContentRenditionRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_contentKey = obj.contentKey;
+        const path_contentKey = path + '.contentKey';
+        if (typeof obj_contentKey !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contentKey + '" (at "' + path_contentKey + '")');
+        }
+        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_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_renditionBody = obj.renditionBody;
+        const path_renditionBody = path + '.renditionBody';
+        if (typeof obj_renditionBody !== 'object' || ArrayIsArray(obj_renditionBody) || obj_renditionBody === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj_renditionBody + '" (at "' + path_renditionBody + '")');
+        }
+        const obj_renditionBody_keys = ObjectKeys(obj_renditionBody);
+        for (let i = 0; i < obj_renditionBody_keys.length; i++) {
+            const key = obj_renditionBody_keys[i];
+            const obj_renditionBody_prop = obj_renditionBody[key];
+            const path_renditionBody_prop = path_renditionBody + '["' + key + '"]';
+            if (obj_renditionBody_prop === undefined) {
+                return new TypeError('Expected "defined" but received "' + typeof obj_renditionBody_prop + '" (at "' + path_renditionBody_prop + '")');
+            }
+        }
+        const obj_renditionSchema = obj.renditionSchema;
+        const path_renditionSchema = path + '.renditionSchema';
+        if (typeof obj_renditionSchema !== 'object' || ArrayIsArray(obj_renditionSchema) || obj_renditionSchema === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj_renditionSchema + '" (at "' + path_renditionSchema + '")');
+        }
+        const obj_renditionSchema_keys = ObjectKeys(obj_renditionSchema);
+        for (let i = 0; i < obj_renditionSchema_keys.length; i++) {
+            const key = obj_renditionSchema_keys[i];
+            const obj_renditionSchema_prop = obj_renditionSchema[key];
+            const path_renditionSchema_prop = path_renditionSchema + '["' + key + '"]';
+            if (obj_renditionSchema_prop === undefined) {
+                return new TypeError('Expected "defined" but received "' + typeof obj_renditionSchema_prop + '" (at "' + path_renditionSchema_prop + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$i = 'ManagedContentRenditionRepresentation';
+function normalize$i(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$I = function ManagedContentRenditionRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$j,
+        private: [],
+        opaque: true
+    };
+};
+function equals$j(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
+const ingest$i = function ManagedContentRenditionRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$y(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = path.fullPath;
+    const ttlToUse = TTL$h;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$i, "CMSAuthoring", VERSION$j, RepresentationType$i, equals$j);
+    return createLink(key);
+};
+function getTypeCacheKeys$i(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = fullPathFactory();
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$i,
+        mergeable: false
+    });
+}
+
+function select$H(luvio, params) {
+    return select$I();
+}
+function keyBuilder$B(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));
+}
+function ingestSuccess$o(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$B(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$i, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$H(),
+        variables: {},
+    }, snapshotRefresh);
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
+}
+function ingestError$f(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$B(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    const storeMetadataParams = {
+        ttl: TTL$h,
+        namespace: keyPrefix,
+        version: VERSION$j,
+        representationName: RepresentationType$i
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
+function createResourceRequest$o(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v61.0',
+        basePath: '/connect/cms/contents/' + config.urlParams.contentKeyOrId + '/renditions/' + config.urlParams.renditionType + '',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: config.queryParams,
+        headers,
+        priority: 'normal',
+    };
 }
 
-const adapterName$n = 'getManagedContent';
-const getManagedContent_ConfigPropertyMetadata = [
+const adapterName$o = 'getManagedContentVariantRendition';
+const getManagedContentVariantRendition_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contentKeyOrId', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('renditionType', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('channelIdOrApiName', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('language', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('version', false, 1 /* QueryParameter */, 0 /* String */),
 ];
-const getManagedContent_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$n, getManagedContent_ConfigPropertyMetadata);
-const createResourceParams$n = /*#__PURE__*/ createResourceParams$I(getManagedContent_ConfigPropertyMetadata);
-function keyBuilder$z(luvio, config) {
-    const resourceParams = createResourceParams$n(config);
-    return keyBuilder$A(luvio, resourceParams);
+const getManagedContentVariantRendition_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$o, getManagedContentVariantRendition_ConfigPropertyMetadata);
+const createResourceParams$o = /*#__PURE__*/ createResourceParams$I(getManagedContentVariantRendition_ConfigPropertyMetadata);
+function keyBuilder$A(luvio, config) {
+    const resourceParams = createResourceParams$o(config);
+    return keyBuilder$B(luvio, resourceParams);
 }
-function typeCheckConfig$n(untrustedConfig) {
+function typeCheckConfig$o(untrustedConfig) {
     const config = {};
-    typeCheckConfig$I(untrustedConfig, config, getManagedContent_ConfigPropertyMetadata);
+    typeCheckConfig$I(untrustedConfig, config, getManagedContentVariantRendition_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$n(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$o(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$n(untrustedConfig);
+    const config = typeCheckConfig$o(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$f(luvio, config) {
-    createResourceParams$n(config);
-    return select$E();
+    createResourceParams$o(config);
+    return select$H();
 }
 function onFetchResponseSuccess$g(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$n(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$o(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$n(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$o(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$n(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$o(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$n(luvio, config, options) {
-    const resourceParams = createResourceParams$n(config);
-    const request = createResourceRequest$n(resourceParams);
+function buildNetworkSnapshot$o(luvio, config, options) {
+    const resourceParams = createResourceParams$o(config);
+    const request = createResourceRequest$o(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$h(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$g(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$n(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$o(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -7069,23 +6719,23 @@ function buildNetworkSnapshot$n(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$p(context, coercedAdapterRequestContext, buildNetworkSnapshot$n, undefined, false);
+    return buildNetworkSnapshotCachePolicy$p(context, coercedAdapterRequestContext, buildNetworkSnapshot$o, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$f(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$z(luvio, config),
+        recordId: keyBuilder$A(luvio, config),
         node: adapterFragment$f(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$n(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$o(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
-const getManagedContentAdapterFactory = (luvio) => function CMSAuthoring__getManagedContent(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$n(untrustedConfig, getManagedContent_ConfigPropertyNames);
+const getManagedContentVariantRenditionAdapterFactory = (luvio) => function CMSAuthoring__getManagedContentVariantRendition(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$o(untrustedConfig, getManagedContentVariantRendition_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -7094,115 +6744,419 @@ const getManagedContentAdapterFactory = (luvio) => function CMSAuthoring__getMan
     buildCachedSnapshotCachePolicy$f, buildNetworkSnapshotCachePolicy$f);
 };
 
-const TTL$f = 1000;
-const VERSION$g = "98edee4f058ced93570a7b0ce2293672";
-function validate$u(obj, path = 'ManagedContentRenditionRepresentation') {
+function validate$x(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 + '")');
+        }
+        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 + '")');
+        }
+        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 + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+const TTL$g = 100;
+const VERSION$i = "861a01549e9c8877564cf9109fe8af72";
+function validate$w(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 + '")');
+        }
+        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_taxonomyFragment = obj.taxonomyFragment;
+        const path_taxonomyFragment = path + '.taxonomyFragment';
+        const referencepath_taxonomyFragmentValidationError = validate$x(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');
+            return new TypeError(message);
+        }
+        const obj_termFragments = obj.termFragments;
+        const path_termFragments = path + '.termFragments';
+        if (!ArrayIsArray(obj_termFragments)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_termFragments + '" (at "' + path_termFragments + '")');
+        }
+        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$x(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');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$h = 'ManagedContentTaxonomyPathRepresentation';
+function normalize$h(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$G = function ManagedContentTaxonomyPathRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$i,
+        private: [],
+        opaque: true
+    };
+};
+function equals$i(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
+const ingest$h = function ManagedContentTaxonomyPathRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$w(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = path.fullPath;
+    const ttlToUse = TTL$g;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$h, "CMSAuthoring", VERSION$i, RepresentationType$h, equals$i);
+    return createLink(key);
+};
+function getTypeCacheKeys$h(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = fullPathFactory();
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$h,
+        mergeable: false
+    });
+}
+
+const VERSION$h = "05c4867cd20f87930367aa80db4baab5";
+function validate$v(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 + '")');
+        }
+        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 + '")');
+        }
+        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_pathsFromRoot = obj.pathsFromRoot;
+        const path_pathsFromRoot = path + '.pathsFromRoot';
+        if (!ArrayIsArray(obj_pathsFromRoot)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_pathsFromRoot + '" (at "' + path_pathsFromRoot + '")');
+        }
+        for (let i = 0; i < obj_pathsFromRoot.length; i++) {
+            const obj_pathsFromRoot_item = obj_pathsFromRoot[i];
+            const path_pathsFromRoot_item = path_pathsFromRoot + '[' + i + ']';
+            if (typeof obj_pathsFromRoot_item !== 'object') {
+                return new TypeError('Expected "object" but received "' + typeof obj_pathsFromRoot_item + '" (at "' + path_pathsFromRoot_item + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$g = 'ManagedContentTaxonomyTermRepresentation';
+function normalize$g(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$h(input_pathsFromRoot_item, {
+            fullPath: input_pathsFromRoot_item_id,
+            propertyName: i,
+            parent: {
+                data: input,
+                key: path.fullPath,
+                existing: existing,
+            },
+            ttl: path.ttl
+        }, luvio, store, timestamp);
+    }
+    return input;
+}
+const select$F = function ManagedContentTaxonomyTermRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$h,
+        private: [],
+        selections: [
+            {
+                name: 'id',
+                kind: 'Scalar'
+            },
+            {
+                name: 'label',
+                kind: 'Scalar'
+            },
+            {
+                name: 'pathsFromRoot',
+                kind: 'Link',
+                plural: true,
+                fragment: select$G()
+            }
+        ]
+    };
+};
+function equals$h(existing, incoming) {
+    const existing_id = existing.id;
+    const incoming_id = incoming.id;
+    if (!(existing_id === incoming_id)) {
+        return false;
+    }
+    const existing_label = existing.label;
+    const incoming_label = incoming.label;
+    if (!(existing_label === incoming_label)) {
+        return false;
+    }
+    const existing_pathsFromRoot = existing.pathsFromRoot;
+    const incoming_pathsFromRoot = incoming.pathsFromRoot;
+    const equals_pathsFromRoot_items = equalsArray(existing_pathsFromRoot, incoming_pathsFromRoot, (existing_pathsFromRoot_item, incoming_pathsFromRoot_item) => {
+        if (!(existing_pathsFromRoot_item.__ref === incoming_pathsFromRoot_item.__ref)) {
+            return false;
+        }
+    });
+    if (equals_pathsFromRoot_items === false) {
+        return false;
+    }
+    return true;
+}
+const ingest$g = function ManagedContentTaxonomyTermRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$v(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = path.fullPath;
+    const ttlToUse = path.ttl;
+    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();
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$g,
+        mergeable: false
+    });
+    const input_pathsFromRoot_length = input.pathsFromRoot.length;
+    for (let i = 0; i < input_pathsFromRoot_length; i++) {
+        getTypeCacheKeys$h(rootKeySet, luvio, input.pathsFromRoot[i], () => '');
+    }
+}
+
+const TTL$f = 100;
+const VERSION$g = "8ab64b2a71caa7cbdb25a65e8081196c";
+function validate$u(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 + '")');
         }
         const obj_contentKey = obj.contentKey;
         const path_contentKey = path + '.contentKey';
-        if (typeof obj_contentKey !== 'string') {
-            return new TypeError('Expected "string" but received "' + typeof obj_contentKey + '" (at "' + 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;
         }
-        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 + '")');
+        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);
         }
         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_renditionBody = obj.renditionBody;
-        const path_renditionBody = path + '.renditionBody';
-        if (typeof obj_renditionBody !== 'object' || ArrayIsArray(obj_renditionBody) || obj_renditionBody === null) {
-            return new TypeError('Expected "object" but received "' + typeof obj_renditionBody + '" (at "' + path_renditionBody + '")');
+        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;
         }
-        const obj_renditionBody_keys = ObjectKeys(obj_renditionBody);
-        for (let i = 0; i < obj_renditionBody_keys.length; i++) {
-            const key = obj_renditionBody_keys[i];
-            const obj_renditionBody_prop = obj_renditionBody[key];
-            const path_renditionBody_prop = path_renditionBody + '["' + key + '"]';
-            if (obj_renditionBody_prop === undefined) {
-                return new TypeError('Expected "defined" but received "' + typeof obj_renditionBody_prop + '" (at "' + path_renditionBody_prop + '")');
+        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;
         }
-        const obj_renditionSchema = obj.renditionSchema;
-        const path_renditionSchema = path + '.renditionSchema';
-        if (typeof obj_renditionSchema !== 'object' || ArrayIsArray(obj_renditionSchema) || obj_renditionSchema === null) {
-            return new TypeError('Expected "object" but received "' + typeof obj_renditionSchema + '" (at "' + path_renditionSchema + '")');
+        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_renditionSchema_keys = ObjectKeys(obj_renditionSchema);
-        for (let i = 0; i < obj_renditionSchema_keys.length; i++) {
-            const key = obj_renditionSchema_keys[i];
-            const obj_renditionSchema_prop = obj_renditionSchema[key];
-            const path_renditionSchema_prop = path_renditionSchema + '["' + key + '"]';
-            if (obj_renditionSchema_prop === undefined) {
-                return new TypeError('Expected "defined" but received "' + typeof obj_renditionSchema_prop + '" (at "' + path_renditionSchema_prop + '")');
+        const obj_taxonomyTerms = obj.taxonomyTerms;
+        const path_taxonomyTerms = path + '.taxonomyTerms';
+        if (!ArrayIsArray(obj_taxonomyTerms)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_taxonomyTerms + '" (at "' + path_taxonomyTerms + '")');
+        }
+        for (let i = 0; i < obj_taxonomyTerms.length; i++) {
+            const obj_taxonomyTerms_item = obj_taxonomyTerms[i];
+            const path_taxonomyTerms_item = path_taxonomyTerms + '[' + i + ']';
+            if (typeof obj_taxonomyTerms_item !== 'object') {
+                return new TypeError('Expected "object" but received "' + typeof obj_taxonomyTerms_item + '" (at "' + path_taxonomyTerms_item + '")');
             }
         }
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$f = 'ManagedContentRenditionRepresentation';
+const RepresentationType$f = 'ManagedContentTaxonomyTermCollectionRepresentation';
+function keyBuilder$z(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$f + ':' + (config.id === null ? '' : config.id);
+}
+function keyBuilderFromType$5(luvio, object) {
+    const keyParams = {
+        id: object.managedContentId
+    };
+    return keyBuilder$z(luvio, keyParams);
+}
 function normalize$f(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$g(input_taxonomyTerms_item, {
+            fullPath: input_taxonomyTerms_item_id,
+            propertyName: i,
+            parent: {
+                data: input,
+                key: path.fullPath,
+                existing: existing,
+            },
+            ttl: path.ttl
+        }, luvio, store, timestamp);
+    }
     return input;
 }
-const select$D = function ManagedContentRenditionRepresentationSelect() {
+const select$E = function ManagedContentTaxonomyTermCollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$g,
         private: [],
-        opaque: true
+        selections: [
+            {
+                name: 'contentKey',
+                kind: 'Scalar'
+            },
+            {
+                name: 'managedContentId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'taxonomyTerms',
+                kind: 'Link',
+                plural: true,
+                fragment: select$F()
+            }
+        ]
     };
 };
 function equals$g(existing, incoming) {
-    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+    const existing_contentKey = existing.contentKey;
+    const incoming_contentKey = incoming.contentKey;
+    if (!(existing_contentKey === incoming_contentKey)) {
+        return false;
+    }
+    const existing_managedContentId = existing.managedContentId;
+    const incoming_managedContentId = incoming.managedContentId;
+    if (!(existing_managedContentId === incoming_managedContentId)) {
+        return false;
+    }
+    const existing_taxonomyTerms = existing.taxonomyTerms;
+    const incoming_taxonomyTerms = incoming.taxonomyTerms;
+    const equals_taxonomyTerms_items = equalsArray(existing_taxonomyTerms, incoming_taxonomyTerms, (existing_taxonomyTerms_item, incoming_taxonomyTerms_item) => {
+        if (!(existing_taxonomyTerms_item.__ref === incoming_taxonomyTerms_item.__ref)) {
+            return false;
+        }
+    });
+    if (equals_taxonomyTerms_items === false) {
         return false;
     }
     return true;
 }
-const ingest$f = function ManagedContentRenditionRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$f = function ManagedContentTaxonomyTermCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$u(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = path.fullPath;
+    const key = keyBuilderFromType$5(luvio, input);
     const ttlToUse = TTL$f;
     ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$f, "CMSAuthoring", VERSION$g, RepresentationType$f, equals$g);
     return createLink(key);
 };
 function getTypeCacheKeys$f(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = fullPathFactory();
+    const rootKey = keyBuilderFromType$5(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
         representationName: RepresentationType$f,
         mergeable: false
     });
+    const input_taxonomyTerms_length = input.taxonomyTerms.length;
+    for (let i = 0; i < input_taxonomyTerms_length; i++) {
+        getTypeCacheKeys$g(rootKeySet, luvio, input.taxonomyTerms[i], () => '');
+    }
 }
 
-function select$C(luvio, params) {
-    return select$D();
+function select$D(luvio, params) {
+    return select$E();
 }
 function keyBuilder$y(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 + ')';
+    return keyBuilder$z(luvio, {
+        id: params.urlParams.contentKeyOrId
+    });
 }
-function getResponseCacheKeys$m(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$f(storeKeyMap, luvio, response, () => keyBuilder$y(luvio, resourceParams));
+function getResponseCacheKeys$n(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$f(storeKeyMap, luvio, response);
 }
-function ingestSuccess$m(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$n(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
     const key = keyBuilder$y(luvio, resourceParams);
     luvio.storeIngest(key, ingest$f, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$C(),
+        node: select$D(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -7225,78 +7179,74 @@ function ingestError$e(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$m(config) {
+function createResourceRequest$n(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v61.0',
-        basePath: '/connect/cms/contents/' + config.urlParams.contentKeyOrId + '/renditions/' + config.urlParams.renditionType + '',
+        basePath: '/connect/cms/contents/' + config.urlParams.contentKeyOrId + '/taxonomy-terms',
         method: 'get',
         body: null,
         urlParams: config.urlParams,
-        queryParams: config.queryParams,
+        queryParams: {},
         headers,
         priority: 'normal',
     };
 }
 
-const adapterName$m = 'getManagedContentVariantRendition';
-const getManagedContentVariantRendition_ConfigPropertyMetadata = [
+const adapterName$n = 'getManagedContentTaxonomyTerms';
+const getManagedContentTaxonomyTerms_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contentKeyOrId', true, 0 /* UrlParameter */, 0 /* String */),
-    generateParamConfigMetadata('renditionType', true, 0 /* UrlParameter */, 0 /* String */),
-    generateParamConfigMetadata('channelIdOrApiName', false, 1 /* QueryParameter */, 0 /* String */),
-    generateParamConfigMetadata('language', false, 1 /* QueryParameter */, 0 /* String */),
-    generateParamConfigMetadata('version', false, 1 /* QueryParameter */, 0 /* String */),
 ];
-const getManagedContentVariantRendition_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$m, getManagedContentVariantRendition_ConfigPropertyMetadata);
-const createResourceParams$m = /*#__PURE__*/ createResourceParams$I(getManagedContentVariantRendition_ConfigPropertyMetadata);
+const getManagedContentTaxonomyTerms_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$n, getManagedContentTaxonomyTerms_ConfigPropertyMetadata);
+const createResourceParams$n = /*#__PURE__*/ createResourceParams$I(getManagedContentTaxonomyTerms_ConfigPropertyMetadata);
 function keyBuilder$x(luvio, config) {
-    const resourceParams = createResourceParams$m(config);
+    const resourceParams = createResourceParams$n(config);
     return keyBuilder$y(luvio, resourceParams);
 }
-function typeCheckConfig$m(untrustedConfig) {
+function typeCheckConfig$n(untrustedConfig) {
     const config = {};
-    typeCheckConfig$I(untrustedConfig, config, getManagedContentVariantRendition_ConfigPropertyMetadata);
+    typeCheckConfig$I(untrustedConfig, config, getManagedContentTaxonomyTerms_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$m(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$n(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$m(untrustedConfig);
+    const config = typeCheckConfig$n(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$e(luvio, config) {
-    createResourceParams$m(config);
-    return select$C();
+    createResourceParams$n(config);
+    return select$D();
 }
 function onFetchResponseSuccess$f(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$m(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$n(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$m(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$n(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$e(luvio, config, resourceParams, response) {
     const snapshot = ingestError$e(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$m(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$n(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$m(luvio, config, options) {
-    const resourceParams = createResourceParams$m(config);
-    const request = createResourceRequest$m(resourceParams);
+function buildNetworkSnapshot$n(luvio, config, options) {
+    const resourceParams = createResourceParams$n(config);
+    const request = createResourceRequest$n(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess$f(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$m(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$n(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -7304,7 +7254,7 @@ function buildNetworkSnapshot$m(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$e(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$p(context, coercedAdapterRequestContext, buildNetworkSnapshot$m, undefined, false);
+    return buildNetworkSnapshotCachePolicy$p(context, coercedAdapterRequestContext, buildNetworkSnapshot$n, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$e(context, storeLookup) {
     const { luvio, config } = context;
@@ -7315,12 +7265,12 @@ function buildCachedSnapshotCachePolicy$e(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$m(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$n(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
-const getManagedContentVariantRenditionAdapterFactory = (luvio) => function CMSAuthoring__getManagedContentVariantRendition(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$m(untrustedConfig, getManagedContentVariantRendition_ConfigPropertyNames);
+const getManagedContentTaxonomyTermsAdapterFactory = (luvio) => function CMSAuthoring__getManagedContentTaxonomyTerms(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$n(untrustedConfig, getManagedContentTaxonomyTerms_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -7329,6 +7279,99 @@ const getManagedContentVariantRenditionAdapterFactory = (luvio) => function CMSA
     buildCachedSnapshotCachePolicy$e, buildNetworkSnapshotCachePolicy$e);
 };
 
+function select$C(luvio, params) {
+    return select$E();
+}
+function getResponseCacheKeys$m(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$f(storeKeyMap, luvio, response);
+}
+function ingestSuccess$m(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$5(luvio, body);
+    luvio.storeIngest(key, ingest$f, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$C(),
+        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$m(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v61.0',
+        basePath: '/connect/cms/contents/' + config.urlParams.contentKeyOrId + '/taxonomy-terms',
+        method: 'patch',
+        body: config.body,
+        urlParams: config.urlParams,
+        queryParams: config.queryParams,
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$m = 'updateManagedContentTaxonomyTerms';
+const updateManagedContentTaxonomyTerms_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('contentKeyOrId', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('publish', true, 1 /* QueryParameter */, 1 /* Boolean */),
+    generateParamConfigMetadata('termsToAdd', true, 2 /* Body */, 0 /* String */, true),
+    generateParamConfigMetadata('termsToRemove', true, 2 /* Body */, 0 /* String */, true),
+];
+const updateManagedContentTaxonomyTerms_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$m, updateManagedContentTaxonomyTerms_ConfigPropertyMetadata);
+const createResourceParams$m = /*#__PURE__*/ createResourceParams$I(updateManagedContentTaxonomyTerms_ConfigPropertyMetadata);
+function typeCheckConfig$m(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$I(untrustedConfig, config, updateManagedContentTaxonomyTerms_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig$m(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$m(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$m(luvio, config, options) {
+    const resourceParams = createResourceParams$m(config);
+    const request = createResourceRequest$m(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$m(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$m(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const updateManagedContentTaxonomyTermsAdapterFactory = (luvio) => {
+    return function updateManagedContentTaxonomyTerms(untrustedConfig) {
+        const config = validateAdapterConfig$m(untrustedConfig, updateManagedContentTaxonomyTerms_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "updateManagedContentTaxonomyTerms"');
+        }
+        return buildNetworkSnapshot$m(luvio, config);
+    };
+};
+
 const TTL$e = 100;
 const VERSION$f = "361f66b21b2d3b6832c42c67fac4f448";
 function validate$t(obj, path = 'ManagedContentWebUrlsRepresentation') {
@@ -7344,7 +7387,7 @@ function validate$t(obj, path = 'ManagedContentWebUrlsRepresentation') {
         for (let i = 0; i < obj_urlAliases.length; i++) {
             const obj_urlAliases_item = obj_urlAliases[i];
             const path_urlAliases_item = path_urlAliases + '[' + i + ']';
-            const referencepath_urlAliases_itemValidationError = validate$v(obj_urlAliases_item, path_urlAliases_item);
+            const referencepath_urlAliases_itemValidationError = validate$z(obj_urlAliases_item, path_urlAliases_item);
             if (referencepath_urlAliases_itemValidationError !== null) {
                 let message = 'Object doesn\'t match ManagedContentWebUrlRepresentation (at "' + path_urlAliases_item + '")\n';
                 message += referencepath_urlAliases_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -7947,7 +7990,7 @@ function validate$p(obj, path = 'ManagedContentVariantReferenceDetailsRepresenta
         }
         const obj_status = obj.status;
         const path_status = path + '.status';
-        const referencepath_statusValidationError = validate$R(obj_status, path_status);
+        const referencepath_statusValidationError = validate$V(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');
@@ -9565,7 +9608,7 @@ function validate$e(obj, path = 'AbstractManagedContentSearchResultRepresentatio
         }
         const obj_folder = obj.folder;
         const path_folder = path + '.folder';
-        const referencepath_folderValidationError = validate$S(obj_folder, path_folder);
+        const referencepath_folderValidationError = validate$W(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');
@@ -12214,22 +12257,22 @@ const getManagedContentPreviewsAdapterFactory = (luvio) => function CMSAuthoring
 };
 
 function select(luvio, params) {
-    return select$W();
+    return select$$();
 }
 function keyBuilder$1(luvio, params) {
-    return keyBuilder$O(luvio, {
+    return keyBuilder$R(luvio, {
         content_key: params.urlParams.contentKeyOrId,
         language: params.queryParams.language || '',
         version: params.queryParams.version || ''
     });
 }
 function getResponseCacheKeys(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$n(storeKeyMap, luvio, response);
+    getTypeCacheKeys$q(storeKeyMap, luvio, response);
 }
 function ingestSuccess(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
     const key = keyBuilder$1(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$n, body);
+    luvio.storeIngest(key, ingest$q, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
         node: select(),
@@ -12247,10 +12290,10 @@ function ingestError(luvio, params, error, snapshotRefresh) {
     const key = keyBuilder$1(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$n,
+        ttl: TTL$p,
         namespace: keyPrefix,
-        version: VERSION$o,
-        representationName: RepresentationType$n
+        version: VERSION$r,
+        representationName: RepresentationType$q
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;