@salesforce/lds-adapters-industries-clm 1.100.2

package/sfdc/index.js

@@ -0,0 +1,3417 @@
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/*  *******************************************************************************************
+ *  ATTENTION!
+ *  THIS IS A GENERATED FILE FROM https://github.com/salesforce-experience-platform-emu/lds-lightning-platform
+ *  If you would like to contribute to LDS, please follow the steps outlined in the git repo.
+ *  Any changes made to this file in p4 will be automatically overwritten.
+ *  *******************************************************************************************
+ */
+/* proxy-compat-disable */
+import { createInstrumentedAdapter, createLDSAdapter, createWireAdapterConstructor, createImperativeAdapter } from 'force/ldsBindings';
+import { withDefaultLuvio } from 'force/ldsEngine';
+import { serializeStructuredKey, StoreKeyMap } from 'force/luvioEngine';
+
+const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
+const { keys: ObjectKeys$1, freeze: ObjectFreeze$1, create: ObjectCreate$1 } = Object;
+const { isArray: ArrayIsArray$1 } = Array;
+/**
+ * Validates an adapter config is well-formed.
+ * @param config The config to validate.
+ * @param adapter The adapter validation configuration.
+ * @param oneOf The keys the config must contain at least one of.
+ * @throws A TypeError if config doesn't satisfy the adapter's config validation.
+ */
+function validateConfig(config, adapter, oneOf) {
+    const { displayName } = adapter;
+    const { required, optional, unsupported } = adapter.parameters;
+    if (config === undefined ||
+        required.every(req => ObjectPrototypeHasOwnProperty.call(config, req)) === false) {
+        throw new TypeError(`adapter ${displayName} configuration must specify ${required.sort().join(', ')}`);
+    }
+    if (oneOf && oneOf.some(req => ObjectPrototypeHasOwnProperty.call(config, req)) === false) {
+        throw new TypeError(`adapter ${displayName} configuration must specify one of ${oneOf.sort().join(', ')}`);
+    }
+    if (unsupported !== undefined &&
+        unsupported.some(req => ObjectPrototypeHasOwnProperty.call(config, req))) {
+        throw new TypeError(`adapter ${displayName} does not yet support ${unsupported.sort().join(', ')}`);
+    }
+    const supported = required.concat(optional);
+    if (ObjectKeys$1(config).some(key => !supported.includes(key))) {
+        throw new TypeError(`adapter ${displayName} configuration supports only ${supported.sort().join(', ')}`);
+    }
+}
+function untrustedIsObject(untrusted) {
+    return typeof untrusted === 'object' && untrusted !== null && ArrayIsArray$1(untrusted) === false;
+}
+function areRequiredParametersPresent(config, configPropertyNames) {
+    return configPropertyNames.parameters.required.every(req => req in config);
+}
+const snapshotRefreshOptions = {
+    overrides: {
+        headers: {
+            'Cache-Control': 'no-cache',
+        },
+    }
+};
+const keyPrefix = 'clm';
+
+const { freeze: ObjectFreeze, keys: ObjectKeys, create: ObjectCreate, assign: ObjectAssign } = Object;
+const { isArray: ArrayIsArray } = Array;
+const { stringify: JSONStringify } = JSON;
+function equalsArray(a, b, equalsItem) {
+    const aLength = a.length;
+    const bLength = b.length;
+    if (aLength !== bLength) {
+        return false;
+    }
+    for (let i = 0; i < aLength; i++) {
+        if (equalsItem(a[i], b[i]) === false) {
+            return false;
+        }
+    }
+    return true;
+}
+function deepFreeze$b(value) {
+    // No need to freeze primitives
+    if (typeof value !== 'object' || value === null) {
+        return;
+    }
+    if (ArrayIsArray(value)) {
+        for (let i = 0, len = value.length; i < len; i += 1) {
+            deepFreeze$b(value[i]);
+        }
+    }
+    else {
+        const keys = ObjectKeys(value);
+        for (let i = 0, len = keys.length; i < len; i += 1) {
+            deepFreeze$b(value[keys[i]]);
+        }
+    }
+    ObjectFreeze(value);
+}
+function createLink(ref) {
+    return {
+        __ref: serializeStructuredKey(ref),
+    };
+}
+
+const TTL$6 = 60000;
+const VERSION$8 = "c8652b5c3ad8c532087704340d3cad55";
+function validate$e(obj, path = 'GenericOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_id = obj.id;
+        const path_id = path + '.id';
+        if (typeof obj_id !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_id + '" (at "' + path_id + '")');
+        }
+        if (obj.isSuccess !== undefined) {
+            const obj_isSuccess = obj.isSuccess;
+            const path_isSuccess = path + '.isSuccess';
+            if (typeof obj_isSuccess !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isSuccess + '" (at "' + path_isSuccess + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$7 = 'GenericOutputRepresentation';
+function keyBuilder$f(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$7 + ':' + config.id;
+}
+function keyBuilderFromType$4(luvio, object) {
+    const keyParams = {
+        id: object.id
+    };
+    return keyBuilder$f(luvio, keyParams);
+}
+function normalize$7(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$l = function GenericOutputRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$8,
+        private: [],
+        opaque: true
+    };
+};
+function equals$8(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
+function deepFreeze$a(input) {
+    ObjectFreeze(input);
+}
+const ingest$7 = function GenericOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$e(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$4(luvio, input);
+    const existingRecord = store.readEntry(key);
+    const ttlToUse = TTL$6;
+    let incomingRecord = normalize$7(input, store.readEntry(key), {
+        fullPath: key,
+        parent: path.parent,
+        propertyName: path.propertyName,
+        ttl: ttlToUse
+    });
+    deepFreeze$a(input);
+    if (existingRecord === undefined || equals$8(existingRecord, incomingRecord) === false) {
+        luvio.storePublish(key, incomingRecord);
+    }
+    {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "clm",
+            version: VERSION$8,
+            representationName: RepresentationType$7,
+        };
+        luvio.publishStoreMetadata(key, storeMetadataParams);
+    }
+    return createLink(key);
+};
+function getTypeCacheKeys$7(luvio, input, fullPathFactory) {
+    const rootKeySet = new StoreKeyMap();
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$4(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$7,
+        mergeable: false
+    });
+    return rootKeySet;
+}
+
+function select$k(luvio, params) {
+    return select$l();
+}
+function getResponseCacheKeys$d(luvio, resourceParams, response) {
+    return getTypeCacheKeys$7(luvio, response);
+}
+function ingestSuccess$c(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$4(luvio, body);
+    luvio.storeIngest(key, ingest$7, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$k(),
+        variables: {},
+    });
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    return snapshot;
+}
+function createResourceRequest$d(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/clm/contract-document-version/' + config.urlParams.contractDocumentVersionId + '/checkIn',
+        method: 'patch',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const checkIn_ConfigPropertyNames = {
+    displayName: 'checkIn',
+    parameters: {
+        required: ['contractDocumentVersionId'],
+        optional: []
+    }
+};
+function createResourceParams$d(config) {
+    const resourceParams = {
+        urlParams: {
+            contractDocumentVersionId: config.contractDocumentVersionId
+        }
+    };
+    return resourceParams;
+}
+function typeCheckConfig$d(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contractDocumentVersionId = untrustedConfig.contractDocumentVersionId;
+    if (typeof untrustedConfig_contractDocumentVersionId === 'string') {
+        config.contractDocumentVersionId = untrustedConfig_contractDocumentVersionId;
+    }
+    return config;
+}
+function validateAdapterConfig$d(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$d(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);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$c(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => getResponseCacheKeys$d(luvio, resourceParams, response.body));
+    }, (response) => {
+        deepFreeze$b(response);
+        throw response;
+    });
+}
+const checkInAdapterFactory = (luvio) => {
+    return function checkIn(untrustedConfig) {
+        const config = validateAdapterConfig$d(untrustedConfig, checkIn_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "checkIn"');
+        }
+        return buildNetworkSnapshot$d(luvio, config);
+    };
+};
+
+function validate$d(obj, path = 'TemplateInputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.pdfDocumentId !== undefined) {
+            const obj_pdfDocumentId = obj.pdfDocumentId;
+            const path_pdfDocumentId = path + '.pdfDocumentId';
+            if (typeof obj_pdfDocumentId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_pdfDocumentId + '" (at "' + path_pdfDocumentId + '")');
+            }
+        }
+        const obj_templateId = obj.templateId;
+        const path_templateId = path + '.templateId';
+        if (typeof obj_templateId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_templateId + '" (at "' + path_templateId + '")');
+        }
+        if (obj.wordDocumentId !== undefined) {
+            const obj_wordDocumentId = obj.wordDocumentId;
+            const path_wordDocumentId = path + '.wordDocumentId';
+            if (typeof obj_wordDocumentId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_wordDocumentId + '" (at "' + path_wordDocumentId + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+const VERSION$7 = "f874339705636326163a82467da64b36";
+function validate$c(obj, path = 'ContentDocumentRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_contentDocumentId = obj.contentDocumentId;
+        const path_contentDocumentId = path + '.contentDocumentId';
+        if (typeof obj_contentDocumentId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contentDocumentId + '" (at "' + path_contentDocumentId + '")');
+        }
+        if (obj.contentDocumentLinkId !== undefined) {
+            const obj_contentDocumentLinkId = obj.contentDocumentLinkId;
+            const path_contentDocumentLinkId = path + '.contentDocumentLinkId';
+            if (typeof obj_contentDocumentLinkId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_contentDocumentLinkId + '" (at "' + path_contentDocumentLinkId + '")');
+            }
+        }
+        const obj_contractDocumentVersionId = obj.contractDocumentVersionId;
+        const path_contractDocumentVersionId = path + '.contractDocumentVersionId';
+        if (typeof obj_contractDocumentVersionId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contractDocumentVersionId + '" (at "' + path_contractDocumentVersionId + '")');
+        }
+        const obj_createdDate = obj.createdDate;
+        const path_createdDate = path + '.createdDate';
+        if (typeof obj_createdDate !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_createdDate + '" (at "' + path_createdDate + '")');
+        }
+        if (obj.fileExtension !== undefined) {
+            const obj_fileExtension = obj.fileExtension;
+            const path_fileExtension = path + '.fileExtension';
+            if (typeof obj_fileExtension !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_fileExtension + '" (at "' + path_fileExtension + '")');
+            }
+        }
+        const obj_lastModifiedDate = obj.lastModifiedDate;
+        const path_lastModifiedDate = path + '.lastModifiedDate';
+        if (typeof obj_lastModifiedDate !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_lastModifiedDate + '" (at "' + path_lastModifiedDate + '")');
+        }
+        const obj_title = obj.title;
+        const path_title = path + '.title';
+        if (typeof obj_title !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_title + '" (at "' + path_title + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$j = function ContentDocumentRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$7,
+        private: [],
+        selections: [
+            {
+                name: 'contentDocumentId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'contentDocumentLinkId',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'contractDocumentVersionId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'createdDate',
+                kind: 'Scalar'
+            },
+            {
+                name: 'fileExtension',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'lastModifiedDate',
+                kind: 'Scalar'
+            },
+            {
+                name: 'title',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$7(existing, incoming) {
+    const existing_contentDocumentId = existing.contentDocumentId;
+    const incoming_contentDocumentId = incoming.contentDocumentId;
+    if (!(existing_contentDocumentId === incoming_contentDocumentId)) {
+        return false;
+    }
+    const existing_contentDocumentLinkId = existing.contentDocumentLinkId;
+    const incoming_contentDocumentLinkId = incoming.contentDocumentLinkId;
+    // if at least one of these optionals is defined
+    if (existing_contentDocumentLinkId !== undefined || incoming_contentDocumentLinkId !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_contentDocumentLinkId === undefined || incoming_contentDocumentLinkId === undefined) {
+            return false;
+        }
+        if (!(existing_contentDocumentLinkId === incoming_contentDocumentLinkId)) {
+            return false;
+        }
+    }
+    const existing_contractDocumentVersionId = existing.contractDocumentVersionId;
+    const incoming_contractDocumentVersionId = incoming.contractDocumentVersionId;
+    if (!(existing_contractDocumentVersionId === incoming_contractDocumentVersionId)) {
+        return false;
+    }
+    const existing_createdDate = existing.createdDate;
+    const incoming_createdDate = incoming.createdDate;
+    if (!(existing_createdDate === incoming_createdDate)) {
+        return false;
+    }
+    const existing_fileExtension = existing.fileExtension;
+    const incoming_fileExtension = incoming.fileExtension;
+    // if at least one of these optionals is defined
+    if (existing_fileExtension !== undefined || incoming_fileExtension !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_fileExtension === undefined || incoming_fileExtension === undefined) {
+            return false;
+        }
+        if (!(existing_fileExtension === incoming_fileExtension)) {
+            return false;
+        }
+    }
+    const existing_lastModifiedDate = existing.lastModifiedDate;
+    const incoming_lastModifiedDate = incoming.lastModifiedDate;
+    if (!(existing_lastModifiedDate === incoming_lastModifiedDate)) {
+        return false;
+    }
+    const existing_title = existing.title;
+    const incoming_title = incoming.title;
+    if (!(existing_title === incoming_title)) {
+        return false;
+    }
+    return true;
+}
+function deepFreeze$9(input) {
+    ObjectFreeze(input);
+}
+
+const TTL$5 = 60000;
+const VERSION$6 = "520b4f1213b0e08b197d18564d0a2432";
+function validate$b(obj, path = 'DocumentGenerateRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.contentDocuments !== undefined) {
+            const obj_contentDocuments = obj.contentDocuments;
+            const path_contentDocuments = path + '.contentDocuments';
+            if (!ArrayIsArray(obj_contentDocuments)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_contentDocuments + '" (at "' + path_contentDocuments + '")');
+            }
+            for (let i = 0; i < obj_contentDocuments.length; i++) {
+                const obj_contentDocuments_item = obj_contentDocuments[i];
+                const path_contentDocuments_item = path_contentDocuments + '[' + i + ']';
+                const referencepath_contentDocuments_itemValidationError = validate$c(obj_contentDocuments_item, path_contentDocuments_item);
+                if (referencepath_contentDocuments_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match ContentDocumentRepresentation (at "' + path_contentDocuments_item + '")\n';
+                    message += referencepath_contentDocuments_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+        const obj_contractDocumentVersionId = obj.contractDocumentVersionId;
+        const path_contractDocumentVersionId = path + '.contractDocumentVersionId';
+        if (typeof obj_contractDocumentVersionId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contractDocumentVersionId + '" (at "' + path_contractDocumentVersionId + '")');
+        }
+        const obj_contractId = obj.contractId;
+        const path_contractId = path + '.contractId';
+        if (typeof obj_contractId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contractId + '" (at "' + path_contractId + '")');
+        }
+        if (obj.jobId !== undefined) {
+            const obj_jobId = obj.jobId;
+            const path_jobId = path + '.jobId';
+            if (typeof obj_jobId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_jobId + '" (at "' + path_jobId + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$6 = 'DocumentGenerateRepresentation';
+function keyBuilder$e(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$6 + ':' + config.contractId;
+}
+function keyBuilderFromType$3(luvio, object) {
+    const keyParams = {
+        contractId: object.contractId
+    };
+    return keyBuilder$e(luvio, keyParams);
+}
+function normalize$6(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$i = function DocumentGenerateRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$6,
+        private: [],
+        opaque: true
+    };
+};
+function equals$6(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
+function deepFreeze$8(input) {
+    const input_contentDocuments = input.contentDocuments;
+    if (input_contentDocuments !== undefined) {
+        for (let i = 0; i < input_contentDocuments.length; i++) {
+            const input_contentDocuments_item = input_contentDocuments[i];
+            deepFreeze$9(input_contentDocuments_item);
+        }
+        ObjectFreeze(input_contentDocuments);
+    }
+    ObjectFreeze(input);
+}
+const ingest$6 = function DocumentGenerateRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$b(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$3(luvio, input);
+    const existingRecord = store.readEntry(key);
+    const ttlToUse = TTL$5;
+    let incomingRecord = normalize$6(input, store.readEntry(key), {
+        fullPath: key,
+        parent: path.parent,
+        propertyName: path.propertyName,
+        ttl: ttlToUse
+    });
+    deepFreeze$8(input);
+    if (existingRecord === undefined || equals$6(existingRecord, incomingRecord) === false) {
+        luvio.storePublish(key, incomingRecord);
+    }
+    {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "clm",
+            version: VERSION$6,
+            representationName: RepresentationType$6,
+        };
+        luvio.publishStoreMetadata(key, storeMetadataParams);
+    }
+    return createLink(key);
+};
+function getTypeCacheKeys$6(luvio, input, fullPathFactory) {
+    const rootKeySet = new StoreKeyMap();
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$3(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$6,
+        mergeable: false
+    });
+    return rootKeySet;
+}
+
+function select$h(luvio, params) {
+    return select$i();
+}
+function getResponseCacheKeys$c(luvio, resourceParams, response) {
+    return getTypeCacheKeys$6(luvio, response);
+}
+function ingestSuccess$b(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$3(luvio, body);
+    luvio.storeIngest(key, ingest$6, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$h(),
+        variables: {},
+    });
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    return snapshot;
+}
+function createResourceRequest$c(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/clm/contract-document-version/' + config.urlParams.contractDocumentVersionId + '/checkout',
+        method: 'post',
+        body: config.body,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const checkoutContractDocumentVersion_ConfigPropertyNames = {
+    displayName: 'checkoutContractDocumentVersion',
+    parameters: {
+        required: ['contractDocumentVersionId', 'templateInput'],
+        optional: []
+    }
+};
+function createResourceParams$c(config) {
+    const resourceParams = {
+        urlParams: {
+            contractDocumentVersionId: config.contractDocumentVersionId
+        },
+        body: {
+            templateInput: config.templateInput
+        }
+    };
+    return resourceParams;
+}
+function typeCheckConfig$c(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contractDocumentVersionId = untrustedConfig.contractDocumentVersionId;
+    if (typeof untrustedConfig_contractDocumentVersionId === 'string') {
+        config.contractDocumentVersionId = untrustedConfig_contractDocumentVersionId;
+    }
+    const untrustedConfig_templateInput = untrustedConfig.templateInput;
+    const referenceTemplateInputRepresentationValidationError = validate$d(untrustedConfig_templateInput);
+    if (referenceTemplateInputRepresentationValidationError === null) {
+        config.templateInput = untrustedConfig_templateInput;
+    }
+    return config;
+}
+function validateAdapterConfig$c(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$c(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);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$b(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => getResponseCacheKeys$c(luvio, resourceParams, response.body));
+    }, (response) => {
+        deepFreeze$b(response);
+        throw response;
+    });
+}
+const checkoutContractDocumentVersionAdapterFactory = (luvio) => {
+    return function checkoutContractDocumentVersion(untrustedConfig) {
+        const config = validateAdapterConfig$c(untrustedConfig, checkoutContractDocumentVersion_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "checkoutContractDocumentVersion"');
+        }
+        return buildNetworkSnapshot$c(luvio, config);
+    };
+};
+
+function select$g(luvio, params) {
+    return select$i();
+}
+function getResponseCacheKeys$b(luvio, resourceParams, response) {
+    return getTypeCacheKeys$6(luvio, response);
+}
+function ingestSuccess$a(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$3(luvio, body);
+    luvio.storeIngest(key, ingest$6, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$g(),
+        variables: {},
+    });
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    return snapshot;
+}
+function createResourceRequest$b(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/clm/contract/' + config.urlParams.contractId + '/contract-document-version',
+        method: 'post',
+        body: config.body,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const createContractDocumentVersionAndInitializeGenerateDocumentProcess_ConfigPropertyNames = {
+    displayName: 'createContractDocumentVersionAndInitializeGenerateDocumentProcess',
+    parameters: {
+        required: ['contractId', 'templateInput'],
+        optional: []
+    }
+};
+function createResourceParams$b(config) {
+    const resourceParams = {
+        urlParams: {
+            contractId: config.contractId
+        },
+        body: {
+            templateInput: config.templateInput
+        }
+    };
+    return resourceParams;
+}
+function typeCheckConfig$b(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contractId = untrustedConfig.contractId;
+    if (typeof untrustedConfig_contractId === 'string') {
+        config.contractId = untrustedConfig_contractId;
+    }
+    const untrustedConfig_templateInput = untrustedConfig.templateInput;
+    const referenceTemplateInputRepresentationValidationError = validate$d(untrustedConfig_templateInput);
+    if (referenceTemplateInputRepresentationValidationError === null) {
+        config.templateInput = untrustedConfig_templateInput;
+    }
+    return config;
+}
+function validateAdapterConfig$b(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$b(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);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$a(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => getResponseCacheKeys$b(luvio, resourceParams, response.body));
+    }, (response) => {
+        deepFreeze$b(response);
+        throw response;
+    });
+}
+const createContractDocumentVersionAndInitializeGenerateDocumentProcessAdapterFactory = (luvio) => {
+    return function createContractDocumentVersionAndInitializeGenerateDocumentProcess(untrustedConfig) {
+        const config = validateAdapterConfig$b(untrustedConfig, createContractDocumentVersionAndInitializeGenerateDocumentProcess_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "createContractDocumentVersionAndInitializeGenerateDocumentProcess"');
+        }
+        return buildNetworkSnapshot$b(luvio, config);
+    };
+};
+
+const TTL$4 = 60000;
+const VERSION$5 = "dce4365dead9ca97204892d274fbf1b7";
+function validate$a(obj, path = 'ContentDocumentListRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_contractDocumentVersionId = obj.contractDocumentVersionId;
+        const path_contractDocumentVersionId = path + '.contractDocumentVersionId';
+        if (typeof obj_contractDocumentVersionId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contractDocumentVersionId + '" (at "' + path_contractDocumentVersionId + '")');
+        }
+        if (obj.data !== undefined) {
+            const obj_data = obj.data;
+            const path_data = path + '.data';
+            if (!ArrayIsArray(obj_data)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_data + '" (at "' + path_data + '")');
+            }
+            for (let i = 0; i < obj_data.length; i++) {
+                const obj_data_item = obj_data[i];
+                const path_data_item = path_data + '[' + i + ']';
+                const referencepath_data_itemValidationError = validate$c(obj_data_item, path_data_item);
+                if (referencepath_data_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match ContentDocumentRepresentation (at "' + path_data_item + '")\n';
+                    message += referencepath_data_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$5 = 'ContentDocumentListRepresentation';
+function keyBuilder$d(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$5 + ':' + config.contractDocumentVersionId;
+}
+function keyBuilderFromType$2(luvio, object) {
+    const keyParams = {
+        contractDocumentVersionId: object.contractDocumentVersionId
+    };
+    return keyBuilder$d(luvio, keyParams);
+}
+function normalize$5(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$f = function ContentDocumentListRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$5,
+        private: [],
+        opaque: true
+    };
+};
+function equals$5(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
+function deepFreeze$7(input) {
+    const input_data = input.data;
+    if (input_data !== undefined) {
+        for (let i = 0; i < input_data.length; i++) {
+            const input_data_item = input_data[i];
+            deepFreeze$9(input_data_item);
+        }
+        ObjectFreeze(input_data);
+    }
+    ObjectFreeze(input);
+}
+const ingest$5 = function ContentDocumentListRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$a(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$2(luvio, input);
+    const existingRecord = store.readEntry(key);
+    const ttlToUse = TTL$4;
+    let incomingRecord = normalize$5(input, store.readEntry(key), {
+        fullPath: key,
+        parent: path.parent,
+        propertyName: path.propertyName,
+        ttl: ttlToUse
+    });
+    deepFreeze$7(input);
+    if (existingRecord === undefined || equals$5(existingRecord, incomingRecord) === false) {
+        luvio.storePublish(key, incomingRecord);
+    }
+    {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "clm",
+            version: VERSION$5,
+            representationName: RepresentationType$5,
+        };
+        luvio.publishStoreMetadata(key, storeMetadataParams);
+    }
+    return createLink(key);
+};
+function getTypeCacheKeys$5(luvio, input, fullPathFactory) {
+    const rootKeySet = new StoreKeyMap();
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$2(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$5,
+        mergeable: false
+    });
+    return rootKeySet;
+}
+
+function keyBuilder$c(luvio, params) {
+    return keyBuilder$d(luvio, {
+        contractDocumentVersionId: params.urlParams.contractDocumentVersionId
+    });
+}
+function getResponseCacheKeys$a(luvio, resourceParams) {
+    const key = keyBuilder$c(luvio, resourceParams);
+    const cacheKeyMap = new StoreKeyMap();
+    cacheKeyMap.set(key, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$5,
+        mergeable: false
+    });
+    return cacheKeyMap;
+}
+function evictSuccess(luvio, resourceParams) {
+    const key = keyBuilder$c(luvio, resourceParams);
+    luvio.storeEvict(key);
+}
+function createResourceRequest$a(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/clm/contract-document-version/' + config.urlParams.contractDocumentVersionId + '/content-documents',
+        method: 'delete',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: config.queryParams,
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName = 'deleteAttachment';
+const deleteAttachment_ConfigPropertyNames = {
+    displayName: 'deleteAttachment',
+    parameters: {
+        required: ['contractDocumentVersionId'],
+        optional: ['contentDocumentId']
+    }
+};
+function createResourceParams$a(config) {
+    const resourceParams = {
+        urlParams: {
+            contractDocumentVersionId: config.contractDocumentVersionId
+        },
+        queryParams: {
+            contentDocumentId: config.contentDocumentId
+        }
+    };
+    return resourceParams;
+}
+function typeCheckConfig$a(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contractDocumentVersionId = untrustedConfig.contractDocumentVersionId;
+    if (typeof untrustedConfig_contractDocumentVersionId === 'string') {
+        config.contractDocumentVersionId = untrustedConfig_contractDocumentVersionId;
+    }
+    const untrustedConfig_contentDocumentId = untrustedConfig.contentDocumentId;
+    if (typeof untrustedConfig_contentDocumentId === 'string') {
+        config.contentDocumentId = untrustedConfig_contentDocumentId;
+    }
+    return config;
+}
+function validateAdapterConfig$a(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$a(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$a(luvio, config, options) {
+    const resourceParams = createResourceParams$a(config);
+    const request = createResourceRequest$a(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then(() => {
+        return luvio.handleSuccessResponse(() => {
+            evictSuccess(luvio, resourceParams);
+            return luvio.storeBroadcast();
+        }, () => getResponseCacheKeys$a(luvio, resourceParams));
+    }, (response) => {
+        deepFreeze$b(response);
+        throw response;
+    });
+}
+const deleteAttachmentAdapterFactory = (luvio) => {
+    return function clmdeleteAttachment(untrustedConfig) {
+        const config = validateAdapterConfig$a(untrustedConfig, deleteAttachment_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error(`Invalid config for "${adapterName}"`);
+        }
+        return buildNetworkSnapshot$a(luvio, config);
+    };
+};
+
+function validate$9(obj, path = 'ContractActionInputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.actionApiName !== undefined) {
+            const obj_actionApiName = obj.actionApiName;
+            const path_actionApiName = path + '.actionApiName';
+            if (typeof obj_actionApiName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_actionApiName + '" (at "' + path_actionApiName + '")');
+            }
+        }
+        if (obj.actionData !== undefined) {
+            const obj_actionData = obj.actionData;
+            const path_actionData = path + '.actionData';
+            if (typeof obj_actionData !== 'object' || ArrayIsArray(obj_actionData) || obj_actionData === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj_actionData + '" (at "' + path_actionData + '")');
+            }
+            const obj_actionData_keys = ObjectKeys(obj_actionData);
+            for (let i = 0; i < obj_actionData_keys.length; i++) {
+                const key = obj_actionData_keys[i];
+                const obj_actionData_prop = obj_actionData[key];
+                const path_actionData_prop = path_actionData + '["' + key + '"]';
+                if (typeof obj_actionData_prop !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_actionData_prop + '" (at "' + path_actionData_prop + '")');
+                }
+            }
+        }
+        if (obj.actionId !== undefined) {
+            const obj_actionId = obj.actionId;
+            const path_actionId = path + '.actionId';
+            if (typeof obj_actionId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_actionId + '" (at "' + path_actionId + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function select$e(luvio, params) {
+    return select$l();
+}
+function getResponseCacheKeys$9(luvio, resourceParams, response) {
+    return getTypeCacheKeys$7(luvio, response);
+}
+function ingestSuccess$9(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$4(luvio, body);
+    luvio.storeIngest(key, ingest$7, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$e(),
+        variables: {},
+    });
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    return snapshot;
+}
+function createResourceRequest$9(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/clm/contract/' + config.urlParams.contractId + '',
+        method: 'patch',
+        body: config.body,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const executeContractAction_ConfigPropertyNames = {
+    displayName: 'executeContractAction',
+    parameters: {
+        required: ['contractId', 'actionInput'],
+        optional: []
+    }
+};
+function createResourceParams$9(config) {
+    const resourceParams = {
+        urlParams: {
+            contractId: config.contractId
+        },
+        body: {
+            actionInput: config.actionInput
+        }
+    };
+    return resourceParams;
+}
+function typeCheckConfig$9(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contractId = untrustedConfig.contractId;
+    if (typeof untrustedConfig_contractId === 'string') {
+        config.contractId = untrustedConfig_contractId;
+    }
+    const untrustedConfig_actionInput = untrustedConfig.actionInput;
+    const referenceContractActionInputRepresentationValidationError = validate$9(untrustedConfig_actionInput);
+    if (referenceContractActionInputRepresentationValidationError === null) {
+        config.actionInput = untrustedConfig_actionInput;
+    }
+    return config;
+}
+function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$9(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+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$9(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => getResponseCacheKeys$9(luvio, resourceParams, response.body));
+    }, (response) => {
+        deepFreeze$b(response);
+        throw response;
+    });
+}
+const executeContractActionAdapterFactory = (luvio) => {
+    return function executeContractAction(untrustedConfig) {
+        const config = validateAdapterConfig$9(untrustedConfig, executeContractAction_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "executeContractAction"');
+        }
+        return buildNetworkSnapshot$9(luvio, config);
+    };
+};
+
+function select$d(luvio, params) {
+    return select$f();
+}
+function keyBuilder$b(luvio, params) {
+    return keyBuilder$d(luvio, {
+        contractDocumentVersionId: params.urlParams.contractDocumentVersionId
+    });
+}
+function getResponseCacheKeys$8(luvio, resourceParams, response) {
+    return getTypeCacheKeys$5(luvio, response);
+}
+function ingestSuccess$8(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$b(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$5, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$d(),
+        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');
+        }
+    }
+    return snapshot;
+}
+function ingestError$4(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$b(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    const storeMetadataParams = {
+        ttl: TTL$4,
+        namespace: keyPrefix,
+        version: VERSION$5,
+        representationName: RepresentationType$5
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
+function createResourceRequest$8(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/clm/contract-document-version/' + config.urlParams.contractDocumentVersionId + '/content-documents',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+function createResourceRequestFromRepresentation$1(representation) {
+    const config = {
+        urlParams: {},
+    };
+    config.urlParams.contractDocumentVersionId = representation.contractDocumentVersionId;
+    return createResourceRequest$8(config);
+}
+
+const getContentDocument_ConfigPropertyNames = {
+    displayName: 'getContentDocument',
+    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$4(luvio, config) {
+    createResourceParams$8(config);
+    return select$d();
+}
+function onFetchResponseSuccess$4(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$8(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError$4(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$4(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$4(luvio, config, resourceParams, response), () => getResponseCacheKeys$8(luvio, resourceParams, response.body));
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$4(luvio, config, resourceParams, response));
+    });
+}
+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);
+}
+function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$a(luvio, config),
+        node: adapterFragment$4(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getContentDocumentAdapterFactory = (luvio) => function clm__getContentDocument(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$8(untrustedConfig, getContentDocument_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$4, buildNetworkSnapshotCachePolicy$4);
+};
+const notifyChangeFactory$1 = (luvio, options) => {
+    return function getConnectClmContractDocumentVersionContentDocumentsByContractDocumentVersionIdNotifyChange(configs) {
+        const keys = configs.map(c => keyBuilder$d(luvio, c));
+        luvio.getNotifyChangeStoreEntries(keys).then(entries => {
+            for (let i = 0, len = entries.length; i < len; i++) {
+                const { key, record: val } = entries[i];
+                const refreshRequest = createResourceRequestFromRepresentation$1(val);
+                luvio.dispatchResourceRequest(refreshRequest, options)
+                    .then((response) => {
+                    return luvio.handleSuccessResponse(() => {
+                        const { body } = response;
+                        luvio.storeIngest(key, ingest$5, body);
+                        return luvio.storeBroadcast();
+                    }, () => getTypeCacheKeys$5(luvio, response.body));
+                }, (error) => {
+                    return luvio.handleErrorResponse(() => {
+                        const errorSnapshot = luvio.errorSnapshot(error);
+                        luvio.storeIngestError(key, errorSnapshot, {
+                            ttl: TTL$4,
+                            namespace: keyPrefix,
+                            version: VERSION$5,
+                            representationName: RepresentationType$5
+                        });
+                        return luvio.storeBroadcast().then(() => errorSnapshot);
+                    });
+                });
+            }
+        });
+    };
+};
+
+function validate$8(obj, path = 'ContractActionRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_actionId = obj.actionId;
+        const path_actionId = path + '.actionId';
+        if (typeof obj_actionId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_actionId + '" (at "' + path_actionId + '")');
+        }
+        if (obj.actionType !== undefined) {
+            const obj_actionType = obj.actionType;
+            const path_actionType = path + '.actionType';
+            if (typeof obj_actionType !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_actionType + '" (at "' + path_actionType + '")');
+            }
+        }
+        const obj_apiName = obj.apiName;
+        const path_apiName = path + '.apiName';
+        if (typeof obj_apiName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_apiName + '" (at "' + path_apiName + '")');
+        }
+        if (obj.invocableClassName !== undefined) {
+            const obj_invocableClassName = obj.invocableClassName;
+            const path_invocableClassName = path + '.invocableClassName';
+            if (typeof obj_invocableClassName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_invocableClassName + '" (at "' + path_invocableClassName + '")');
+            }
+        }
+        if (obj.invocableMethodName !== undefined) {
+            const obj_invocableMethodName = obj.invocableMethodName;
+            const path_invocableMethodName = path + '.invocableMethodName';
+            if (typeof obj_invocableMethodName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_invocableMethodName + '" (at "' + path_invocableMethodName + '")');
+            }
+        }
+        if (obj.referenceObject !== undefined) {
+            const obj_referenceObject = obj.referenceObject;
+            const path_referenceObject = path + '.referenceObject';
+            if (typeof obj_referenceObject !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_referenceObject + '" (at "' + path_referenceObject + '")');
+            }
+        }
+        if (obj.referenceObjectId !== undefined) {
+            const obj_referenceObjectId = obj.referenceObjectId;
+            const path_referenceObjectId = path + '.referenceObjectId';
+            if (typeof obj_referenceObjectId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_referenceObjectId + '" (at "' + path_referenceObjectId + '")');
+            }
+        }
+        const obj_uiText = obj.uiText;
+        const path_uiText = path + '.uiText';
+        if (typeof obj_uiText !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_uiText + '" (at "' + path_uiText + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+function deepFreeze$6(input) {
+    ObjectFreeze(input);
+}
+
+const TTL$3 = 60000;
+const VERSION$4 = "2caf5349dc6c6aa44ef471df00f65bbd";
+function validate$7(obj, path = 'ContractActionListRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_actions = obj.actions;
+        const path_actions = path + '.actions';
+        if (!ArrayIsArray(obj_actions)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_actions + '" (at "' + path_actions + '")');
+        }
+        for (let i = 0; i < obj_actions.length; i++) {
+            const obj_actions_item = obj_actions[i];
+            const path_actions_item = path_actions + '[' + i + ']';
+            const referencepath_actions_itemValidationError = validate$8(obj_actions_item, path_actions_item);
+            if (referencepath_actions_itemValidationError !== null) {
+                let message = 'Object doesn\'t match ContractActionRepresentation (at "' + path_actions_item + '")\n';
+                message += referencepath_actions_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_contractId = obj.contractId;
+        const path_contractId = path + '.contractId';
+        if (typeof obj_contractId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contractId + '" (at "' + path_contractId + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$4 = 'ContractActionListRepresentation';
+function keyBuilder$9(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$4 + ':' + config.contractId;
+}
+function keyBuilderFromType$1(luvio, object) {
+    const keyParams = {
+        contractId: object.contractId
+    };
+    return keyBuilder$9(luvio, keyParams);
+}
+function normalize$4(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$c = function ContractActionListRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$4,
+        private: [],
+        opaque: true
+    };
+};
+function equals$4(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
+function deepFreeze$5(input) {
+    const input_actions = input.actions;
+    for (let i = 0; i < input_actions.length; i++) {
+        const input_actions_item = input_actions[i];
+        deepFreeze$6(input_actions_item);
+    }
+    ObjectFreeze(input_actions);
+    ObjectFreeze(input);
+}
+const ingest$4 = function ContractActionListRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$7(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$1(luvio, input);
+    const existingRecord = store.readEntry(key);
+    const ttlToUse = TTL$3;
+    let incomingRecord = normalize$4(input, store.readEntry(key), {
+        fullPath: key,
+        parent: path.parent,
+        propertyName: path.propertyName,
+        ttl: ttlToUse
+    });
+    deepFreeze$5(input);
+    if (existingRecord === undefined || equals$4(existingRecord, incomingRecord) === false) {
+        luvio.storePublish(key, incomingRecord);
+    }
+    {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "clm",
+            version: VERSION$4,
+            representationName: RepresentationType$4,
+        };
+        luvio.publishStoreMetadata(key, storeMetadataParams);
+    }
+    return createLink(key);
+};
+function getTypeCacheKeys$4(luvio, input, fullPathFactory) {
+    const rootKeySet = new StoreKeyMap();
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$1(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$4,
+        mergeable: false
+    });
+    return rootKeySet;
+}
+
+function select$b(luvio, params) {
+    return select$c();
+}
+function keyBuilder$8(luvio, params) {
+    return keyBuilder$9(luvio, {
+        contractId: params.urlParams.contractId
+    });
+}
+function getResponseCacheKeys$7(luvio, resourceParams, response) {
+    return getTypeCacheKeys$4(luvio, response);
+}
+function ingestSuccess$7(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$8(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$4, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$b(),
+        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');
+        }
+    }
+    return snapshot;
+}
+function ingestError$3(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$8(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    const storeMetadataParams = {
+        ttl: TTL$3,
+        namespace: keyPrefix,
+        version: VERSION$4,
+        representationName: RepresentationType$4
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
+function createResourceRequest$7(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/clm/contract/' + config.urlParams.contractId + '/contract-actions',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+function createResourceRequestFromRepresentation(representation) {
+    const config = {
+        urlParams: {},
+    };
+    config.urlParams.contractId = representation.contractId;
+    return createResourceRequest$7(config);
+}
+
+const getContractActions_ConfigPropertyNames = {
+    displayName: 'getContractActions',
+    parameters: {
+        required: ['contractId'],
+        optional: []
+    }
+};
+function createResourceParams$7(config) {
+    const resourceParams = {
+        urlParams: {
+            contractId: config.contractId
+        }
+    };
+    return resourceParams;
+}
+function keyBuilder$7(luvio, config) {
+    const resourceParams = createResourceParams$7(config);
+    return keyBuilder$8(luvio, resourceParams);
+}
+function typeCheckConfig$7(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contractId = untrustedConfig.contractId;
+    if (typeof untrustedConfig_contractId === 'string') {
+        config.contractId = untrustedConfig_contractId;
+    }
+    return config;
+}
+function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$7(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment$3(luvio, config) {
+    createResourceParams$7(config);
+    return select$b();
+}
+function onFetchResponseSuccess$3(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$7(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$7(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$7(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$7(luvio, config, options) {
+    const resourceParams = createResourceParams$7(config);
+    const request = createResourceRequest$7(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$3(luvio, config, resourceParams, response), () => getResponseCacheKeys$7(luvio, resourceParams, response.body));
+    }, (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$7(luvio, config, dispatchOptions);
+}
+function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$7(luvio, config),
+        node: adapterFragment$3(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getContractActionsAdapterFactory = (luvio) => function clm__getContractActions(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$7(untrustedConfig, getContractActions_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$3, buildNetworkSnapshotCachePolicy$3);
+};
+const notifyChangeFactory = (luvio, options) => {
+    return function getConnectClmContractContractActionsByContractIdNotifyChange(configs) {
+        const keys = configs.map(c => keyBuilder$9(luvio, c));
+        luvio.getNotifyChangeStoreEntries(keys).then(entries => {
+            for (let i = 0, len = entries.length; i < len; i++) {
+                const { key, record: val } = entries[i];
+                const refreshRequest = createResourceRequestFromRepresentation(val);
+                luvio.dispatchResourceRequest(refreshRequest, options)
+                    .then((response) => {
+                    return luvio.handleSuccessResponse(() => {
+                        const { body } = response;
+                        luvio.storeIngest(key, ingest$4, body);
+                        return luvio.storeBroadcast();
+                    }, () => getTypeCacheKeys$4(luvio, response.body));
+                }, (error) => {
+                    return luvio.handleErrorResponse(() => {
+                        const errorSnapshot = luvio.errorSnapshot(error);
+                        luvio.storeIngestError(key, errorSnapshot, {
+                            ttl: TTL$3,
+                            namespace: keyPrefix,
+                            version: VERSION$4,
+                            representationName: RepresentationType$4
+                        });
+                        return luvio.storeBroadcast().then(() => errorSnapshot);
+                    });
+                });
+            }
+        });
+    };
+};
+
+function validate$6(obj, path = 'ContractDocumentVersionRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_contractDocumentVersionId = obj.contractDocumentVersionId;
+        const path_contractDocumentVersionId = path + '.contractDocumentVersionId';
+        if (typeof obj_contractDocumentVersionId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contractDocumentVersionId + '" (at "' + path_contractDocumentVersionId + '")');
+        }
+        const obj_contractId = obj.contractId;
+        const path_contractId = path + '.contractId';
+        if (typeof obj_contractId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contractId + '" (at "' + path_contractId + '")');
+        }
+        if (obj.createdByFullName !== undefined) {
+            const obj_createdByFullName = obj.createdByFullName;
+            const path_createdByFullName = path + '.createdByFullName';
+            if (typeof obj_createdByFullName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_createdByFullName + '" (at "' + path_createdByFullName + '")');
+            }
+        }
+        const obj_createdDate = obj.createdDate;
+        const path_createdDate = path + '.createdDate';
+        if (typeof obj_createdDate !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_createdDate + '" (at "' + path_createdDate + '")');
+        }
+        if (obj.creationProcessType !== undefined) {
+            const obj_creationProcessType = obj.creationProcessType;
+            const path_creationProcessType = path + '.creationProcessType';
+            if (typeof obj_creationProcessType !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_creationProcessType + '" (at "' + path_creationProcessType + '")');
+            }
+        }
+        if (obj.documentTemplateId !== undefined) {
+            const obj_documentTemplateId = obj.documentTemplateId;
+            const path_documentTemplateId = path + '.documentTemplateId';
+            if (typeof obj_documentTemplateId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_documentTemplateId + '" (at "' + path_documentTemplateId + '")');
+            }
+        }
+        const obj_isDocumentVersionLocked = obj.isDocumentVersionLocked;
+        const path_isDocumentVersionLocked = path + '.isDocumentVersionLocked';
+        if (typeof obj_isDocumentVersionLocked !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_isDocumentVersionLocked + '" (at "' + path_isDocumentVersionLocked + '")');
+        }
+        const obj_lastModifiedDate = obj.lastModifiedDate;
+        const path_lastModifiedDate = path + '.lastModifiedDate';
+        if (typeof obj_lastModifiedDate !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_lastModifiedDate + '" (at "' + path_lastModifiedDate + '")');
+        }
+        if (obj.lockType !== undefined) {
+            const obj_lockType = obj.lockType;
+            const path_lockType = path + '.lockType';
+            if (typeof obj_lockType !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_lockType + '" (at "' + path_lockType + '")');
+            }
+        }
+        if (obj.lockedByUserName !== undefined) {
+            const obj_lockedByUserName = obj.lockedByUserName;
+            const path_lockedByUserName = path + '.lockedByUserName';
+            if (typeof obj_lockedByUserName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_lockedByUserName + '" (at "' + path_lockedByUserName + '")');
+            }
+        }
+        const obj_name = obj.name;
+        const path_name = path + '.name';
+        if (typeof obj_name !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
+        }
+        const obj_status = obj.status;
+        const path_status = path + '.status';
+        if (typeof obj_status !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_status + '" (at "' + path_status + '")');
+        }
+        const obj_versionNumber = obj.versionNumber;
+        const path_versionNumber = path + '.versionNumber';
+        if (typeof obj_versionNumber !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_versionNumber + '" (at "' + path_versionNumber + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+function deepFreeze$4(input) {
+    ObjectFreeze(input);
+}
+
+const TTL$2 = 60000;
+const VERSION$3 = "a824de2ee1cbb2f1e15ea8114da78d95";
+function validate$5(obj, path = 'ContractDocumentVersionsListRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_contractId = obj.contractId;
+        const path_contractId = path + '.contractId';
+        if (typeof obj_contractId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contractId + '" (at "' + path_contractId + '")');
+        }
+        if (obj.data !== undefined) {
+            const obj_data = obj.data;
+            const path_data = path + '.data';
+            if (!ArrayIsArray(obj_data)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_data + '" (at "' + path_data + '")');
+            }
+            for (let i = 0; i < obj_data.length; i++) {
+                const obj_data_item = obj_data[i];
+                const path_data_item = path_data + '[' + i + ']';
+                const referencepath_data_itemValidationError = validate$6(obj_data_item, path_data_item);
+                if (referencepath_data_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match ContractDocumentVersionRepresentation (at "' + path_data_item + '")\n';
+                    message += referencepath_data_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$3 = 'ContractDocumentVersionsListRepresentation';
+function normalize$3(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$a = function ContractDocumentVersionsListRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$3,
+        private: [],
+        opaque: true
+    };
+};
+function equals$3(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
+function deepFreeze$3(input) {
+    const input_data = input.data;
+    if (input_data !== undefined) {
+        for (let i = 0; i < input_data.length; i++) {
+            const input_data_item = input_data[i];
+            deepFreeze$4(input_data_item);
+        }
+        ObjectFreeze(input_data);
+    }
+    ObjectFreeze(input);
+}
+const ingest$3 = function ContractDocumentVersionsListRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$5(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = path.fullPath;
+    const existingRecord = store.readEntry(key);
+    const ttlToUse = TTL$2;
+    let incomingRecord = normalize$3(input, store.readEntry(key), {
+        fullPath: key,
+        parent: path.parent,
+        propertyName: path.propertyName,
+        ttl: ttlToUse
+    });
+    deepFreeze$3(input);
+    if (existingRecord === undefined || equals$3(existingRecord, incomingRecord) === false) {
+        luvio.storePublish(key, incomingRecord);
+    }
+    {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "clm",
+            version: VERSION$3,
+            representationName: RepresentationType$3,
+        };
+        luvio.publishStoreMetadata(key, storeMetadataParams);
+    }
+    return createLink(key);
+};
+function getTypeCacheKeys$3(luvio, input, fullPathFactory) {
+    const rootKeySet = new StoreKeyMap();
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = fullPathFactory();
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$3,
+        mergeable: false
+    });
+    return rootKeySet;
+}
+
+function select$9(luvio, params) {
+    return select$a();
+}
+function keyBuilder$6(luvio, params) {
+    return keyPrefix + '::ContractDocumentVersionsListRepresentation:(' + 'contractDocumentVersionId:' + params.queryParams.contractDocumentVersionId + ',' + 'contractId:' + params.urlParams.contractId + ')';
+}
+function getResponseCacheKeys$6(luvio, resourceParams, response) {
+    return getTypeCacheKeys$3(luvio, response, () => keyBuilder$6(luvio, resourceParams));
+}
+function ingestSuccess$6(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$6(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$3, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$9(),
+        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');
+        }
+    }
+    return snapshot;
+}
+function ingestError$2(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$6(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    const storeMetadataParams = {
+        ttl: TTL$2,
+        namespace: keyPrefix,
+        version: VERSION$3,
+        representationName: RepresentationType$3
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
+function createResourceRequest$6(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/clm/contract/' + config.urlParams.contractId + '/contract-document-version',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: config.queryParams,
+        headers,
+        priority: 'normal',
+    };
+}
+
+const getContractDocumentVersion_ConfigPropertyNames = {
+    displayName: 'getContractDocumentVersion',
+    parameters: {
+        required: ['contractId'],
+        optional: ['contractDocumentVersionId']
+    }
+};
+function createResourceParams$6(config) {
+    const resourceParams = {
+        urlParams: {
+            contractId: config.contractId
+        },
+        queryParams: {
+            contractDocumentVersionId: config.contractDocumentVersionId
+        }
+    };
+    return resourceParams;
+}
+function keyBuilder$5(luvio, config) {
+    const resourceParams = createResourceParams$6(config);
+    return keyBuilder$6(luvio, resourceParams);
+}
+function typeCheckConfig$6(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contractId = untrustedConfig.contractId;
+    if (typeof untrustedConfig_contractId === 'string') {
+        config.contractId = untrustedConfig_contractId;
+    }
+    const untrustedConfig_contractDocumentVersionId = untrustedConfig.contractDocumentVersionId;
+    if (typeof untrustedConfig_contractDocumentVersionId === 'string') {
+        config.contractDocumentVersionId = untrustedConfig_contractDocumentVersionId;
+    }
+    return config;
+}
+function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$6(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment$2(luvio, config) {
+    createResourceParams$6(config);
+    return select$9();
+}
+function onFetchResponseSuccess$2(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$6(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError$2(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$2(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$6(luvio, config, options) {
+    const resourceParams = createResourceParams$6(config);
+    const request = createResourceRequest$6(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$2(luvio, config, resourceParams, response), () => getResponseCacheKeys$6(luvio, resourceParams, response.body));
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$2(luvio, config, resourceParams, response));
+    });
+}
+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$6(luvio, config, dispatchOptions);
+}
+function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$5(luvio, config),
+        node: adapterFragment$2(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getContractDocumentVersionAdapterFactory = (luvio) => function clm__getContractDocumentVersion(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$6(untrustedConfig, getContractDocumentVersion_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$2, buildNetworkSnapshotCachePolicy$2);
+};
+
+const VERSION$2 = "108316884026f0999c72cbecfb179629";
+function validate$4(obj, path = 'DocumentGenerationProcessStatusRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.contentDocuments !== undefined) {
+            const obj_contentDocuments = obj.contentDocuments;
+            const path_contentDocuments = path + '.contentDocuments';
+            if (!ArrayIsArray(obj_contentDocuments)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_contentDocuments + '" (at "' + path_contentDocuments + '")');
+            }
+            for (let i = 0; i < obj_contentDocuments.length; i++) {
+                const obj_contentDocuments_item = obj_contentDocuments[i];
+                const path_contentDocuments_item = path_contentDocuments + '[' + i + ']';
+                const referencepath_contentDocuments_itemValidationError = validate$c(obj_contentDocuments_item, path_contentDocuments_item);
+                if (referencepath_contentDocuments_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match ContentDocumentRepresentation (at "' + path_contentDocuments_item + '")\n';
+                    message += referencepath_contentDocuments_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+        const obj_contractDocumentVersionId = obj.contractDocumentVersionId;
+        const path_contractDocumentVersionId = path + '.contractDocumentVersionId';
+        if (typeof obj_contractDocumentVersionId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contractDocumentVersionId + '" (at "' + path_contractDocumentVersionId + '")');
+        }
+        if (obj.documentGenerationProcessId !== undefined) {
+            const obj_documentGenerationProcessId = obj.documentGenerationProcessId;
+            const path_documentGenerationProcessId = path + '.documentGenerationProcessId';
+            if (typeof obj_documentGenerationProcessId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_documentGenerationProcessId + '" (at "' + path_documentGenerationProcessId + '")');
+            }
+        }
+        if (obj.documentUrl !== undefined) {
+            const obj_documentUrl = obj.documentUrl;
+            const path_documentUrl = path + '.documentUrl';
+            if (typeof obj_documentUrl !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_documentUrl + '" (at "' + path_documentUrl + '")');
+            }
+        }
+        if (obj.name !== undefined) {
+            const obj_name = obj.name;
+            const path_name = path + '.name';
+            if (typeof obj_name !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
+            }
+        }
+        if (obj.responseText !== undefined) {
+            const obj_responseText = obj.responseText;
+            const path_responseText = path + '.responseText';
+            if (typeof obj_responseText !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_responseText + '" (at "' + path_responseText + '")');
+            }
+        }
+        if (obj.status !== undefined) {
+            const obj_status = obj.status;
+            const path_status = path + '.status';
+            if (typeof obj_status !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_status + '" (at "' + path_status + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$2 = 'DocumentGenerationProcessStatusRepresentation';
+function normalize$2(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$8 = function DocumentGenerationProcessStatusRepresentationSelect() {
+    const { selections: ContentDocumentRepresentation__selections, opaque: ContentDocumentRepresentation__opaque, } = select$j();
+    return {
+        kind: 'Fragment',
+        version: VERSION$2,
+        private: [],
+        selections: [
+            {
+                name: 'contentDocuments',
+                kind: 'Object',
+                plural: true,
+                selections: ContentDocumentRepresentation__selections,
+                required: false
+            },
+            {
+                name: 'contractDocumentVersionId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'documentGenerationProcessId',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'documentUrl',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'name',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'responseText',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'status',
+                kind: 'Scalar',
+                required: false
+            }
+        ]
+    };
+};
+function equals$2(existing, incoming) {
+    const existing_contractDocumentVersionId = existing.contractDocumentVersionId;
+    const incoming_contractDocumentVersionId = incoming.contractDocumentVersionId;
+    if (!(existing_contractDocumentVersionId === incoming_contractDocumentVersionId)) {
+        return false;
+    }
+    const existing_documentGenerationProcessId = existing.documentGenerationProcessId;
+    const incoming_documentGenerationProcessId = incoming.documentGenerationProcessId;
+    // if at least one of these optionals is defined
+    if (existing_documentGenerationProcessId !== undefined || incoming_documentGenerationProcessId !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_documentGenerationProcessId === undefined || incoming_documentGenerationProcessId === undefined) {
+            return false;
+        }
+        if (!(existing_documentGenerationProcessId === incoming_documentGenerationProcessId)) {
+            return false;
+        }
+    }
+    const existing_documentUrl = existing.documentUrl;
+    const incoming_documentUrl = incoming.documentUrl;
+    // if at least one of these optionals is defined
+    if (existing_documentUrl !== undefined || incoming_documentUrl !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_documentUrl === undefined || incoming_documentUrl === undefined) {
+            return false;
+        }
+        if (!(existing_documentUrl === incoming_documentUrl)) {
+            return false;
+        }
+    }
+    const existing_name = existing.name;
+    const incoming_name = incoming.name;
+    // if at least one of these optionals is defined
+    if (existing_name !== undefined || incoming_name !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_name === undefined || incoming_name === undefined) {
+            return false;
+        }
+        if (!(existing_name === incoming_name)) {
+            return false;
+        }
+    }
+    const existing_responseText = existing.responseText;
+    const incoming_responseText = incoming.responseText;
+    // if at least one of these optionals is defined
+    if (existing_responseText !== undefined || incoming_responseText !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_responseText === undefined || incoming_responseText === undefined) {
+            return false;
+        }
+        if (!(existing_responseText === incoming_responseText)) {
+            return false;
+        }
+    }
+    const existing_status = existing.status;
+    const incoming_status = incoming.status;
+    // if at least one of these optionals is defined
+    if (existing_status !== undefined || incoming_status !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_status === undefined || incoming_status === undefined) {
+            return false;
+        }
+        if (!(existing_status === incoming_status)) {
+            return false;
+        }
+    }
+    const existing_contentDocuments = existing.contentDocuments;
+    const incoming_contentDocuments = incoming.contentDocuments;
+    // if at least one of these optionals is defined
+    if (existing_contentDocuments !== undefined || incoming_contentDocuments !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_contentDocuments === undefined || incoming_contentDocuments === undefined) {
+            return false;
+        }
+        const equals_contentDocuments_items = equalsArray(existing_contentDocuments, incoming_contentDocuments, (existing_contentDocuments_item, incoming_contentDocuments_item) => {
+            if (!(equals$7(existing_contentDocuments_item, incoming_contentDocuments_item))) {
+                return false;
+            }
+        });
+        if (equals_contentDocuments_items === false) {
+            return false;
+        }
+    }
+    return true;
+}
+const ingest$2 = function DocumentGenerationProcessStatusRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$4(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = path.fullPath;
+    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: "clm",
+            version: VERSION$2,
+            representationName: RepresentationType$2,
+        };
+        luvio.publishStoreMetadata(key, storeMetadataParams);
+    }
+    return createLink(key);
+};
+function getTypeCacheKeys$2(luvio, input, fullPathFactory) {
+    const rootKeySet = new StoreKeyMap();
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = fullPathFactory();
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$2,
+        mergeable: false
+    });
+    return rootKeySet;
+}
+
+function select$7(luvio, params) {
+    return select$8();
+}
+function keyBuilder$4(luvio, params) {
+    return keyPrefix + '::DocumentGenerationProcessStatusRepresentation:(' + 'contractDocumentVersionId:' + params.queryParams.contractDocumentVersionId + ')';
+}
+function getResponseCacheKeys$5(luvio, resourceParams, response) {
+    return getTypeCacheKeys$2(luvio, response, () => keyBuilder$4(luvio, resourceParams));
+}
+function ingestSuccess$5(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$4(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$2, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$7(),
+        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');
+        }
+    }
+    return snapshot;
+}
+function ingestError$1(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$4(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    luvio.storeIngestError(key, errorSnapshot);
+    return errorSnapshot;
+}
+function createResourceRequest$5(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/clm/document-generation-process/status',
+        method: 'get',
+        body: null,
+        urlParams: {},
+        queryParams: config.queryParams,
+        headers,
+        priority: 'normal',
+    };
+}
+
+const getDocumentGenerationProcessDetails_ConfigPropertyNames = {
+    displayName: 'getDocumentGenerationProcessDetails',
+    parameters: {
+        required: [],
+        optional: ['contractDocumentVersionId']
+    }
+};
+function createResourceParams$5(config) {
+    const resourceParams = {
+        queryParams: {
+            contractDocumentVersionId: config.contractDocumentVersionId
+        }
+    };
+    return resourceParams;
+}
+function keyBuilder$3(luvio, config) {
+    const resourceParams = createResourceParams$5(config);
+    return keyBuilder$4(luvio, resourceParams);
+}
+function typeCheckConfig$5(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contractDocumentVersionId = untrustedConfig.contractDocumentVersionId;
+    if (typeof untrustedConfig_contractDocumentVersionId === 'string') {
+        config.contractDocumentVersionId = untrustedConfig_contractDocumentVersionId;
+    }
+    return config;
+}
+function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$5(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment$1(luvio, config) {
+    createResourceParams$5(config);
+    return select$7();
+}
+function onFetchResponseSuccess$1(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$5(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError$1(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$1(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$5(luvio, config, options) {
+    const resourceParams = createResourceParams$5(config);
+    const request = createResourceRequest$5(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$1(luvio, config, resourceParams, response), () => getResponseCacheKeys$5(luvio, resourceParams, response.body));
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$1(luvio, config, resourceParams, response));
+    });
+}
+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$5(luvio, config, dispatchOptions);
+}
+function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$3(luvio, config),
+        node: adapterFragment$1(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getDocumentGenerationProcessDetailsAdapterFactory = (luvio) => function clm__getDocumentGenerationProcessDetails(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$5(untrustedConfig, getDocumentGenerationProcessDetails_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$1, buildNetworkSnapshotCachePolicy$1);
+};
+
+function validate$3(obj, path = 'TemplateRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_id = obj.id;
+        const path_id = path + '.id';
+        if (typeof obj_id !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_id + '" (at "' + path_id + '")');
+        }
+        const obj_isActive = obj.isActive;
+        const path_isActive = path + '.isActive';
+        if (typeof obj_isActive !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_isActive + '" (at "' + path_isActive + '")');
+        }
+        const obj_name = obj.name;
+        const path_name = path + '.name';
+        if (typeof obj_name !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
+        }
+        const obj_type = obj.type;
+        const path_type = path + '.type';
+        if (typeof obj_type !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_type + '" (at "' + path_type + '")');
+        }
+        const obj_version = obj.version;
+        const path_version = path + '.version';
+        if (typeof obj_version !== 'number' || (typeof obj_version === 'number' && Math.floor(obj_version) !== obj_version)) {
+            return new TypeError('Expected "integer" but received "' + typeof obj_version + '" (at "' + path_version + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+function deepFreeze$2(input) {
+    ObjectFreeze(input);
+}
+
+const TTL$1 = 60000;
+const VERSION$1 = "f3cbbe481890c87cbcb6b12993f6383c";
+function validate$2(obj, path = 'TemplateListRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.code !== undefined) {
+            const obj_code = obj.code;
+            const path_code = path + '.code';
+            if (typeof obj_code !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_code + '" (at "' + path_code + '")');
+            }
+        }
+        const obj_data = obj.data;
+        const path_data = path + '.data';
+        if (!ArrayIsArray(obj_data)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_data + '" (at "' + path_data + '")');
+        }
+        for (let i = 0; i < obj_data.length; i++) {
+            const obj_data_item = obj_data[i];
+            const path_data_item = path_data + '[' + i + ']';
+            const referencepath_data_itemValidationError = validate$3(obj_data_item, path_data_item);
+            if (referencepath_data_itemValidationError !== null) {
+                let message = 'Object doesn\'t match TemplateRepresentation (at "' + path_data_item + '")\n';
+                message += referencepath_data_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.message !== undefined) {
+            const obj_message = obj.message;
+            const path_message = path + '.message';
+            if (typeof obj_message !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_message + '" (at "' + path_message + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$1 = 'TemplateListRepresentation';
+function normalize$1(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$6 = function TemplateListRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$1,
+        private: [],
+        opaque: true
+    };
+};
+function equals$1(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
+function deepFreeze$1(input) {
+    const input_data = input.data;
+    for (let i = 0; i < input_data.length; i++) {
+        const input_data_item = input_data[i];
+        deepFreeze$2(input_data_item);
+    }
+    ObjectFreeze(input_data);
+    ObjectFreeze(input);
+}
+const ingest$1 = function TemplateListRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$2(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = path.fullPath;
+    const existingRecord = store.readEntry(key);
+    const ttlToUse = TTL$1;
+    let incomingRecord = normalize$1(input, store.readEntry(key), {
+        fullPath: key,
+        parent: path.parent,
+        propertyName: path.propertyName,
+        ttl: ttlToUse
+    });
+    deepFreeze$1(input);
+    if (existingRecord === undefined || equals$1(existingRecord, incomingRecord) === false) {
+        luvio.storePublish(key, incomingRecord);
+    }
+    {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "clm",
+            version: VERSION$1,
+            representationName: RepresentationType$1,
+        };
+        luvio.publishStoreMetadata(key, storeMetadataParams);
+    }
+    return createLink(key);
+};
+function getTypeCacheKeys$1(luvio, input, fullPathFactory) {
+    const rootKeySet = new StoreKeyMap();
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = fullPathFactory();
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$1,
+        mergeable: false
+    });
+    return rootKeySet;
+}
+
+function select$5(luvio, params) {
+    return select$6();
+}
+function keyBuilder$2(luvio, params) {
+    return keyPrefix + '::TemplateListRepresentation:(' + 'isActive:' + params.queryParams.isActive + ',' + 'type:' + params.queryParams.type + ',' + 'usageType:' + params.queryParams.usageType + ',' + 'contractId:' + params.queryParams.contractId + ',' + 'documentTemplateTypes:' + params.queryParams.documentTemplateTypes + ')';
+}
+function getResponseCacheKeys$4(luvio, resourceParams, response) {
+    return getTypeCacheKeys$1(luvio, response, () => keyBuilder$2(luvio, resourceParams));
+}
+function ingestSuccess$4(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$2(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$1, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$5(),
+        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');
+        }
+    }
+    return snapshot;
+}
+function ingestError(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$2(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    const storeMetadataParams = {
+        ttl: TTL$1,
+        namespace: keyPrefix,
+        version: VERSION$1,
+        representationName: RepresentationType$1
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
+function createResourceRequest$4(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/clm/document-template',
+        method: 'get',
+        body: null,
+        urlParams: {},
+        queryParams: config.queryParams,
+        headers,
+        priority: 'normal',
+    };
+}
+
+const getTemplates_ConfigPropertyNames = {
+    displayName: 'getTemplates',
+    parameters: {
+        required: [],
+        optional: ['isActive', 'type', 'usageType', 'contractId', 'documentTemplateTypes']
+    }
+};
+function createResourceParams$4(config) {
+    const resourceParams = {
+        queryParams: {
+            isActive: config.isActive, type: config.type, usageType: config.usageType, contractId: config.contractId, documentTemplateTypes: config.documentTemplateTypes
+        }
+    };
+    return resourceParams;
+}
+function keyBuilder$1(luvio, config) {
+    const resourceParams = createResourceParams$4(config);
+    return keyBuilder$2(luvio, resourceParams);
+}
+function typeCheckConfig$4(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_isActive = untrustedConfig.isActive;
+    if (typeof untrustedConfig_isActive === 'boolean') {
+        config.isActive = untrustedConfig_isActive;
+    }
+    const untrustedConfig_type = untrustedConfig.type;
+    if (typeof untrustedConfig_type === 'string') {
+        config.type = untrustedConfig_type;
+    }
+    const untrustedConfig_usageType = untrustedConfig.usageType;
+    if (typeof untrustedConfig_usageType === 'string') {
+        config.usageType = untrustedConfig_usageType;
+    }
+    const untrustedConfig_contractId = untrustedConfig.contractId;
+    if (typeof untrustedConfig_contractId === 'string') {
+        config.contractId = untrustedConfig_contractId;
+    }
+    const untrustedConfig_documentTemplateTypes = untrustedConfig.documentTemplateTypes;
+    if (ArrayIsArray$1(untrustedConfig_documentTemplateTypes)) {
+        const untrustedConfig_documentTemplateTypes_array = [];
+        for (let i = 0, arrayLength = untrustedConfig_documentTemplateTypes.length; i < arrayLength; i++) {
+            const untrustedConfig_documentTemplateTypes_item = untrustedConfig_documentTemplateTypes[i];
+            if (typeof untrustedConfig_documentTemplateTypes_item === 'string') {
+                untrustedConfig_documentTemplateTypes_array.push(untrustedConfig_documentTemplateTypes_item);
+            }
+        }
+        config.documentTemplateTypes = untrustedConfig_documentTemplateTypes_array;
+    }
+    return config;
+}
+function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$4(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment(luvio, config) {
+    createResourceParams$4(config);
+    return select$5();
+}
+function onFetchResponseSuccess(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$4(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError(luvio, config, resourceParams, response) {
+    const snapshot = ingestError(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$4(luvio, config, options) {
+    const resourceParams = createResourceParams$4(config);
+    const request = createResourceRequest$4(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess(luvio, config, resourceParams, response), () => getResponseCacheKeys$4(luvio, resourceParams, response.body));
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError(luvio, config, resourceParams, response));
+    });
+}
+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$4(luvio, config, dispatchOptions);
+}
+function buildCachedSnapshotCachePolicy(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$1(luvio, config),
+        node: adapterFragment(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getTemplatesAdapterFactory = (luvio) => function clm__getTemplates(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$4(untrustedConfig, getTemplates_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
+};
+
+function select$4(luvio, params) {
+    return select$l();
+}
+function getResponseCacheKeys$3(luvio, resourceParams, response) {
+    return getTypeCacheKeys$7(luvio, response);
+}
+function ingestSuccess$3(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$4(luvio, body);
+    luvio.storeIngest(key, ingest$7, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$4(),
+        variables: {},
+    });
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    return snapshot;
+}
+function createResourceRequest$3(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/clm/contract-document-version/' + config.urlParams.contractDocumentVersionId + '/lock',
+        method: 'patch',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const lockContractDocumentVersion_ConfigPropertyNames = {
+    displayName: 'lockContractDocumentVersion',
+    parameters: {
+        required: ['contractDocumentVersionId'],
+        optional: []
+    }
+};
+function createResourceParams$3(config) {
+    const resourceParams = {
+        urlParams: {
+            contractDocumentVersionId: config.contractDocumentVersionId
+        }
+    };
+    return resourceParams;
+}
+function typeCheckConfig$3(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contractDocumentVersionId = untrustedConfig.contractDocumentVersionId;
+    if (typeof untrustedConfig_contractDocumentVersionId === 'string') {
+        config.contractDocumentVersionId = untrustedConfig_contractDocumentVersionId;
+    }
+    return config;
+}
+function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$3(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$3(luvio, config, options) {
+    const resourceParams = createResourceParams$3(config);
+    const request = createResourceRequest$3(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$3(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => getResponseCacheKeys$3(luvio, resourceParams, response.body));
+    }, (response) => {
+        deepFreeze$b(response);
+        throw response;
+    });
+}
+const lockContractDocumentVersionAdapterFactory = (luvio) => {
+    return function lockContractDocumentVersion(untrustedConfig) {
+        const config = validateAdapterConfig$3(untrustedConfig, lockContractDocumentVersion_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "lockContractDocumentVersion"');
+        }
+        return buildNetworkSnapshot$3(luvio, config);
+    };
+};
+
+function validate$1(obj, path = 'SaveExternalDocumentInputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_extDocumentId = obj.extDocumentId;
+        const path_extDocumentId = path + '.extDocumentId';
+        if (typeof obj_extDocumentId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_extDocumentId + '" (at "' + path_extDocumentId + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+const TTL = 60000;
+const VERSION = "0073b6a90cebc73156c21fe3fd09256a";
+function validate(obj, path = 'SaveExternalDocumentRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_id = obj.id;
+        const path_id = path + '.id';
+        if (typeof obj_id !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_id + '" (at "' + path_id + '")');
+        }
+        const obj_isSuccess = obj.isSuccess;
+        const path_isSuccess = path + '.isSuccess';
+        if (typeof obj_isSuccess !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_isSuccess + '" (at "' + path_isSuccess + '")');
+        }
+        if (obj.message !== undefined) {
+            const obj_message = obj.message;
+            const path_message = path + '.message';
+            if (typeof obj_message !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_message + '" (at "' + path_message + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType = 'SaveExternalDocumentRepresentation';
+function keyBuilder(luvio, config) {
+    return keyPrefix + '::' + RepresentationType + ':' + config.id;
+}
+function keyBuilderFromType(luvio, object) {
+    const keyParams = {
+        id: object.id
+    };
+    return keyBuilder(luvio, keyParams);
+}
+function normalize(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$3 = function SaveExternalDocumentRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION,
+        private: [],
+        opaque: true
+    };
+};
+function equals(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
+function deepFreeze(input) {
+    ObjectFreeze(input);
+}
+const ingest = function SaveExternalDocumentRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType(luvio, input);
+    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
+    });
+    deepFreeze(input);
+    if (existingRecord === undefined || equals(existingRecord, incomingRecord) === false) {
+        luvio.storePublish(key, incomingRecord);
+    }
+    {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "clm",
+            version: VERSION,
+            representationName: RepresentationType,
+        };
+        luvio.publishStoreMetadata(key, storeMetadataParams);
+    }
+    return createLink(key);
+};
+function getTypeCacheKeys(luvio, input, fullPathFactory) {
+    const rootKeySet = new StoreKeyMap();
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType,
+        mergeable: false
+    });
+    return rootKeySet;
+}
+
+function select$2(luvio, params) {
+    return select$3();
+}
+function getResponseCacheKeys$2(luvio, resourceParams, response) {
+    return getTypeCacheKeys(luvio, response);
+}
+function ingestSuccess$2(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType(luvio, body);
+    luvio.storeIngest(key, ingest, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$2(),
+        variables: {},
+    });
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    return snapshot;
+}
+function createResourceRequest$2(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/clm/external-document-resource',
+        method: 'patch',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const saveExternalDocument_ConfigPropertyNames = {
+    displayName: 'saveExternalDocument',
+    parameters: {
+        required: ['externalDocumentInput'],
+        optional: []
+    }
+};
+function createResourceParams$2(config) {
+    const resourceParams = {
+        body: {
+            externalDocumentInput: config.externalDocumentInput
+        }
+    };
+    return resourceParams;
+}
+function typeCheckConfig$2(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_externalDocumentInput = untrustedConfig.externalDocumentInput;
+    const referenceSaveExternalDocumentInputRepresentationValidationError = validate$1(untrustedConfig_externalDocumentInput);
+    if (referenceSaveExternalDocumentInputRepresentationValidationError === null) {
+        config.externalDocumentInput = untrustedConfig_externalDocumentInput;
+    }
+    return config;
+}
+function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$2(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$2(luvio, config, options) {
+    const resourceParams = createResourceParams$2(config);
+    const request = createResourceRequest$2(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$2(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => getResponseCacheKeys$2(luvio, resourceParams, response.body));
+    }, (response) => {
+        deepFreeze$b(response);
+        throw response;
+    });
+}
+const saveExternalDocumentAdapterFactory = (luvio) => {
+    return function saveExternalDocument(untrustedConfig) {
+        const config = validateAdapterConfig$2(untrustedConfig, saveExternalDocument_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "saveExternalDocument"');
+        }
+        return buildNetworkSnapshot$2(luvio, config);
+    };
+};
+
+function select$1(luvio, params) {
+    return select$l();
+}
+function getResponseCacheKeys$1(luvio, resourceParams, response) {
+    return getTypeCacheKeys$7(luvio, response);
+}
+function ingestSuccess$1(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$4(luvio, body);
+    luvio.storeIngest(key, ingest$7, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$1(),
+        variables: {},
+    });
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    return snapshot;
+}
+function createResourceRequest$1(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/clm/contract-document-version/' + config.urlParams.contractDocumentVersionId + '/unlock',
+        method: 'patch',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const unlock_ConfigPropertyNames = {
+    displayName: 'unlock',
+    parameters: {
+        required: ['contractDocumentVersionId'],
+        optional: []
+    }
+};
+function createResourceParams$1(config) {
+    const resourceParams = {
+        urlParams: {
+            contractDocumentVersionId: config.contractDocumentVersionId
+        }
+    };
+    return resourceParams;
+}
+function typeCheckConfig$1(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contractDocumentVersionId = untrustedConfig.contractDocumentVersionId;
+    if (typeof untrustedConfig_contractDocumentVersionId === 'string') {
+        config.contractDocumentVersionId = untrustedConfig_contractDocumentVersionId;
+    }
+    return config;
+}
+function validateAdapterConfig$1(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$1(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$1(luvio, config, options) {
+    const resourceParams = createResourceParams$1(config);
+    const request = createResourceRequest$1(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$1(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => getResponseCacheKeys$1(luvio, resourceParams, response.body));
+    }, (response) => {
+        deepFreeze$b(response);
+        throw response;
+    });
+}
+const unlockAdapterFactory = (luvio) => {
+    return function unlock(untrustedConfig) {
+        const config = validateAdapterConfig$1(untrustedConfig, unlock_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "unlock"');
+        }
+        return buildNetworkSnapshot$1(luvio, config);
+    };
+};
+
+function select(luvio, params) {
+    return select$i();
+}
+function getResponseCacheKeys(luvio, resourceParams, response) {
+    return getTypeCacheKeys$6(luvio, response);
+}
+function ingestSuccess(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$3(luvio, body);
+    luvio.storeIngest(key, ingest$6, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select(),
+        variables: {},
+    });
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    return snapshot;
+}
+function createResourceRequest(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/clm/contract-document-version/' + config.urlParams.contractDocumentVersionId + '',
+        method: 'patch',
+        body: config.body,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const updateContractDocumentVersionWithTemplate_ConfigPropertyNames = {
+    displayName: 'updateContractDocumentVersionWithTemplate',
+    parameters: {
+        required: ['contractDocumentVersionId', 'templateInput'],
+        optional: []
+    }
+};
+function createResourceParams(config) {
+    const resourceParams = {
+        urlParams: {
+            contractDocumentVersionId: config.contractDocumentVersionId
+        },
+        body: {
+            templateInput: config.templateInput
+        }
+    };
+    return resourceParams;
+}
+function typeCheckConfig(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contractDocumentVersionId = untrustedConfig.contractDocumentVersionId;
+    if (typeof untrustedConfig_contractDocumentVersionId === 'string') {
+        config.contractDocumentVersionId = untrustedConfig_contractDocumentVersionId;
+    }
+    const untrustedConfig_templateInput = untrustedConfig.templateInput;
+    const referenceTemplateInputRepresentationValidationError = validate$d(untrustedConfig_templateInput);
+    if (referenceTemplateInputRepresentationValidationError === null) {
+        config.templateInput = untrustedConfig_templateInput;
+    }
+    return config;
+}
+function validateAdapterConfig(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot(luvio, config, options) {
+    const resourceParams = createResourceParams(config);
+    const request = createResourceRequest(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => getResponseCacheKeys(luvio, resourceParams, response.body));
+    }, (response) => {
+        deepFreeze$b(response);
+        throw response;
+    });
+}
+const updateContractDocumentVersionWithTemplateAdapterFactory = (luvio) => {
+    return function updateContractDocumentVersionWithTemplate(untrustedConfig) {
+        const config = validateAdapterConfig(untrustedConfig, updateContractDocumentVersionWithTemplate_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "updateContractDocumentVersionWithTemplate"');
+        }
+        return buildNetworkSnapshot(luvio, config);
+    };
+};
+
+let checkIn;
+let checkoutContractDocumentVersion;
+let createContractDocumentVersionAndInitializeGenerateDocumentProcess;
+let deleteAttachment;
+let executeContractAction;
+let getContentDocument;
+let getContentDocumentNotifyChange;
+let getContractActions;
+let getContractActionsNotifyChange;
+let getContractDocumentVersion;
+let getDocumentGenerationProcessDetails;
+let getTemplates;
+let lockContractDocumentVersion;
+let saveExternalDocument;
+let unlock;
+let updateContractDocumentVersionWithTemplate;
+// Imperative GET Adapters
+let getContentDocument_imperative;
+let getContractActions_imperative;
+let getContractDocumentVersion_imperative;
+let getDocumentGenerationProcessDetails_imperative;
+let getTemplates_imperative;
+const getContentDocumentMetadata = { apiFamily: 'clm', name: 'getContentDocument', ttl: 60000 };
+const getContractActionsMetadata = { apiFamily: 'clm', name: 'getContractActions', ttl: 60000 };
+const getContractDocumentVersionMetadata = { apiFamily: 'clm', name: 'getContractDocumentVersion', ttl: 60000 };
+const getDocumentGenerationProcessDetailsMetadata = { apiFamily: 'clm', name: 'getDocumentGenerationProcessDetails' };
+const getTemplatesMetadata = { apiFamily: 'clm', name: 'getTemplates', ttl: 60000 };
+function bindExportsTo(luvio) {
+    // LDS Adapters
+    const getContentDocument_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getContentDocument', getContentDocumentAdapterFactory), getContentDocumentMetadata);
+    const getContractActions_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getContractActions', getContractActionsAdapterFactory), getContractActionsMetadata);
+    const getContractDocumentVersion_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getContractDocumentVersion', getContractDocumentVersionAdapterFactory), getContractDocumentVersionMetadata);
+    const getDocumentGenerationProcessDetails_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getDocumentGenerationProcessDetails', getDocumentGenerationProcessDetailsAdapterFactory), getDocumentGenerationProcessDetailsMetadata);
+    const getTemplates_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getTemplates', getTemplatesAdapterFactory), getTemplatesMetadata);
+    function unwrapSnapshotData(factory) {
+        const adapter = factory(luvio);
+        return (config) => adapter(config).then(snapshot => snapshot.data);
+    }
+    return {
+        checkIn: unwrapSnapshotData(checkInAdapterFactory),
+        checkoutContractDocumentVersion: unwrapSnapshotData(checkoutContractDocumentVersionAdapterFactory),
+        createContractDocumentVersionAndInitializeGenerateDocumentProcess: unwrapSnapshotData(createContractDocumentVersionAndInitializeGenerateDocumentProcessAdapterFactory),
+        deleteAttachment: createLDSAdapter(luvio, adapterName, deleteAttachmentAdapterFactory),
+        executeContractAction: unwrapSnapshotData(executeContractActionAdapterFactory),
+        getContentDocument: createWireAdapterConstructor(luvio, getContentDocument_ldsAdapter, getContentDocumentMetadata),
+        getContentDocumentNotifyChange: createLDSAdapter(luvio, 'getContentDocumentNotifyChange', notifyChangeFactory$1),
+        getContractActions: createWireAdapterConstructor(luvio, getContractActions_ldsAdapter, getContractActionsMetadata),
+        getContractActionsNotifyChange: createLDSAdapter(luvio, 'getContractActionsNotifyChange', notifyChangeFactory),
+        getContractDocumentVersion: createWireAdapterConstructor(luvio, getContractDocumentVersion_ldsAdapter, getContractDocumentVersionMetadata),
+        getDocumentGenerationProcessDetails: createWireAdapterConstructor(luvio, getDocumentGenerationProcessDetails_ldsAdapter, getDocumentGenerationProcessDetailsMetadata),
+        getTemplates: createWireAdapterConstructor(luvio, getTemplates_ldsAdapter, getTemplatesMetadata),
+        lockContractDocumentVersion: unwrapSnapshotData(lockContractDocumentVersionAdapterFactory),
+        saveExternalDocument: unwrapSnapshotData(saveExternalDocumentAdapterFactory),
+        unlock: unwrapSnapshotData(unlockAdapterFactory),
+        updateContractDocumentVersionWithTemplate: unwrapSnapshotData(updateContractDocumentVersionWithTemplateAdapterFactory),
+        // Imperative GET Adapters
+        getContentDocument_imperative: createImperativeAdapter(luvio, getContentDocument_ldsAdapter, getContentDocumentMetadata),
+        getContractActions_imperative: createImperativeAdapter(luvio, getContractActions_ldsAdapter, getContractActionsMetadata),
+        getContractDocumentVersion_imperative: createImperativeAdapter(luvio, getContractDocumentVersion_ldsAdapter, getContractDocumentVersionMetadata),
+        getDocumentGenerationProcessDetails_imperative: createImperativeAdapter(luvio, getDocumentGenerationProcessDetails_ldsAdapter, getDocumentGenerationProcessDetailsMetadata),
+        getTemplates_imperative: createImperativeAdapter(luvio, getTemplates_ldsAdapter, getTemplatesMetadata)
+    };
+}
+withDefaultLuvio((luvio) => {
+    ({
+        checkIn,
+        checkoutContractDocumentVersion,
+        createContractDocumentVersionAndInitializeGenerateDocumentProcess,
+        deleteAttachment,
+        executeContractAction,
+        getContentDocument,
+        getContentDocumentNotifyChange,
+        getContractActions,
+        getContractActionsNotifyChange,
+        getContractDocumentVersion,
+        getDocumentGenerationProcessDetails,
+        getTemplates,
+        lockContractDocumentVersion,
+        saveExternalDocument,
+        unlock,
+        updateContractDocumentVersionWithTemplate,
+        getContentDocument_imperative,
+        getContractActions_imperative,
+        getContractDocumentVersion_imperative,
+        getDocumentGenerationProcessDetails_imperative,
+        getTemplates_imperative
+    } = bindExportsTo(luvio));
+});
+
+export { checkIn, checkoutContractDocumentVersion, createContractDocumentVersionAndInitializeGenerateDocumentProcess, deleteAttachment, executeContractAction, getContentDocument, getContentDocumentNotifyChange, getContentDocument_imperative, getContractActions, getContractActionsNotifyChange, getContractActions_imperative, getContractDocumentVersion, getContractDocumentVersion_imperative, getDocumentGenerationProcessDetails, getDocumentGenerationProcessDetails_imperative, getTemplates, getTemplates_imperative, lockContractDocumentVersion, saveExternalDocument, unlock, updateContractDocumentVersionWithTemplate };
+// version: 1.100.2-ca56bb821