@salesforce/lds-adapters-industries-clm 1.179.0 → 1.181.0

package/dist/es/es2018/industries-clm.js

@@ -134,19 +134,19 @@ function validate$g(obj, path = 'GenericOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$9 = 'GenericOutputRepresentation';
-function keyBuilder$k(luvio, config) {
+function keyBuilder$m(luvio, config) {
     return keyPrefix + '::' + RepresentationType$9 + ':' + config.id;
 }
 function keyBuilderFromType$6(luvio, object) {
     const keyParams = {
         id: object.id
     };
-    return keyBuilder$k(luvio, keyParams);
+    return keyBuilder$m(luvio, keyParams);
 }
 function normalize$9(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$q = function GenericOutputRepresentationSelect() {
+const select$r = function GenericOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$a,
@@ -200,19 +200,19 @@ function getTypeCacheKeys$9(rootKeySet, luvio, input, fullPathFactory) {
     });
 }
 
-function select$p(luvio, params) {
-    return select$q();
+function select$q(luvio, params) {
+    return select$r();
 }
-function getResponseCacheKeys$h(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$i(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$9(storeKeyMap, luvio, response);
 }
-function ingestSuccess$f(luvio, resourceParams, response) {
+function ingestSuccess$g(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$6(luvio, body);
     luvio.storeIngest(key, ingest$9, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$p(),
+        node: select$q(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -223,7 +223,7 @@ function ingestSuccess$f(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$h(config) {
+function createResourceRequest$i(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v59.0',
@@ -244,7 +244,7 @@ const executeContractAction_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$h(config) {
+function createResourceParams$i(config) {
     const resourceParams = {
         urlParams: {
             contractId: config.contractId
@@ -255,7 +255,7 @@ function createResourceParams$h(config) {
     };
     return resourceParams;
 }
-function typeCheckConfig$h(untrustedConfig) {
+function typeCheckConfig$i(untrustedConfig) {
     const config = {};
     const untrustedConfig_contractId = untrustedConfig.contractId;
     if (typeof untrustedConfig_contractId === 'string') {
@@ -268,30 +268,30 @@ function typeCheckConfig$h(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$h(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$i(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$h(untrustedConfig);
+    const config = typeCheckConfig$i(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$h(luvio, config, options) {
-    const resourceParams = createResourceParams$h(config);
-    const request = createResourceRequest$h(resourceParams);
+function buildNetworkSnapshot$i(luvio, config, options) {
+    const resourceParams = createResourceParams$i(config);
+    const request = createResourceRequest$i(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$f(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$g(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$h(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$i(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -301,12 +301,12 @@ function buildNetworkSnapshot$h(luvio, config, options) {
 }
 const executeContractActionAdapterFactory = (luvio) => {
     return function executeContractAction(untrustedConfig) {
-        const config = validateAdapterConfig$h(untrustedConfig, executeContractAction_ConfigPropertyNames);
+        const config = validateAdapterConfig$i(untrustedConfig, executeContractAction_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "executeContractAction"');
         }
-        return buildNetworkSnapshot$h(luvio, config);
+        return buildNetworkSnapshot$i(luvio, config);
     };
 };
 
@@ -430,7 +430,7 @@ const RepresentationType$8 = 'ContractDocumentVersionsListRepresentation';
 function normalize$8(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$o = function ContractDocumentVersionsListRepresentationSelect() {
+const select$p = function ContractDocumentVersionsListRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$9,
@@ -484,22 +484,22 @@ function getTypeCacheKeys$8(rootKeySet, luvio, input, fullPathFactory) {
     });
 }
 
-function select$n(luvio, params) {
-    return select$o();
+function select$o(luvio, params) {
+    return select$p();
 }
-function keyBuilder$j(luvio, params) {
+function keyBuilder$l(luvio, params) {
     return keyPrefix + '::ContractDocumentVersionsListRepresentation:(' + 'contractDocumentVersionId:' + params.queryParams.contractDocumentVersionId + ',' + 'contractId:' + params.urlParams.contractId + ')';
 }
-function getResponseCacheKeys$g(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$8(storeKeyMap, luvio, response, () => keyBuilder$j(luvio, resourceParams));
+function getResponseCacheKeys$h(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$8(storeKeyMap, luvio, response, () => keyBuilder$l(luvio, resourceParams));
 }
-function ingestSuccess$e(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$f(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$j(luvio, resourceParams);
+    const key = keyBuilder$l(luvio, resourceParams);
     luvio.storeIngest(key, ingest$8, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$n(),
+        node: select$o(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -510,8 +510,8 @@ function ingestSuccess$e(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$5(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$j(luvio, params);
+function ingestError$6(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$l(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
         ttl: TTL$7,
@@ -522,7 +522,7 @@ function ingestError$5(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$g(config) {
+function createResourceRequest$h(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v59.0',
@@ -543,7 +543,7 @@ const getContractDocumentVersion_ConfigPropertyNames = {
         optional: ['contractDocumentVersionId']
     }
 };
-function createResourceParams$g(config) {
+function createResourceParams$h(config) {
     const resourceParams = {
         urlParams: {
             contractId: config.contractId
@@ -554,11 +554,11 @@ function createResourceParams$g(config) {
     };
     return resourceParams;
 }
-function keyBuilder$i(luvio, config) {
-    const resourceParams = createResourceParams$g(config);
-    return keyBuilder$j(luvio, resourceParams);
+function keyBuilder$k(luvio, config) {
+    const resourceParams = createResourceParams$h(config);
+    return keyBuilder$l(luvio, resourceParams);
 }
-function typeCheckConfig$g(untrustedConfig) {
+function typeCheckConfig$h(untrustedConfig) {
     const config = {};
     const untrustedConfig_contractId = untrustedConfig.contractId;
     if (typeof untrustedConfig_contractId === 'string') {
@@ -570,52 +570,52 @@ function typeCheckConfig$g(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$g(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$h(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$g(untrustedConfig);
+    const config = typeCheckConfig$h(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$5(luvio, config) {
-    createResourceParams$g(config);
-    return select$n();
+function adapterFragment$6(luvio, config) {
+    createResourceParams$h(config);
+    return select$o();
 }
-function onFetchResponseSuccess$5(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$e(luvio, resourceParams, response, {
+function onFetchResponseSuccess$6(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$f(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$g(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$h(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$5(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$5(luvio, resourceParams, response, {
+function onFetchResponseError$6(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$6(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$g(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$h(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$g(luvio, config, options) {
-    const resourceParams = createResourceParams$g(config);
-    const request = createResourceRequest$g(resourceParams);
+function buildNetworkSnapshot$h(luvio, config, options) {
+    const resourceParams = createResourceParams$h(config);
+    const request = createResourceRequest$h(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$5(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$6(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$g(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$h(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$5(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$6(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext) {
+function buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext) {
     const { luvio, config } = context;
     const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
     const dispatchOptions = {
@@ -630,29 +630,29 @@ function buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext
             priority: networkPriority
         };
     }
-    return buildNetworkSnapshot$g(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$h(luvio, config, dispatchOptions);
 }
-function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$i(luvio, config),
-        node: adapterFragment$5(luvio, config),
+        recordId: keyBuilder$k(luvio, config),
+        node: adapterFragment$6(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$g(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$h(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getContractDocumentVersionAdapterFactory = (luvio) => function clm__getContractDocumentVersion(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$g(untrustedConfig, getContractDocumentVersion_ConfigPropertyNames);
+    const config = validateAdapterConfig$h(untrustedConfig, getContractDocumentVersion_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$5, buildNetworkSnapshotCachePolicy$5);
+    buildCachedSnapshotCachePolicy$6, buildNetworkSnapshotCachePolicy$6);
 };
 
 function validate$d(obj, path = 'TemplateInputRepresentation') {
@@ -660,6 +660,13 @@ function validate$d(obj, path = 'TemplateInputRepresentation') {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
         }
+        if (obj.isExternalReviewImport !== undefined) {
+            const obj_isExternalReviewImport = obj.isExternalReviewImport;
+            const path_isExternalReviewImport = path + '.isExternalReviewImport';
+            if (typeof obj_isExternalReviewImport !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isExternalReviewImport + '" (at "' + path_isExternalReviewImport + '")');
+            }
+        }
         if (obj.pdfDocumentId !== undefined) {
             const obj_pdfDocumentId = obj.pdfDocumentId;
             const path_pdfDocumentId = path + '.pdfDocumentId';
@@ -731,7 +738,7 @@ function validate$c(obj, path = 'ContentDocumentRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$m = function ContentDocumentRepresentationSelect() {
+const select$n = function ContentDocumentRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$8,
@@ -870,19 +877,19 @@ function validate$b(obj, path = 'DocumentGenerateRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$7 = 'DocumentGenerateRepresentation';
-function keyBuilder$h(luvio, config) {
+function keyBuilder$j(luvio, config) {
     return keyPrefix + '::' + RepresentationType$7 + ':' + config.contractId;
 }
 function keyBuilderFromType$5(luvio, object) {
     const keyParams = {
         contractId: object.contractId
     };
-    return keyBuilder$h(luvio, keyParams);
+    return keyBuilder$j(luvio, keyParams);
 }
 function normalize$7(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$l = function DocumentGenerateRepresentationSelect() {
+const select$m = function DocumentGenerateRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$7,
@@ -936,19 +943,19 @@ function getTypeCacheKeys$7(rootKeySet, luvio, input, fullPathFactory) {
     });
 }
 
-function select$k(luvio, params) {
-    return select$l();
+function select$l(luvio, params) {
+    return select$m();
 }
-function getResponseCacheKeys$f(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$g(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$7(storeKeyMap, luvio, response);
 }
-function ingestSuccess$d(luvio, resourceParams, response) {
+function ingestSuccess$e(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$5(luvio, body);
     luvio.storeIngest(key, ingest$7, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$k(),
+        node: select$l(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -959,7 +966,7 @@ function ingestSuccess$d(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$f(config) {
+function createResourceRequest$g(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v59.0',
@@ -980,7 +987,7 @@ const createContractDocumentVersionAndInitializeGenerateDocumentProcess_ConfigPr
         optional: []
     }
 };
-function createResourceParams$f(config) {
+function createResourceParams$g(config) {
     const resourceParams = {
         urlParams: {
             contractId: config.contractId
@@ -991,7 +998,7 @@ function createResourceParams$f(config) {
     };
     return resourceParams;
 }
-function typeCheckConfig$f(untrustedConfig) {
+function typeCheckConfig$g(untrustedConfig) {
     const config = {};
     const untrustedConfig_contractId = untrustedConfig.contractId;
     if (typeof untrustedConfig_contractId === 'string') {
@@ -1004,30 +1011,30 @@ function typeCheckConfig$f(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$f(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$g(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$f(untrustedConfig);
+    const config = typeCheckConfig$g(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$f(luvio, config, options) {
-    const resourceParams = createResourceParams$f(config);
-    const request = createResourceRequest$f(resourceParams);
+function buildNetworkSnapshot$g(luvio, config, options) {
+    const resourceParams = createResourceParams$g(config);
+    const request = createResourceRequest$g(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$d(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$e(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$f(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$g(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -1037,12 +1044,12 @@ function buildNetworkSnapshot$f(luvio, config, options) {
 }
 const createContractDocumentVersionAndInitializeGenerateDocumentProcessAdapterFactory = (luvio) => {
     return function createContractDocumentVersionAndInitializeGenerateDocumentProcess(untrustedConfig) {
-        const config = validateAdapterConfig$f(untrustedConfig, createContractDocumentVersionAndInitializeGenerateDocumentProcess_ConfigPropertyNames);
+        const config = validateAdapterConfig$g(untrustedConfig, createContractDocumentVersionAndInitializeGenerateDocumentProcess_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createContractDocumentVersionAndInitializeGenerateDocumentProcess"');
         }
-        return buildNetworkSnapshot$f(luvio, config);
+        return buildNetworkSnapshot$g(luvio, config);
     };
 };
 
@@ -1136,19 +1143,19 @@ function validate$9(obj, path = 'ContractActionListRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$6 = 'ContractActionListRepresentation';
-function keyBuilder$g(luvio, config) {
+function keyBuilder$i(luvio, config) {
     return keyPrefix + '::' + RepresentationType$6 + ':' + config.contractId;
 }
 function keyBuilderFromType$4(luvio, object) {
     const keyParams = {
         contractId: object.contractId
     };
-    return keyBuilder$g(luvio, keyParams);
+    return keyBuilder$i(luvio, keyParams);
 }
 function normalize$6(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$j = function ContractActionListRepresentationSelect() {
+const select$k = function ContractActionListRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$6,
@@ -1202,24 +1209,24 @@ function getTypeCacheKeys$6(rootKeySet, luvio, input, fullPathFactory) {
     });
 }
 
-function select$i(luvio, params) {
-    return select$j();
+function select$j(luvio, params) {
+    return select$k();
 }
-function keyBuilder$f(luvio, params) {
-    return keyBuilder$g(luvio, {
+function keyBuilder$h(luvio, params) {
+    return keyBuilder$i(luvio, {
         contractId: params.urlParams.contractId
     });
 }
-function getResponseCacheKeys$e(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$f(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$6(storeKeyMap, luvio, response);
 }
-function ingestSuccess$c(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$d(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$f(luvio, resourceParams);
+    const key = keyBuilder$h(luvio, resourceParams);
     luvio.storeIngest(key, ingest$6, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$i(),
+        node: select$j(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -1230,8 +1237,8 @@ function ingestSuccess$c(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$4(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$f(luvio, params);
+function ingestError$5(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$h(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
         ttl: TTL$5,
@@ -1242,7 +1249,7 @@ function ingestError$4(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$e(config) {
+function createResourceRequest$f(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v59.0',
@@ -1263,7 +1270,7 @@ const getContractActions_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$e(config) {
+function createResourceParams$f(config) {
     const resourceParams = {
         urlParams: {
             contractId: config.contractId
@@ -1271,11 +1278,11 @@ function createResourceParams$e(config) {
     };
     return resourceParams;
 }
-function keyBuilder$e(luvio, config) {
-    const resourceParams = createResourceParams$e(config);
-    return keyBuilder$f(luvio, resourceParams);
+function keyBuilder$g(luvio, config) {
+    const resourceParams = createResourceParams$f(config);
+    return keyBuilder$h(luvio, resourceParams);
 }
-function typeCheckConfig$e(untrustedConfig) {
+function typeCheckConfig$f(untrustedConfig) {
     const config = {};
     const untrustedConfig_contractId = untrustedConfig.contractId;
     if (typeof untrustedConfig_contractId === 'string') {
@@ -1283,52 +1290,52 @@ function typeCheckConfig$e(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$e(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$f(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$e(untrustedConfig);
+    const config = typeCheckConfig$f(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$4(luvio, config) {
-    createResourceParams$e(config);
-    return select$i();
+function adapterFragment$5(luvio, config) {
+    createResourceParams$f(config);
+    return select$j();
 }
-function onFetchResponseSuccess$4(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$c(luvio, resourceParams, response, {
+function onFetchResponseSuccess$5(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$d(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$e(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$f(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$4(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$4(luvio, resourceParams, response, {
+function onFetchResponseError$5(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$5(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$e(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$f(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$e(luvio, config, options) {
-    const resourceParams = createResourceParams$e(config);
-    const request = createResourceRequest$e(resourceParams);
+function buildNetworkSnapshot$f(luvio, config, options) {
+    const resourceParams = createResourceParams$f(config);
+    const request = createResourceRequest$f(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$4(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$5(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$e(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$f(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$4(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$5(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext) {
+function buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext) {
     const { luvio, config } = context;
     const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
     const dispatchOptions = {
@@ -1343,44 +1350,44 @@ function buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext
             priority: networkPriority
         };
     }
-    return buildNetworkSnapshot$e(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$f(luvio, config, dispatchOptions);
 }
-function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$e(luvio, config),
-        node: adapterFragment$4(luvio, config),
+        recordId: keyBuilder$g(luvio, config),
+        node: adapterFragment$5(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$e(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$f(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getContractActionsAdapterFactory = (luvio) => function clm__getContractActions(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$e(untrustedConfig, getContractActions_ConfigPropertyNames);
+    const config = validateAdapterConfig$f(untrustedConfig, getContractActions_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$4, buildNetworkSnapshotCachePolicy$4);
+    buildCachedSnapshotCachePolicy$5, buildNetworkSnapshotCachePolicy$5);
 };
 
-function select$h(luvio, params) {
-    return select$l();
+function select$i(luvio, params) {
+    return select$m();
 }
-function getResponseCacheKeys$d(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$e(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$7(storeKeyMap, luvio, response);
 }
-function ingestSuccess$b(luvio, resourceParams, response) {
+function ingestSuccess$c(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$5(luvio, body);
     luvio.storeIngest(key, ingest$7, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$h(),
+        node: select$i(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -1391,7 +1398,7 @@ function ingestSuccess$b(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$d(config) {
+function createResourceRequest$e(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v59.0',
@@ -1412,7 +1419,7 @@ const updateContractDocumentVersionWithTemplate_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$d(config) {
+function createResourceParams$e(config) {
     const resourceParams = {
         urlParams: {
             contractDocumentVersionId: config.contractDocumentVersionId
@@ -1423,7 +1430,7 @@ function createResourceParams$d(config) {
     };
     return resourceParams;
 }
-function typeCheckConfig$d(untrustedConfig) {
+function typeCheckConfig$e(untrustedConfig) {
     const config = {};
     const untrustedConfig_contractDocumentVersionId = untrustedConfig.contractDocumentVersionId;
     if (typeof untrustedConfig_contractDocumentVersionId === 'string') {
@@ -1436,30 +1443,30 @@ function typeCheckConfig$d(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$d(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$e(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$d(untrustedConfig);
+    const config = typeCheckConfig$e(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$d(luvio, config, options) {
-    const resourceParams = createResourceParams$d(config);
-    const request = createResourceRequest$d(resourceParams);
+function buildNetworkSnapshot$e(luvio, config, options) {
+    const resourceParams = createResourceParams$e(config);
+    const request = createResourceRequest$e(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$b(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$c(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$d(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$e(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -1469,28 +1476,28 @@ function buildNetworkSnapshot$d(luvio, config, options) {
 }
 const updateContractDocumentVersionWithTemplateAdapterFactory = (luvio) => {
     return function updateContractDocumentVersionWithTemplate(untrustedConfig) {
-        const config = validateAdapterConfig$d(untrustedConfig, updateContractDocumentVersionWithTemplate_ConfigPropertyNames);
+        const config = validateAdapterConfig$e(untrustedConfig, updateContractDocumentVersionWithTemplate_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "updateContractDocumentVersionWithTemplate"');
         }
-        return buildNetworkSnapshot$d(luvio, config);
+        return buildNetworkSnapshot$e(luvio, config);
     };
 };
 
-function select$g(luvio, params) {
-    return select$q();
+function select$h(luvio, params) {
+    return select$r();
 }
-function getResponseCacheKeys$c(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$d(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$9(storeKeyMap, luvio, response);
 }
-function ingestSuccess$a(luvio, resourceParams, response) {
+function ingestSuccess$b(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$6(luvio, body);
     luvio.storeIngest(key, ingest$9, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$g(),
+        node: select$h(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -1501,7 +1508,7 @@ function ingestSuccess$a(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$c(config) {
+function createResourceRequest$d(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v59.0',
@@ -1522,7 +1529,7 @@ const checkIn_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$c(config) {
+function createResourceParams$d(config) {
     const resourceParams = {
         urlParams: {
             contractDocumentVersionId: config.contractDocumentVersionId
@@ -1530,7 +1537,7 @@ function createResourceParams$c(config) {
     };
     return resourceParams;
 }
-function typeCheckConfig$c(untrustedConfig) {
+function typeCheckConfig$d(untrustedConfig) {
     const config = {};
     const untrustedConfig_contractDocumentVersionId = untrustedConfig.contractDocumentVersionId;
     if (typeof untrustedConfig_contractDocumentVersionId === 'string') {
@@ -1538,30 +1545,30 @@ function typeCheckConfig$c(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$c(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$d(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$c(untrustedConfig);
+    const config = typeCheckConfig$d(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$c(luvio, config, options) {
-    const resourceParams = createResourceParams$c(config);
-    const request = createResourceRequest$c(resourceParams);
+function buildNetworkSnapshot$d(luvio, config, options) {
+    const resourceParams = createResourceParams$d(config);
+    const request = createResourceRequest$d(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$a(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$b(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$c(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$d(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -1571,28 +1578,28 @@ function buildNetworkSnapshot$c(luvio, config, options) {
 }
 const checkInAdapterFactory = (luvio) => {
     return function checkIn(untrustedConfig) {
-        const config = validateAdapterConfig$c(untrustedConfig, checkIn_ConfigPropertyNames);
+        const config = validateAdapterConfig$d(untrustedConfig, checkIn_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "checkIn"');
         }
-        return buildNetworkSnapshot$c(luvio, config);
+        return buildNetworkSnapshot$d(luvio, config);
     };
 };
 
-function select$f(luvio, params) {
-    return select$l();
+function select$g(luvio, params) {
+    return select$m();
 }
-function getResponseCacheKeys$b(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$c(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$7(storeKeyMap, luvio, response);
 }
-function ingestSuccess$9(luvio, resourceParams, response) {
+function ingestSuccess$a(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$5(luvio, body);
     luvio.storeIngest(key, ingest$7, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$f(),
+        node: select$g(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -1603,7 +1610,7 @@ function ingestSuccess$9(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$b(config) {
+function createResourceRequest$c(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v59.0',
@@ -1624,7 +1631,7 @@ const checkoutContractDocumentVersion_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$b(config) {
+function createResourceParams$c(config) {
     const resourceParams = {
         urlParams: {
             contractDocumentVersionId: config.contractDocumentVersionId
@@ -1635,7 +1642,7 @@ function createResourceParams$b(config) {
     };
     return resourceParams;
 }
-function typeCheckConfig$b(untrustedConfig) {
+function typeCheckConfig$c(untrustedConfig) {
     const config = {};
     const untrustedConfig_contractDocumentVersionId = untrustedConfig.contractDocumentVersionId;
     if (typeof untrustedConfig_contractDocumentVersionId === 'string') {
@@ -1648,30 +1655,30 @@ function typeCheckConfig$b(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$b(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$c(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$b(untrustedConfig);
+    const config = typeCheckConfig$c(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$b(luvio, config, options) {
-    const resourceParams = createResourceParams$b(config);
-    const request = createResourceRequest$b(resourceParams);
+function buildNetworkSnapshot$c(luvio, config, options) {
+    const resourceParams = createResourceParams$c(config);
+    const request = createResourceRequest$c(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$9(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$a(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$b(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$c(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -1681,12 +1688,12 @@ function buildNetworkSnapshot$b(luvio, config, options) {
 }
 const checkoutContractDocumentVersionAdapterFactory = (luvio) => {
     return function checkoutContractDocumentVersion(untrustedConfig) {
-        const config = validateAdapterConfig$b(untrustedConfig, checkoutContractDocumentVersion_ConfigPropertyNames);
+        const config = validateAdapterConfig$c(untrustedConfig, checkoutContractDocumentVersion_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "checkoutContractDocumentVersion"');
         }
-        return buildNetworkSnapshot$b(luvio, config);
+        return buildNetworkSnapshot$c(luvio, config);
     };
 };
 
@@ -1723,19 +1730,19 @@ function validate$8(obj, path = 'ContentDocumentListRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$5 = 'ContentDocumentListRepresentation';
-function keyBuilder$d(luvio, config) {
+function keyBuilder$f(luvio, config) {
     return keyPrefix + '::' + RepresentationType$5 + ':' + config.contractDocumentVersionId;
 }
 function keyBuilderFromType$3(luvio, object) {
     const keyParams = {
         contractDocumentVersionId: object.contractDocumentVersionId
     };
-    return keyBuilder$d(luvio, keyParams);
+    return keyBuilder$f(luvio, keyParams);
 }
 function normalize$5(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$e = function ContentDocumentListRepresentationSelect() {
+const select$f = function ContentDocumentListRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$5,
@@ -1789,13 +1796,13 @@ function getTypeCacheKeys$5(rootKeySet, luvio, input, fullPathFactory) {
     });
 }
 
-function keyBuilder$c(luvio, params) {
-    return keyBuilder$d(luvio, {
+function keyBuilder$e(luvio, params) {
+    return keyBuilder$f(luvio, {
         contractDocumentVersionId: params.urlParams.contractDocumentVersionId
     });
 }
-function getResponseCacheKeys$a(cacheKeyMap, luvio, resourceParams) {
-    const key = keyBuilder$c(luvio, resourceParams);
+function getResponseCacheKeys$b(cacheKeyMap, luvio, resourceParams) {
+    const key = keyBuilder$e(luvio, resourceParams);
     cacheKeyMap.set(key, {
         namespace: keyPrefix,
         representationName: RepresentationType$5,
@@ -1803,10 +1810,10 @@ function getResponseCacheKeys$a(cacheKeyMap, luvio, resourceParams) {
     });
 }
 function evictSuccess$1(luvio, resourceParams) {
-    const key = keyBuilder$c(luvio, resourceParams);
+    const key = keyBuilder$e(luvio, resourceParams);
     luvio.storeEvict(key);
 }
-function createResourceRequest$a(config) {
+function createResourceRequest$b(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v59.0',
@@ -1828,7 +1835,7 @@ const deleteAttachment_ConfigPropertyNames = {
         optional: ['contentDocumentId']
     }
 };
-function createResourceParams$a(config) {
+function createResourceParams$b(config) {
     const resourceParams = {
         urlParams: {
             contractDocumentVersionId: config.contractDocumentVersionId
@@ -1839,7 +1846,7 @@ function createResourceParams$a(config) {
     };
     return resourceParams;
 }
-function typeCheckConfig$a(untrustedConfig) {
+function typeCheckConfig$b(untrustedConfig) {
     const config = {};
     const untrustedConfig_contractDocumentVersionId = untrustedConfig.contractDocumentVersionId;
     if (typeof untrustedConfig_contractDocumentVersionId === 'string') {
@@ -1851,22 +1858,22 @@ function typeCheckConfig$a(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$a(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$b(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$a(untrustedConfig);
+    const config = typeCheckConfig$b(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$a(luvio, config, options) {
-    const resourceParams = createResourceParams$a(config);
-    const request = createResourceRequest$a(resourceParams);
+function buildNetworkSnapshot$b(luvio, config, options) {
+    const resourceParams = createResourceParams$b(config);
+    const request = createResourceRequest$b(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then(() => {
         return luvio.handleSuccessResponse(() => {
@@ -1874,7 +1881,7 @@ function buildNetworkSnapshot$a(luvio, config, options) {
             return luvio.storeBroadcast();
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$a(cache, luvio, resourceParams);
+            getResponseCacheKeys$b(cache, luvio, resourceParams);
             return cache;
         });
     }, (response) => {
@@ -1884,33 +1891,33 @@ function buildNetworkSnapshot$a(luvio, config, options) {
 }
 const deleteAttachmentAdapterFactory = (luvio) => {
     return function clmdeleteAttachment(untrustedConfig) {
-        const config = validateAdapterConfig$a(untrustedConfig, deleteAttachment_ConfigPropertyNames);
+        const config = validateAdapterConfig$b(untrustedConfig, deleteAttachment_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error(`Invalid config for "${adapterName$1}"`);
         }
-        return buildNetworkSnapshot$a(luvio, config);
+        return buildNetworkSnapshot$b(luvio, config);
     };
 };
 
-function select$d(luvio, params) {
-    return select$e();
+function select$e(luvio, params) {
+    return select$f();
 }
-function keyBuilder$b(luvio, params) {
-    return keyBuilder$d(luvio, {
+function keyBuilder$d(luvio, params) {
+    return keyBuilder$f(luvio, {
         contractDocumentVersionId: params.urlParams.contractDocumentVersionId
     });
 }
-function getResponseCacheKeys$9(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$a(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$5(storeKeyMap, luvio, response);
 }
-function ingestSuccess$8(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$9(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$b(luvio, resourceParams);
+    const key = keyBuilder$d(luvio, resourceParams);
     luvio.storeIngest(key, ingest$5, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$d(),
+        node: select$e(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -1921,8 +1928,8 @@ function ingestSuccess$8(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$3(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$b(luvio, params);
+function ingestError$4(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$d(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
         ttl: TTL$4,
@@ -1933,7 +1940,7 @@ function ingestError$3(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$9(config) {
+function createResourceRequest$a(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v59.0',
@@ -1954,7 +1961,7 @@ const getContentDocument_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$9(config) {
+function createResourceParams$a(config) {
     const resourceParams = {
         urlParams: {
             contractDocumentVersionId: config.contractDocumentVersionId
@@ -1962,11 +1969,11 @@ function createResourceParams$9(config) {
     };
     return resourceParams;
 }
-function keyBuilder$a(luvio, config) {
-    const resourceParams = createResourceParams$9(config);
-    return keyBuilder$b(luvio, resourceParams);
+function keyBuilder$c(luvio, config) {
+    const resourceParams = createResourceParams$a(config);
+    return keyBuilder$d(luvio, resourceParams);
 }
-function typeCheckConfig$9(untrustedConfig) {
+function typeCheckConfig$a(untrustedConfig) {
     const config = {};
     const untrustedConfig_contractDocumentVersionId = untrustedConfig.contractDocumentVersionId;
     if (typeof untrustedConfig_contractDocumentVersionId === 'string') {
@@ -1974,52 +1981,52 @@ function typeCheckConfig$9(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$a(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$9(untrustedConfig);
+    const config = typeCheckConfig$a(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$3(luvio, config) {
-    createResourceParams$9(config);
-    return select$d();
+function adapterFragment$4(luvio, config) {
+    createResourceParams$a(config);
+    return select$e();
 }
-function onFetchResponseSuccess$3(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$8(luvio, resourceParams, response, {
+function onFetchResponseSuccess$4(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$9(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$3(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$3(luvio, resourceParams, response, {
+function onFetchResponseError$4(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$4(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$9(luvio, config, options) {
-    const resourceParams = createResourceParams$9(config);
-    const request = createResourceRequest$9(resourceParams);
+function buildNetworkSnapshot$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$3(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$4(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$9(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$a(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$3(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$4(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext) {
+function buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext) {
     const { luvio, config } = context;
     const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
     const dispatchOptions = {
@@ -2034,44 +2041,44 @@ function buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext
             priority: networkPriority
         };
     }
-    return buildNetworkSnapshot$9(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$a(luvio, config, dispatchOptions);
 }
-function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$a(luvio, config),
-        node: adapterFragment$3(luvio, config),
+        recordId: keyBuilder$c(luvio, config),
+        node: adapterFragment$4(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getContentDocumentAdapterFactory = (luvio) => function clm__getContentDocument(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$9(untrustedConfig, getContentDocument_ConfigPropertyNames);
+    const config = validateAdapterConfig$a(untrustedConfig, getContentDocument_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$3, buildNetworkSnapshotCachePolicy$3);
+    buildCachedSnapshotCachePolicy$4, buildNetworkSnapshotCachePolicy$4);
 };
 
-function select$c(luvio, params) {
-    return select$q();
+function select$d(luvio, params) {
+    return select$r();
 }
-function getResponseCacheKeys$8(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$9(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$9(storeKeyMap, luvio, response);
 }
-function ingestSuccess$7(luvio, resourceParams, response) {
+function ingestSuccess$8(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$6(luvio, body);
     luvio.storeIngest(key, ingest$9, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$c(),
+        node: select$d(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -2082,7 +2089,7 @@ function ingestSuccess$7(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$8(config) {
+function createResourceRequest$9(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v59.0',
@@ -2103,7 +2110,7 @@ const lockContractDocumentVersion_ConfigPropertyNames = {
         optional: []
     }
 };
-function createResourceParams$8(config) {
+function createResourceParams$9(config) {
     const resourceParams = {
         urlParams: {
             contractDocumentVersionId: config.contractDocumentVersionId
@@ -2111,7 +2118,7 @@ function createResourceParams$8(config) {
     };
     return resourceParams;
 }
-function typeCheckConfig$8(untrustedConfig) {
+function typeCheckConfig$9(untrustedConfig) {
     const config = {};
     const untrustedConfig_contractDocumentVersionId = untrustedConfig.contractDocumentVersionId;
     if (typeof untrustedConfig_contractDocumentVersionId === 'string') {
@@ -2119,30 +2126,30 @@ function typeCheckConfig$8(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$8(untrustedConfig);
+    const config = typeCheckConfig$9(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$8(luvio, config, options) {
-    const resourceParams = createResourceParams$8(config);
-    const request = createResourceRequest$8(resourceParams);
+function buildNetworkSnapshot$9(luvio, config, options) {
+    const resourceParams = createResourceParams$9(config);
+    const request = createResourceRequest$9(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$7(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$8(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$8(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$9(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -2152,15 +2159,179 @@ function buildNetworkSnapshot$8(luvio, config, options) {
 }
 const lockContractDocumentVersionAdapterFactory = (luvio) => {
     return function lockContractDocumentVersion(untrustedConfig) {
-        const config = validateAdapterConfig$8(untrustedConfig, lockContractDocumentVersion_ConfigPropertyNames);
+        const config = validateAdapterConfig$9(untrustedConfig, lockContractDocumentVersion_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "lockContractDocumentVersion"');
         }
-        return buildNetworkSnapshot$8(luvio, config);
+        return buildNetworkSnapshot$9(luvio, config);
     };
 };
 
+function select$c(luvio, params) {
+    return select$r();
+}
+function keyBuilder$b(luvio, params) {
+    return keyPrefix + '::GenericOutputRepresentation:(' + 'contractDocumentVersionId:' + params.urlParams.contractDocumentVersionId + ')';
+}
+function getResponseCacheKeys$8(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$9(storeKeyMap, luvio, response);
+}
+function ingestSuccess$7(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$b(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$9, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$c(),
+        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$3(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$b(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    const storeMetadataParams = {
+        ttl: TTL$8,
+        namespace: keyPrefix,
+        version: VERSION$a,
+        representationName: RepresentationType$9
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
+function createResourceRequest$8(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v59.0',
+        basePath: '/connect/clm/contract-document-version/' + config.urlParams.contractDocumentVersionId + '/externalReviewDocument',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const getExternalReviewDocument_ConfigPropertyNames = {
+    displayName: 'getExternalReviewDocument',
+    parameters: {
+        required: ['contractDocumentVersionId'],
+        optional: []
+    }
+};
+function createResourceParams$8(config) {
+    const resourceParams = {
+        urlParams: {
+            contractDocumentVersionId: config.contractDocumentVersionId
+        }
+    };
+    return resourceParams;
+}
+function keyBuilder$a(luvio, config) {
+    const resourceParams = createResourceParams$8(config);
+    return keyBuilder$b(luvio, resourceParams);
+}
+function typeCheckConfig$8(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contractDocumentVersionId = untrustedConfig.contractDocumentVersionId;
+    if (typeof untrustedConfig_contractDocumentVersionId === 'string') {
+        config.contractDocumentVersionId = untrustedConfig_contractDocumentVersionId;
+    }
+    return config;
+}
+function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$8(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment$3(luvio, config) {
+    createResourceParams$8(config);
+    return select$c();
+}
+function onFetchResponseSuccess$3(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$7(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError$3(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$3(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$8(luvio, config, options) {
+    const resourceParams = createResourceParams$8(config);
+    const request = createResourceRequest$8(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$3(luvio, config, resourceParams, response), () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$8(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$3(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext) {
+    const { luvio, config } = context;
+    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
+    const dispatchOptions = {
+        resourceRequestContext: {
+            requestCorrelator,
+            luvioRequestMethod: undefined,
+        },
+        eventObservers
+    };
+    if (networkPriority !== 'normal') {
+        dispatchOptions.overrides = {
+            priority: networkPriority
+        };
+    }
+    return buildNetworkSnapshot$8(luvio, config, dispatchOptions);
+}
+function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$a(luvio, config),
+        node: adapterFragment$3(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getExternalReviewDocumentAdapterFactory = (luvio) => function clm__getExternalReviewDocument(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$8(untrustedConfig, getExternalReviewDocument_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$3, buildNetworkSnapshotCachePolicy$3);
+};
+
 function validate$7(obj, path = 'ContractDocumentVersionReviewerOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -2889,7 +3060,7 @@ const postContractDocumentVersionReviewAdapterFactory = (luvio) => {
 };
 
 function select$6(luvio, params) {
-    return select$q();
+    return select$r();
 }
 function getResponseCacheKeys$3(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$9(storeKeyMap, luvio, response);
@@ -3061,7 +3232,7 @@ function normalize$2(input, existing, path, luvio, store, timestamp) {
     return input;
 }
 const select$5 = function DocumentGenerationProcessStatusRepresentationSelect() {
-    const { selections: ContentDocumentRepresentation__selections, opaque: ContentDocumentRepresentation__opaque, } = select$m();
+    const { selections: ContentDocumentRepresentation__selections, opaque: ContentDocumentRepresentation__opaque, } = select$n();
     return {
         kind: 'Fragment',
         version: VERSION$2,
@@ -3924,4 +4095,4 @@ const saveExternalDocumentAdapterFactory = (luvio) => {
     };
 };
 
-export { checkInAdapterFactory, checkoutContractDocumentVersionAdapterFactory, createContractDocumentVersionAndInitializeGenerateDocumentProcessAdapterFactory, deleteAttachmentAdapterFactory, deleteContractDocumentVersionReviewAdapterFactory, executeContractActionAdapterFactory, getContentDocumentAdapterFactory, getContractActionsAdapterFactory, getContractDocumentVersionAdapterFactory, getContractDocumentVersionReviewAdapterFactory, getDocumentGenerationProcessDetailsAdapterFactory, getTemplatesAdapterFactory, lockContractDocumentVersionAdapterFactory, patchContractDocumentVersionReviewAdapterFactory, postContractDocumentVersionReviewAdapterFactory, saveExternalDocumentAdapterFactory, unlockAdapterFactory, updateContractDocumentVersionWithTemplateAdapterFactory };
+export { checkInAdapterFactory, checkoutContractDocumentVersionAdapterFactory, createContractDocumentVersionAndInitializeGenerateDocumentProcessAdapterFactory, deleteAttachmentAdapterFactory, deleteContractDocumentVersionReviewAdapterFactory, executeContractActionAdapterFactory, getContentDocumentAdapterFactory, getContractActionsAdapterFactory, getContractDocumentVersionAdapterFactory, getContractDocumentVersionReviewAdapterFactory, getDocumentGenerationProcessDetailsAdapterFactory, getExternalReviewDocumentAdapterFactory, getTemplatesAdapterFactory, lockContractDocumentVersionAdapterFactory, patchContractDocumentVersionReviewAdapterFactory, postContractDocumentVersionReviewAdapterFactory, saveExternalDocumentAdapterFactory, unlockAdapterFactory, updateContractDocumentVersionWithTemplateAdapterFactory };