@salesforce/lds-adapters-industries-docgen 1.212.1 → 1.213.1

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

@@ -4,7 +4,7 @@
  * For full license text, see the LICENSE.txt file
  */
 
-import { serializeStructuredKey, deepFreeze, typeCheckScalars, StoreKeyMap } from '@luvio/engine';
+import { serializeStructuredKey, ingestShape, deepFreeze, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$7, typeCheckScalars, StoreKeyMap } from '@luvio/engine';
 
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
 const { keys: ObjectKeys$1, create: ObjectCreate$1 } = Object;
@@ -48,6 +48,24 @@ const snapshotRefreshOptions = {
         },
     }
 };
+function generateParamConfigMetadata(name, required, coerceFn) {
+    return {
+        name,
+        required,
+        coerceFn,
+    };
+}
+function buildAdapterValidationConfig(displayName, paramsMeta) {
+    const required = paramsMeta.filter(p => p.required).map(p => p.name);
+    const optional = paramsMeta.filter(p => !p.required).map(p => p.name);
+    return {
+        displayName,
+        parameters: {
+            required,
+            optional,
+        }
+    };
+}
 const keyPrefix = 'docgen';
 
 const { keys: ObjectKeys, create: ObjectCreate, assign: ObjectAssign } = Object;
@@ -232,26 +250,8 @@ const ingest$a = function ClauseCategoriesResponseIngest(input, path, luvio, sto
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$6;
-    let incomingRecord = normalize$a(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$g(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "docgen",
-            version: VERSION$g,
-            representationName: RepresentationType$a,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$a, "docgen", VERSION$g, RepresentationType$a, equals$g);
     return createLink(key);
 };
 function getTypeCacheKeys$a(rootKeySet, luvio, input, fullPathFactory) {
@@ -316,13 +316,13 @@ function createResourceRequest$a(config) {
     };
 }
 
-const getDocumentClauseSetCategories_ConfigPropertyNames = {
-    displayName: 'getDocumentClauseSetCategories',
-    parameters: {
-        required: [],
-        optional: ['id', 'name', 'usageType']
-    }
-};
+const adapterName$a = 'getDocumentClauseSetCategories';
+const getDocumentClauseSetCategories_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('id', false),
+    generateParamConfigMetadata('name', false),
+    generateParamConfigMetadata('usageType', false),
+];
+const getDocumentClauseSetCategories_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$a, getDocumentClauseSetCategories_ConfigPropertyMetadata);
 function createResourceParams$a(config) {
     const resourceParams = {
         queryParams: {
@@ -390,21 +390,7 @@ function buildNetworkSnapshot$a(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$6(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$a(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext, buildNetworkSnapshot$a, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
     const { luvio, config } = context;
@@ -601,26 +587,8 @@ const ingest$9 = function DocumentClauseSetListResponseIngest(input, path, luvio
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$5;
-    let incomingRecord = normalize$9(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$e(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "docgen",
-            version: VERSION$e,
-            representationName: RepresentationType$9,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$9, "docgen", VERSION$e, RepresentationType$9, equals$e);
     return createLink(key);
 };
 function getTypeCacheKeys$9(rootKeySet, luvio, input, fullPathFactory) {
@@ -685,13 +653,16 @@ function createResourceRequest$9(config) {
     };
 }
 
-const getDocumentClauseSets_ConfigPropertyNames = {
-    displayName: 'getDocumentClauseSets',
-    parameters: {
-        required: [],
-        optional: ['category', 'defaultLanguage', 'limit', 'name', 'offset', 'status']
-    }
-};
+const adapterName$9 = 'getDocumentClauseSets';
+const getDocumentClauseSets_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('category', false),
+    generateParamConfigMetadata('defaultLanguage', false),
+    generateParamConfigMetadata('limit', false),
+    generateParamConfigMetadata('name', false),
+    generateParamConfigMetadata('offset', false),
+    generateParamConfigMetadata('status', false),
+];
+const getDocumentClauseSets_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$9, getDocumentClauseSets_ConfigPropertyMetadata);
 function createResourceParams$9(config) {
     const resourceParams = {
         queryParams: {
@@ -762,21 +733,7 @@ function buildNetworkSnapshot$9(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$5(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$9(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext, buildNetworkSnapshot$9, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
     const { luvio, config } = context;
@@ -877,26 +834,8 @@ const ingest$8 = function DocumentClauseFieldsResponseIngest(input, path, luvio,
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$4;
-    let incomingRecord = normalize$8(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$d(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "docgen",
-            version: VERSION$d,
-            representationName: RepresentationType$8,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$8, "docgen", VERSION$d, RepresentationType$8, equals$d);
     return createLink(key);
 };
 function getTypeCacheKeys$8(rootKeySet, luvio, input, fullPathFactory) {
@@ -961,13 +900,16 @@ function createResourceRequest$8(config) {
     };
 }
 
-const getDocumentClauseFields_ConfigPropertyNames = {
-    displayName: 'getDocumentClauseFields',
-    parameters: {
-        required: [],
-        optional: ['clauseSetId', 'extendedFields', 'fieldName', 'language', 'name', 'status']
-    }
-};
+const adapterName$8 = 'getDocumentClauseFields';
+const getDocumentClauseFields_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('clauseSetId', false),
+    generateParamConfigMetadata('extendedFields', false),
+    generateParamConfigMetadata('fieldName', false),
+    generateParamConfigMetadata('language', false),
+    generateParamConfigMetadata('name', false),
+    generateParamConfigMetadata('status', false),
+];
+const getDocumentClauseFields_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$8, getDocumentClauseFields_ConfigPropertyMetadata);
 function createResourceParams$8(config) {
     const resourceParams = {
         queryParams: {
@@ -1038,21 +980,7 @@ function buildNetworkSnapshot$8(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$4(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);
+    return buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext, buildNetworkSnapshot$8, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
     const { luvio, config } = context;
@@ -1158,26 +1086,8 @@ const ingest$7 = function GenericOutputRepresentationIngest(input, path, luvio,
         }
     }
     const key = keyBuilderFromType$3(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 360000;
-    let incomingRecord = normalize$7(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$c(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    if (ttlToUse !== undefined) {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "docgen",
-            version: VERSION$c,
-            representationName: RepresentationType$7,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$7, "docgen", VERSION$c, RepresentationType$7, equals$c);
     return createLink(key);
 };
 function getTypeCacheKeys$7(rootKeySet, luvio, input, fullPathFactory) {
@@ -1227,13 +1137,12 @@ function createResourceRequest$7(config) {
     };
 }
 
-const performDocGenerationBatchProcessAction_ConfigPropertyNames = {
-    displayName: 'performDocGenerationBatchProcessAction',
-    parameters: {
-        required: ['actionName', 'docGenerationBatchProcessId'],
-        optional: []
-    }
-};
+const adapterName$7 = 'performDocGenerationBatchProcessAction';
+const performDocGenerationBatchProcessAction_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('actionName', true),
+    generateParamConfigMetadata('docGenerationBatchProcessId', true),
+];
+const performDocGenerationBatchProcessAction_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$7, performDocGenerationBatchProcessAction_ConfigPropertyMetadata);
 function createResourceParams$7(config) {
     const resourceParams = {
         urlParams: {
@@ -1531,26 +1440,8 @@ const ingest$6 = function DocumentListResponseIngest(input, path, luvio, store,
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$3;
-    let incomingRecord = normalize$6(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$a(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "docgen",
-            version: VERSION$a,
-            representationName: RepresentationType$6,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$6, "docgen", VERSION$a, RepresentationType$6, equals$a);
     return createLink(key);
 };
 function getTypeCacheKeys$6(rootKeySet, luvio, input, fullPathFactory) {
@@ -1615,13 +1506,12 @@ function createResourceRequest$6(config) {
     };
 }
 
-const getDocuments_ConfigPropertyNames = {
-    displayName: 'getDocuments',
-    parameters: {
-        required: [],
-        optional: ['documentSelector', 'sourceObjectId']
-    }
-};
+const adapterName$6 = 'getDocuments';
+const getDocuments_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('documentSelector', false),
+    generateParamConfigMetadata('sourceObjectId', false),
+];
+const getDocuments_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$6, getDocuments_ConfigPropertyMetadata);
 function createResourceParams$6(config) {
     const resourceParams = {
         queryParams: {
@@ -1688,21 +1578,7 @@ function buildNetworkSnapshot$6(luvio, config, options) {
     });
 }
 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$6(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext, buildNetworkSnapshot$6, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
     const { luvio, config } = context;
@@ -2040,26 +1916,8 @@ const ingest$5 = function NotificationSettingResponseIngest(input, path, luvio,
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$2;
-    let incomingRecord = normalize$5(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$7(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "docgen",
-            version: VERSION$7,
-            representationName: RepresentationType$5,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$5, "docgen", VERSION$7, RepresentationType$5, equals$7);
     return createLink(key);
 };
 function getTypeCacheKeys$5(rootKeySet, luvio, input, fullPathFactory) {
@@ -2124,13 +1982,11 @@ function createResourceRequest$5(config) {
     };
 }
 
-const getESignNotificationSettings_ConfigPropertyNames = {
-    displayName: 'getESignNotificationSettings',
-    parameters: {
-        required: [],
-        optional: ['sourceObjectId']
-    }
-};
+const adapterName$5 = 'getESignNotificationSettings';
+const getESignNotificationSettings_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('sourceObjectId', false),
+];
+const getESignNotificationSettings_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, getESignNotificationSettings_ConfigPropertyMetadata);
 function createResourceParams$5(config) {
     const resourceParams = {
         queryParams: {
@@ -2196,21 +2052,7 @@ function buildNetworkSnapshot$5(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$2(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$5(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext, buildNetworkSnapshot$5, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
     const { luvio, config } = context;
@@ -2449,26 +2291,8 @@ const ingest$4 = function RecipientListResponseIngest(input, path, luvio, store,
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL$1;
-    let incomingRecord = normalize$4(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$5(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "docgen",
-            version: VERSION$5,
-            representationName: RepresentationType$4,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$4, "docgen", VERSION$5, RepresentationType$4, equals$5);
     return createLink(key);
 };
 function getTypeCacheKeys$4(rootKeySet, luvio, input, fullPathFactory) {
@@ -2533,13 +2357,12 @@ function createResourceRequest$4(config) {
     };
 }
 
-const getRecipients_ConfigPropertyNames = {
-    displayName: 'getRecipients',
-    parameters: {
-        required: [],
-        optional: ['recipientSelector', 'sourceObjectId']
-    }
-};
+const adapterName$4 = 'getRecipients';
+const getRecipients_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('recipientSelector', false),
+    generateParamConfigMetadata('sourceObjectId', false),
+];
+const getRecipients_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, getRecipients_ConfigPropertyMetadata);
 function createResourceParams$4(config) {
     const resourceParams = {
         queryParams: {
@@ -2606,21 +2429,7 @@ function buildNetworkSnapshot$4(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext) {
-    const { luvio, config } = context;
-    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
-    const dispatchOptions = {
-        resourceRequestContext: {
-            requestCorrelator,
-            luvioRequestMethod: undefined,
-        },
-        eventObservers
-    };
-    if (networkPriority !== 'normal') {
-        dispatchOptions.overrides = {
-            priority: networkPriority
-        };
-    }
-    return buildNetworkSnapshot$4(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext, buildNetworkSnapshot$4, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
     const { luvio, config } = context;
@@ -2774,26 +2583,8 @@ const ingest$3 = function EnvelopeSendResponseIngest(input, path, luvio, store,
         }
     }
     const key = keyBuilderFromType$2(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 360000;
-    let incomingRecord = normalize$3(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$4(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    if (ttlToUse !== undefined) {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "docgen",
-            version: VERSION$4,
-            representationName: RepresentationType$3,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$3, "docgen", VERSION$4, RepresentationType$3, equals$4);
     return createLink(key);
 };
 function getTypeCacheKeys$3(rootKeySet, luvio, input, fullPathFactory) {
@@ -2843,13 +2634,12 @@ function createResourceRequest$3(config) {
     };
 }
 
-const createDocumentEnvelopeForEsign_ConfigPropertyNames = {
-    displayName: 'createDocumentEnvelopeForEsign',
-    parameters: {
-        required: ['sourceObjectId', 'envelope'],
-        optional: []
-    }
-};
+const adapterName$3 = 'createDocumentEnvelopeForEsign';
+const createDocumentEnvelopeForEsign_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('sourceObjectId', true),
+    generateParamConfigMetadata('envelope', true),
+];
+const createDocumentEnvelopeForEsign_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, createDocumentEnvelopeForEsign_ConfigPropertyMetadata);
 function createResourceParams$3(config) {
     const resourceParams = {
         urlParams: {
@@ -3145,26 +2935,8 @@ const ingest$2 = function EnvelopeStatusListResponseIngest(input, path, luvio, s
         }
     }
     const key = keyBuilderFromType$1(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 360000;
-    let incomingRecord = normalize$2(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$2(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    if (ttlToUse !== undefined) {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "docgen",
-            version: VERSION$2,
-            representationName: RepresentationType$2,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$2, "docgen", VERSION$2, RepresentationType$2, equals$2);
     return createLink(key);
 };
 function getTypeCacheKeys$2(rootKeySet, luvio, input, fullPathFactory) {
@@ -3214,13 +2986,11 @@ function createResourceRequest$2(config) {
     };
 }
 
-const updateEnvelope_ConfigPropertyNames = {
-    displayName: 'updateEnvelope',
-    parameters: {
-        required: ['sourceObjectId'],
-        optional: []
-    }
-};
+const adapterName$2 = 'updateEnvelope';
+const updateEnvelope_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('sourceObjectId', true),
+];
+const updateEnvelope_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, updateEnvelope_ConfigPropertyMetadata);
 function createResourceParams$2(config) {
     const resourceParams = {
         urlParams: {
@@ -3440,26 +3210,8 @@ const ingest$1 = function EnvelopeVoidResponseIngest(input, path, luvio, store,
         }
     }
     const key = keyBuilderFromType(luvio, input);
-    const existingRecord = store.readEntry(key);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 360000;
-    let incomingRecord = normalize$1(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals$1(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    if (ttlToUse !== undefined) {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "docgen",
-            version: VERSION$1,
-            representationName: RepresentationType$1,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$1, "docgen", VERSION$1, RepresentationType$1, equals$1);
     return createLink(key);
 };
 function getTypeCacheKeys$1(rootKeySet, luvio, input, fullPathFactory) {
@@ -3509,13 +3261,12 @@ function createResourceRequest$1(config) {
     };
 }
 
-const updateVoidedEnvelope_ConfigPropertyNames = {
-    displayName: 'updateVoidedEnvelope',
-    parameters: {
-        required: ['sourceObjectId', 'voidParam'],
-        optional: []
-    }
-};
+const adapterName$1 = 'updateVoidedEnvelope';
+const updateVoidedEnvelope_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('sourceObjectId', true),
+    generateParamConfigMetadata('voidParam', true),
+];
+const updateVoidedEnvelope_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, updateVoidedEnvelope_ConfigPropertyMetadata);
 function createResourceParams$1(config) {
     const resourceParams = {
         urlParams: {
@@ -3653,26 +3404,8 @@ const ingest = function SignerRolesResponseIngest(input, path, luvio, store, tim
         }
     }
     const key = path.fullPath;
-    const existingRecord = store.readEntry(key);
     const ttlToUse = TTL;
-    let incomingRecord = normalize(input, store.readEntry(key), {
-        fullPath: key,
-        parent: path.parent,
-        propertyName: path.propertyName,
-        ttl: ttlToUse
-    });
-    if (existingRecord === undefined || equals(existingRecord, incomingRecord) === false) {
-        luvio.storePublish(key, incomingRecord);
-    }
-    {
-        const storeMetadataParams = {
-            ttl: ttlToUse,
-            namespace: "docgen",
-            version: VERSION,
-            representationName: RepresentationType,
-        };
-        luvio.publishStoreMetadata(key, storeMetadataParams);
-    }
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize, "docgen", VERSION, RepresentationType, equals);
     return createLink(key);
 };
 function getTypeCacheKeys(rootKeySet, luvio, input, fullPathFactory) {
@@ -3737,13 +3470,9 @@ function createResourceRequest(config) {
     };
 }
 
-const getSignerRoles_ConfigPropertyNames = {
-    displayName: 'getSignerRoles',
-    parameters: {
-        required: [],
-        optional: []
-    }
-};
+const adapterName = 'getSignerRoles';
+const getSignerRoles_ConfigPropertyMetadata = [];
+const getSignerRoles_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, getSignerRoles_ConfigPropertyMetadata);
 function createResourceParams(config) {
     const resourceParams = {};
     return resourceParams;
@@ -3800,21 +3529,7 @@ function buildNetworkSnapshot(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy(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(luvio, config, dispatchOptions);
+    return buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext, buildNetworkSnapshot, undefined, false);
 }
 function buildCachedSnapshotCachePolicy(context, storeLookup) {
     const { luvio, config } = context;