@salesforce/lds-adapters-industries-context 1.100.2

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

@@ -0,0 +1,4038 @@
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+import { serializeStructuredKey, StoreKeyMap } from '@luvio/engine';
+
+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 = 'IndustriesContext';
+
+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$8(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$8(value[i]);
+        }
+    }
+    else {
+        const keys = ObjectKeys(value);
+        for (let i = 0, len = keys.length; i < len; i += 1) {
+            deepFreeze$8(value[keys[i]]);
+        }
+    }
+    ObjectFreeze(value);
+}
+function createLink(ref) {
+    return {
+        __ref: serializeStructuredKey(ref),
+    };
+}
+
+const TTL$6 = 30000;
+const VERSION$6 = "5ded6ac11eaf95f0422141c310d984e3";
+function validate$e(obj, path = 'ContextDefinitionInfoRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.activeVersionId !== undefined) {
+            const obj_activeVersionId = obj.activeVersionId;
+            const path_activeVersionId = path + '.activeVersionId';
+            if (typeof obj_activeVersionId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_activeVersionId + '" (at "' + path_activeVersionId + '")');
+            }
+        }
+        const obj_contextDefinitionId = obj.contextDefinitionId;
+        const path_contextDefinitionId = path + '.contextDefinitionId';
+        if (typeof obj_contextDefinitionId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contextDefinitionId + '" (at "' + path_contextDefinitionId + '")');
+        }
+        const obj_definition = obj.definition;
+        const path_definition = path + '.definition';
+        if (typeof obj_definition !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_definition + '" (at "' + path_definition + '")');
+        }
+        const obj_description = obj.description;
+        const path_description = path + '.description';
+        if (typeof obj_description !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_description + '" (at "' + path_description + '")');
+        }
+        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$6 = 'ContextDefinitionInfoRepresentation';
+function keyBuilder$l(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$6 + ':' + config.id;
+}
+function keyBuilderFromType$5(luvio, object) {
+    const keyParams = {
+        id: object.contextDefinitionId
+    };
+    return keyBuilder$l(luvio, keyParams);
+}
+function normalize$6(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$k = function ContextDefinitionInfoRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$6,
+        private: [],
+        selections: [
+            {
+                name: 'activeVersionId',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'contextDefinitionId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'definition',
+                kind: 'Scalar'
+            },
+            {
+                name: 'description',
+                kind: 'Scalar'
+            },
+            {
+                name: 'isSuccess',
+                kind: 'Scalar',
+                required: false
+            }
+        ]
+    };
+};
+function equals$6(existing, incoming) {
+    const existing_isSuccess = existing.isSuccess;
+    const incoming_isSuccess = incoming.isSuccess;
+    // if at least one of these optionals is defined
+    if (existing_isSuccess !== undefined || incoming_isSuccess !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_isSuccess === undefined || incoming_isSuccess === undefined) {
+            return false;
+        }
+        if (!(existing_isSuccess === incoming_isSuccess)) {
+            return false;
+        }
+    }
+    const existing_activeVersionId = existing.activeVersionId;
+    const incoming_activeVersionId = incoming.activeVersionId;
+    // if at least one of these optionals is defined
+    if (existing_activeVersionId !== undefined || incoming_activeVersionId !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_activeVersionId === undefined || incoming_activeVersionId === undefined) {
+            return false;
+        }
+        if (!(existing_activeVersionId === incoming_activeVersionId)) {
+            return false;
+        }
+    }
+    const existing_contextDefinitionId = existing.contextDefinitionId;
+    const incoming_contextDefinitionId = incoming.contextDefinitionId;
+    if (!(existing_contextDefinitionId === incoming_contextDefinitionId)) {
+        return false;
+    }
+    const existing_definition = existing.definition;
+    const incoming_definition = incoming.definition;
+    if (!(existing_definition === incoming_definition)) {
+        return false;
+    }
+    const existing_description = existing.description;
+    const incoming_description = incoming.description;
+    if (!(existing_description === incoming_description)) {
+        return false;
+    }
+    return true;
+}
+const ingest$6 = function ContextDefinitionInfoRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$e(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$5(luvio, input);
+    const existingRecord = store.readEntry(key);
+    const ttlToUse = TTL$6;
+    let incomingRecord = normalize$6(input, store.readEntry(key), {
+        fullPath: key,
+        parent: path.parent,
+        propertyName: path.propertyName,
+        ttl: ttlToUse
+    });
+    if (existingRecord === undefined || equals$6(existingRecord, incomingRecord) === false) {
+        luvio.storePublish(key, incomingRecord);
+    }
+    {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "IndustriesContext",
+            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$5(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$6,
+        mergeable: false
+    });
+    return rootKeySet;
+}
+
+const TTL$5 = 10000;
+const VERSION$5 = "4eaf7936c751a49821abb04c4e57d921";
+function validate$d(obj, path = 'ContextDefinitionListRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_contextDefinitionList = obj.contextDefinitionList;
+        const path_contextDefinitionList = path + '.contextDefinitionList';
+        if (!ArrayIsArray(obj_contextDefinitionList)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_contextDefinitionList + '" (at "' + path_contextDefinitionList + '")');
+        }
+        for (let i = 0; i < obj_contextDefinitionList.length; i++) {
+            const obj_contextDefinitionList_item = obj_contextDefinitionList[i];
+            const path_contextDefinitionList_item = path_contextDefinitionList + '[' + i + ']';
+            if (typeof obj_contextDefinitionList_item !== 'object') {
+                return new TypeError('Expected "object" but received "' + typeof obj_contextDefinitionList_item + '" (at "' + path_contextDefinitionList_item + '")');
+            }
+        }
+        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$5 = 'ContextDefinitionListRepresentation';
+function normalize$5(input, existing, path, luvio, store, timestamp) {
+    const input_contextDefinitionList = input.contextDefinitionList;
+    const input_contextDefinitionList_id = path.fullPath + '__contextDefinitionList';
+    for (let i = 0; i < input_contextDefinitionList.length; i++) {
+        const input_contextDefinitionList_item = input_contextDefinitionList[i];
+        let input_contextDefinitionList_item_id = input_contextDefinitionList_id + '__' + i;
+        input_contextDefinitionList[i] = ingest$6(input_contextDefinitionList_item, {
+            fullPath: input_contextDefinitionList_item_id,
+            propertyName: i,
+            parent: {
+                data: input,
+                key: path.fullPath,
+                existing: existing,
+            },
+            ttl: path.ttl
+        }, luvio, store);
+    }
+    return input;
+}
+const select$j = function ContextDefinitionListRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$5,
+        private: [],
+        selections: [
+            {
+                name: 'contextDefinitionList',
+                kind: 'Link',
+                plural: true,
+                fragment: select$k()
+            },
+            {
+                name: 'isSuccess',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$5(existing, incoming) {
+    const existing_isSuccess = existing.isSuccess;
+    const incoming_isSuccess = incoming.isSuccess;
+    if (!(existing_isSuccess === incoming_isSuccess)) {
+        return false;
+    }
+    const existing_contextDefinitionList = existing.contextDefinitionList;
+    const incoming_contextDefinitionList = incoming.contextDefinitionList;
+    const equals_contextDefinitionList_items = equalsArray(existing_contextDefinitionList, incoming_contextDefinitionList, (existing_contextDefinitionList_item, incoming_contextDefinitionList_item) => {
+        if (!(existing_contextDefinitionList_item.__ref === incoming_contextDefinitionList_item.__ref)) {
+            return false;
+        }
+    });
+    if (equals_contextDefinitionList_items === false) {
+        return false;
+    }
+    return true;
+}
+const ingest$5 = function ContextDefinitionListRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$d(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = path.fullPath;
+    const existingRecord = store.readEntry(key);
+    const ttlToUse = TTL$5;
+    let incomingRecord = normalize$5(input, store.readEntry(key), {
+        fullPath: key,
+        parent: path.parent,
+        propertyName: path.propertyName,
+        ttl: ttlToUse
+    }, luvio, store);
+    if (existingRecord === undefined || equals$5(existingRecord, incomingRecord) === false) {
+        luvio.storePublish(key, incomingRecord);
+    }
+    {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "IndustriesContext",
+            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 = fullPathFactory();
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$5,
+        mergeable: false
+    });
+    const input_contextDefinitionList_length = input.contextDefinitionList.length;
+    for (let i = 0; i < input_contextDefinitionList_length; i++) {
+        rootKeySet.merge(getTypeCacheKeys$6(luvio, input.contextDefinitionList[i]));
+    }
+    return rootKeySet;
+}
+
+function select$i(luvio, params) {
+    return select$j();
+}
+function keyBuilder$k(luvio, params) {
+    return keyPrefix + '::ContextDefinitionListRepresentation:(' + ')';
+}
+function getResponseCacheKeys$h(luvio, resourceParams, response) {
+    return getTypeCacheKeys$5(luvio, response, () => keyBuilder$k());
+}
+function ingestSuccess$d(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$k();
+    luvio.storeIngest(key, ingest$5, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$i(),
+        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$5(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$k();
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    const storeMetadataParams = {
+        ttl: TTL$5,
+        namespace: keyPrefix,
+        version: VERSION$5,
+        representationName: RepresentationType$5
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
+function createResourceRequest$h(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/contextdefinition',
+        method: 'get',
+        body: null,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const getContextDefinitionList_ConfigPropertyNames = {
+    displayName: 'getContextDefinitionList',
+    parameters: {
+        required: [],
+        optional: []
+    }
+};
+function createResourceParams$h(config) {
+    const resourceParams = {};
+    return resourceParams;
+}
+function keyBuilder$j(luvio, config) {
+    return keyBuilder$k();
+}
+function typeCheckConfig$h(untrustedConfig) {
+    const config = {};
+    return config;
+}
+function validateAdapterConfig$h(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$h();
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment$5(luvio, config) {
+    return select$i();
+}
+function onFetchResponseSuccess$5(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$d(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$h(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError$5(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$5(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$h(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$h(luvio, config, options) {
+    const resourceParams = createResourceParams$h();
+    const request = createResourceRequest$h();
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$5(luvio, config, resourceParams, response), () => getResponseCacheKeys$h(luvio, resourceParams, response.body));
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$5(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext) {
+    const { luvio, config } = context;
+    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
+    const dispatchOptions = {
+        resourceRequestContext: {
+            requestCorrelator,
+            luvioRequestMethod: undefined,
+        },
+        eventObservers
+    };
+    if (networkPriority !== 'normal') {
+        dispatchOptions.overrides = {
+            priority: networkPriority
+        };
+    }
+    return buildNetworkSnapshot$h(luvio, config, dispatchOptions);
+}
+function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$j(),
+        node: adapterFragment$5(),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$h(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getContextDefinitionListAdapterFactory = (luvio) => function IndustriesContext__getContextDefinitionList(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$h(untrustedConfig, getContextDefinitionList_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$5, buildNetworkSnapshotCachePolicy$5);
+};
+
+function validate$c(obj, path = 'ContextDefinitionInputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.definition !== undefined) {
+            const obj_definition = obj.definition;
+            const path_definition = path + '.definition';
+            if (typeof obj_definition !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_definition + '" (at "' + path_definition + '")');
+            }
+        }
+        if (obj.description !== undefined) {
+            const obj_description = obj.description;
+            const path_description = path + '.description';
+            if (typeof obj_description !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_description + '" (at "' + path_description + '")');
+            }
+        }
+        if (obj.developerName !== undefined) {
+            const obj_developerName = obj.developerName;
+            const path_developerName = path + '.developerName';
+            if (typeof obj_developerName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_developerName + '" (at "' + path_developerName + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function select$h(luvio, params) {
+    return select$k();
+}
+function getResponseCacheKeys$g(luvio, resourceParams, response) {
+    return getTypeCacheKeys$6(luvio, response);
+}
+function ingestSuccess$c(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$5(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$g(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/contextdefinition',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const createContextDefinition_ConfigPropertyNames = {
+    displayName: 'createContextDefinition',
+    parameters: {
+        required: ['contextDefinitionInput'],
+        optional: []
+    }
+};
+function createResourceParams$g(config) {
+    const resourceParams = {
+        body: {
+            contextDefinitionInput: config.contextDefinitionInput
+        }
+    };
+    return resourceParams;
+}
+function typeCheckConfig$g(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contextDefinitionInput = untrustedConfig.contextDefinitionInput;
+    const referenceContextDefinitionInputRepresentationValidationError = validate$c(untrustedConfig_contextDefinitionInput);
+    if (referenceContextDefinitionInputRepresentationValidationError === null) {
+        config.contextDefinitionInput = untrustedConfig_contextDefinitionInput;
+    }
+    return config;
+}
+function validateAdapterConfig$g(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$g(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$g(luvio, config, options) {
+    const resourceParams = createResourceParams$g(config);
+    const request = createResourceRequest$g(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$c(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => getResponseCacheKeys$g(luvio, resourceParams, response.body));
+    }, (response) => {
+        deepFreeze$8(response);
+        throw response;
+    });
+}
+const createContextDefinitionAdapterFactory = (luvio) => {
+    return function createContextDefinition(untrustedConfig) {
+        const config = validateAdapterConfig$g(untrustedConfig, createContextDefinition_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "createContextDefinition"');
+        }
+        return buildNetworkSnapshot$g(luvio, config);
+    };
+};
+
+function validate$b(obj, path = 'ContextAttributeInputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.attributeTags !== undefined) {
+            const obj_attributeTags = obj.attributeTags;
+            const path_attributeTags = path + '.attributeTags';
+            if (!ArrayIsArray(obj_attributeTags)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_attributeTags + '" (at "' + path_attributeTags + '")');
+            }
+            for (let i = 0; i < obj_attributeTags.length; i++) {
+                const obj_attributeTags_item = obj_attributeTags[i];
+                const path_attributeTags_item = path_attributeTags + '[' + i + ']';
+                if (typeof obj_attributeTags_item !== 'object' || ArrayIsArray(obj_attributeTags_item) || obj_attributeTags_item === null) {
+                    return new TypeError('Expected "object" but received "' + typeof obj_attributeTags_item + '" (at "' + path_attributeTags_item + '")');
+                }
+            }
+        }
+        if (obj.dataType !== undefined) {
+            const obj_dataType = obj.dataType;
+            const path_dataType = path + '.dataType';
+            if (typeof obj_dataType !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_dataType + '" (at "' + path_dataType + '")');
+            }
+        }
+        if (obj.fieldType !== undefined) {
+            const obj_fieldType = obj.fieldType;
+            const path_fieldType = path + '.fieldType';
+            if (typeof obj_fieldType !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_fieldType + '" (at "' + path_fieldType + '")');
+            }
+        }
+        if (obj.isFinal !== undefined) {
+            const obj_isFinal = obj.isFinal;
+            const path_isFinal = path + '.isFinal';
+            if (typeof obj_isFinal !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isFinal + '" (at "' + path_isFinal + '")');
+            }
+        }
+        if (obj.isKey !== undefined) {
+            const obj_isKey = obj.isKey;
+            const path_isKey = path + '.isKey';
+            if (typeof obj_isKey !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isKey + '" (at "' + path_isKey + '")');
+            }
+        }
+        if (obj.isValue !== undefined) {
+            const obj_isValue = obj.isValue;
+            const path_isValue = path + '.isValue';
+            if (typeof obj_isValue !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isValue + '" (at "' + path_isValue + '")');
+            }
+        }
+        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.parentNodeId !== undefined) {
+            const obj_parentNodeId = obj.parentNodeId;
+            const path_parentNodeId = path + '.parentNodeId';
+            if (typeof obj_parentNodeId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_parentNodeId + '" (at "' + path_parentNodeId + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+const TTL$4 = 30000;
+const VERSION$4 = "60e01dae1235ff9bc96afee43e91620c";
+function validate$a(obj, path = 'ContextAttributeTagRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_contextAttributeId = obj.contextAttributeId;
+        const path_contextAttributeId = path + '.contextAttributeId';
+        if (typeof obj_contextAttributeId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contextAttributeId + '" (at "' + path_contextAttributeId + '")');
+        }
+        const obj_contextAttributeTagId = obj.contextAttributeTagId;
+        const path_contextAttributeTagId = path + '.contextAttributeTagId';
+        if (typeof obj_contextAttributeTagId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contextAttributeTagId + '" (at "' + path_contextAttributeTagId + '")');
+        }
+        const obj_contextNodeId = obj.contextNodeId;
+        const path_contextNodeId = path + '.contextNodeId';
+        if (typeof obj_contextNodeId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contextNodeId + '" (at "' + path_contextNodeId + '")');
+        }
+        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 + '")');
+        }
+        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 + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$4 = 'ContextAttributeTagRepresentation';
+function keyBuilder$i(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$4 + ':' + config.id;
+}
+function keyBuilderFromType$4(luvio, object) {
+    const keyParams = {
+        id: object.contextAttributeTagId
+    };
+    return keyBuilder$i(luvio, keyParams);
+}
+function normalize$4(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$g = function ContextAttributeTagRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$4,
+        private: [],
+        selections: [
+            {
+                name: 'contextAttributeId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'contextAttributeTagId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'contextNodeId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'isSuccess',
+                kind: 'Scalar'
+            },
+            {
+                name: 'name',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$4(existing, incoming) {
+    const existing_isSuccess = existing.isSuccess;
+    const incoming_isSuccess = incoming.isSuccess;
+    if (!(existing_isSuccess === incoming_isSuccess)) {
+        return false;
+    }
+    const existing_contextAttributeId = existing.contextAttributeId;
+    const incoming_contextAttributeId = incoming.contextAttributeId;
+    if (!(existing_contextAttributeId === incoming_contextAttributeId)) {
+        return false;
+    }
+    const existing_contextAttributeTagId = existing.contextAttributeTagId;
+    const incoming_contextAttributeTagId = incoming.contextAttributeTagId;
+    if (!(existing_contextAttributeTagId === incoming_contextAttributeTagId)) {
+        return false;
+    }
+    const existing_contextNodeId = existing.contextNodeId;
+    const incoming_contextNodeId = incoming.contextNodeId;
+    if (!(existing_contextNodeId === incoming_contextNodeId)) {
+        return false;
+    }
+    const existing_name = existing.name;
+    const incoming_name = incoming.name;
+    if (!(existing_name === incoming_name)) {
+        return false;
+    }
+    return true;
+}
+function deepFreeze$7(input) {
+    ObjectFreeze(input);
+}
+const ingest$4 = function ContextAttributeTagRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$a(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$4(luvio, input);
+    const existingRecord = store.readEntry(key);
+    const ttlToUse = TTL$4;
+    let incomingRecord = normalize$4(input, store.readEntry(key), {
+        fullPath: key,
+        parent: path.parent,
+        propertyName: path.propertyName,
+        ttl: ttlToUse
+    });
+    if (existingRecord === undefined || equals$4(existingRecord, incomingRecord) === false) {
+        luvio.storePublish(key, incomingRecord);
+    }
+    {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "IndustriesContext",
+            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$4(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$4,
+        mergeable: false
+    });
+    return rootKeySet;
+}
+
+const TTL$3 = 30000;
+const VERSION$3 = "07b953190ccdfc99b3c6245b4ab37939";
+function validate$9(obj, path = 'ContextAttributeRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_attributeTags = obj.attributeTags;
+        const path_attributeTags = path + '.attributeTags';
+        if (!ArrayIsArray(obj_attributeTags)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_attributeTags + '" (at "' + path_attributeTags + '")');
+        }
+        for (let i = 0; i < obj_attributeTags.length; i++) {
+            const obj_attributeTags_item = obj_attributeTags[i];
+            const path_attributeTags_item = path_attributeTags + '[' + i + ']';
+            if (typeof obj_attributeTags_item !== 'object') {
+                return new TypeError('Expected "object" but received "' + typeof obj_attributeTags_item + '" (at "' + path_attributeTags_item + '")');
+            }
+        }
+        const obj_contextAttributeId = obj.contextAttributeId;
+        const path_contextAttributeId = path + '.contextAttributeId';
+        if (typeof obj_contextAttributeId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contextAttributeId + '" (at "' + path_contextAttributeId + '")');
+        }
+        const obj_dataType = obj.dataType;
+        const path_dataType = path + '.dataType';
+        if (typeof obj_dataType !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_dataType + '" (at "' + path_dataType + '")');
+        }
+        const obj_fieldType = obj.fieldType;
+        const path_fieldType = path + '.fieldType';
+        if (typeof obj_fieldType !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_fieldType + '" (at "' + path_fieldType + '")');
+        }
+        const obj_isFinal = obj.isFinal;
+        const path_isFinal = path + '.isFinal';
+        if (typeof obj_isFinal !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_isFinal + '" (at "' + path_isFinal + '")');
+        }
+        if (obj.isKey !== undefined) {
+            const obj_isKey = obj.isKey;
+            const path_isKey = path + '.isKey';
+            if (typeof obj_isKey !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isKey + '" (at "' + path_isKey + '")');
+            }
+        }
+        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 + '")');
+            }
+        }
+        if (obj.isValue !== undefined) {
+            const obj_isValue = obj.isValue;
+            const path_isValue = path + '.isValue';
+            if (typeof obj_isValue !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isValue + '" (at "' + path_isValue + '")');
+            }
+        }
+        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_parentNodeId = obj.parentNodeId;
+        const path_parentNodeId = path + '.parentNodeId';
+        if (typeof obj_parentNodeId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_parentNodeId + '" (at "' + path_parentNodeId + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$3 = 'ContextAttributeRepresentation';
+function keyBuilder$h(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$3 + ':' + config.id;
+}
+function keyBuilderFromType$3(luvio, object) {
+    const keyParams = {
+        id: object.contextAttributeId
+    };
+    return keyBuilder$h(luvio, keyParams);
+}
+function normalize$3(input, existing, path, luvio, store, timestamp) {
+    const input_attributeTags = input.attributeTags;
+    const input_attributeTags_id = path.fullPath + '__attributeTags';
+    for (let i = 0; i < input_attributeTags.length; i++) {
+        const input_attributeTags_item = input_attributeTags[i];
+        let input_attributeTags_item_id = input_attributeTags_id + '__' + i;
+        input_attributeTags[i] = ingest$4(input_attributeTags_item, {
+            fullPath: input_attributeTags_item_id,
+            propertyName: i,
+            parent: {
+                data: input,
+                key: path.fullPath,
+                existing: existing,
+            },
+            ttl: path.ttl
+        }, luvio, store);
+    }
+    return input;
+}
+const select$f = function ContextAttributeRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$3,
+        private: [],
+        selections: [
+            {
+                name: 'attributeTags',
+                kind: 'Link',
+                plural: true,
+                fragment: select$g()
+            },
+            {
+                name: 'contextAttributeId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'dataType',
+                kind: 'Scalar'
+            },
+            {
+                name: 'fieldType',
+                kind: 'Scalar'
+            },
+            {
+                name: 'isFinal',
+                kind: 'Scalar'
+            },
+            {
+                name: 'isKey',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'isSuccess',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'isValue',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'name',
+                kind: 'Scalar'
+            },
+            {
+                name: 'parentNodeId',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$3(existing, incoming) {
+    const existing_isFinal = existing.isFinal;
+    const incoming_isFinal = incoming.isFinal;
+    if (!(existing_isFinal === incoming_isFinal)) {
+        return false;
+    }
+    const existing_isKey = existing.isKey;
+    const incoming_isKey = incoming.isKey;
+    // if at least one of these optionals is defined
+    if (existing_isKey !== undefined || incoming_isKey !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_isKey === undefined || incoming_isKey === undefined) {
+            return false;
+        }
+        if (!(existing_isKey === incoming_isKey)) {
+            return false;
+        }
+    }
+    const existing_isSuccess = existing.isSuccess;
+    const incoming_isSuccess = incoming.isSuccess;
+    // if at least one of these optionals is defined
+    if (existing_isSuccess !== undefined || incoming_isSuccess !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_isSuccess === undefined || incoming_isSuccess === undefined) {
+            return false;
+        }
+        if (!(existing_isSuccess === incoming_isSuccess)) {
+            return false;
+        }
+    }
+    const existing_isValue = existing.isValue;
+    const incoming_isValue = incoming.isValue;
+    // if at least one of these optionals is defined
+    if (existing_isValue !== undefined || incoming_isValue !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_isValue === undefined || incoming_isValue === undefined) {
+            return false;
+        }
+        if (!(existing_isValue === incoming_isValue)) {
+            return false;
+        }
+    }
+    const existing_contextAttributeId = existing.contextAttributeId;
+    const incoming_contextAttributeId = incoming.contextAttributeId;
+    if (!(existing_contextAttributeId === incoming_contextAttributeId)) {
+        return false;
+    }
+    const existing_dataType = existing.dataType;
+    const incoming_dataType = incoming.dataType;
+    if (!(existing_dataType === incoming_dataType)) {
+        return false;
+    }
+    const existing_fieldType = existing.fieldType;
+    const incoming_fieldType = incoming.fieldType;
+    if (!(existing_fieldType === incoming_fieldType)) {
+        return false;
+    }
+    const existing_name = existing.name;
+    const incoming_name = incoming.name;
+    if (!(existing_name === incoming_name)) {
+        return false;
+    }
+    const existing_parentNodeId = existing.parentNodeId;
+    const incoming_parentNodeId = incoming.parentNodeId;
+    if (!(existing_parentNodeId === incoming_parentNodeId)) {
+        return false;
+    }
+    const existing_attributeTags = existing.attributeTags;
+    const incoming_attributeTags = incoming.attributeTags;
+    const equals_attributeTags_items = equalsArray(existing_attributeTags, incoming_attributeTags, (existing_attributeTags_item, incoming_attributeTags_item) => {
+        if (!(existing_attributeTags_item.__ref === incoming_attributeTags_item.__ref)) {
+            return false;
+        }
+    });
+    if (equals_attributeTags_items === false) {
+        return false;
+    }
+    return true;
+}
+function deepFreeze$6(input) {
+    const input_attributeTags = input.attributeTags;
+    for (let i = 0; i < input_attributeTags.length; i++) {
+        const input_attributeTags_item = input_attributeTags[i];
+        deepFreeze$7(input_attributeTags_item);
+    }
+    ObjectFreeze(input_attributeTags);
+    ObjectFreeze(input);
+}
+const ingest$3 = function ContextAttributeRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$9(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$3(luvio, input);
+    const existingRecord = store.readEntry(key);
+    const ttlToUse = TTL$3;
+    let incomingRecord = normalize$3(input, store.readEntry(key), {
+        fullPath: key,
+        parent: path.parent,
+        propertyName: path.propertyName,
+        ttl: ttlToUse
+    }, luvio, store);
+    if (existingRecord === undefined || equals$3(existingRecord, incomingRecord) === false) {
+        luvio.storePublish(key, incomingRecord);
+    }
+    {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "IndustriesContext",
+            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 = keyBuilderFromType$3(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$3,
+        mergeable: false
+    });
+    const input_attributeTags_length = input.attributeTags.length;
+    for (let i = 0; i < input_attributeTags_length; i++) {
+        rootKeySet.merge(getTypeCacheKeys$4(luvio, input.attributeTags[i]));
+    }
+    return rootKeySet;
+}
+
+function select$e(luvio, params) {
+    return select$f();
+}
+function getResponseCacheKeys$f(luvio, resourceParams, response) {
+    return getTypeCacheKeys$3(luvio, response);
+}
+function ingestSuccess$b(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$3(luvio, body);
+    luvio.storeIngest(key, ingest$3, 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$f(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/contextdefinition/attributenode',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const createContextAttribute_ConfigPropertyNames = {
+    displayName: 'createContextAttribute',
+    parameters: {
+        required: ['contextAttributeInput'],
+        optional: []
+    }
+};
+function createResourceParams$f(config) {
+    const resourceParams = {
+        body: {
+            contextAttributeInput: config.contextAttributeInput
+        }
+    };
+    return resourceParams;
+}
+function typeCheckConfig$f(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contextAttributeInput = untrustedConfig.contextAttributeInput;
+    const referenceContextAttributeInputRepresentationValidationError = validate$b(untrustedConfig_contextAttributeInput);
+    if (referenceContextAttributeInputRepresentationValidationError === null) {
+        config.contextAttributeInput = untrustedConfig_contextAttributeInput;
+    }
+    return config;
+}
+function validateAdapterConfig$f(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$f(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$f(luvio, config, options) {
+    const resourceParams = createResourceParams$f(config);
+    const request = createResourceRequest$f(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$b(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => getResponseCacheKeys$f(luvio, resourceParams, response.body));
+    }, (response) => {
+        deepFreeze$8(response);
+        throw response;
+    });
+}
+const createContextAttributeAdapterFactory = (luvio) => {
+    return function createContextAttribute(untrustedConfig) {
+        const config = validateAdapterConfig$f(untrustedConfig, createContextAttribute_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "createContextAttribute"');
+        }
+        return buildNetworkSnapshot$f(luvio, config);
+    };
+};
+
+function keyBuilder$g(luvio, params) {
+    return keyBuilder$h(luvio, {
+        id: params.urlParams.contextAttributeId
+    });
+}
+function getResponseCacheKeys$e(luvio, resourceParams) {
+    const key = keyBuilder$g(luvio, resourceParams);
+    const cacheKeyMap = new StoreKeyMap();
+    cacheKeyMap.set(key, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$3,
+        mergeable: false
+    });
+    return cacheKeyMap;
+}
+function evictSuccess$3(luvio, resourceParams) {
+    const key = keyBuilder$g(luvio, resourceParams);
+    luvio.storeEvict(key);
+}
+function createResourceRequest$e(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/contextdefinition/attributenode/' + config.urlParams.contextAttributeId + '',
+        method: 'delete',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$3 = 'deleteContextAttribute';
+const deleteContextAttribute_ConfigPropertyNames = {
+    displayName: 'deleteContextAttribute',
+    parameters: {
+        required: ['contextAttributeId'],
+        optional: []
+    }
+};
+function createResourceParams$e(config) {
+    const resourceParams = {
+        urlParams: {
+            contextAttributeId: config.contextAttributeId
+        }
+    };
+    return resourceParams;
+}
+function typeCheckConfig$e(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contextAttributeId = untrustedConfig.contextAttributeId;
+    if (typeof untrustedConfig_contextAttributeId === 'string') {
+        config.contextAttributeId = untrustedConfig_contextAttributeId;
+    }
+    return config;
+}
+function validateAdapterConfig$e(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$e(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$e(luvio, config, options) {
+    const resourceParams = createResourceParams$e(config);
+    const request = createResourceRequest$e(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then(() => {
+        return luvio.handleSuccessResponse(() => {
+            evictSuccess$3(luvio, resourceParams);
+            return luvio.storeBroadcast();
+        }, () => getResponseCacheKeys$e(luvio, resourceParams));
+    }, (response) => {
+        deepFreeze$8(response);
+        throw response;
+    });
+}
+const deleteContextAttributeAdapterFactory = (luvio) => {
+    return function IndustriesContextdeleteContextAttribute(untrustedConfig) {
+        const config = validateAdapterConfig$e(untrustedConfig, deleteContextAttribute_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error(`Invalid config for "${adapterName$3}"`);
+        }
+        return buildNetworkSnapshot$e(luvio, config);
+    };
+};
+
+function select$d(luvio, params) {
+    return select$f();
+}
+function keyBuilder$f(luvio, params) {
+    return keyBuilder$h(luvio, {
+        id: params.urlParams.contextAttributeId
+    });
+}
+function getResponseCacheKeys$d(luvio, resourceParams, response) {
+    return getTypeCacheKeys$3(luvio, response);
+}
+function ingestSuccess$a(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$f(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$3, 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$f(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    const storeMetadataParams = {
+        ttl: TTL$3,
+        namespace: keyPrefix,
+        version: VERSION$3,
+        representationName: RepresentationType$3
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
+function createResourceRequest$d(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/contextdefinition/attributenode/' + config.urlParams.contextAttributeId + '',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const getContextAttribute_ConfigPropertyNames = {
+    displayName: 'getContextAttribute',
+    parameters: {
+        required: ['contextAttributeId'],
+        optional: []
+    }
+};
+function createResourceParams$d(config) {
+    const resourceParams = {
+        urlParams: {
+            contextAttributeId: config.contextAttributeId
+        }
+    };
+    return resourceParams;
+}
+function keyBuilder$e(luvio, config) {
+    const resourceParams = createResourceParams$d(config);
+    return keyBuilder$f(luvio, resourceParams);
+}
+function typeCheckConfig$d(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contextAttributeId = untrustedConfig.contextAttributeId;
+    if (typeof untrustedConfig_contextAttributeId === 'string') {
+        config.contextAttributeId = untrustedConfig_contextAttributeId;
+    }
+    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 adapterFragment$4(luvio, config) {
+    createResourceParams$d(config);
+    return select$d();
+}
+function onFetchResponseSuccess$4(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$a(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$d(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$d(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+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(() => onFetchResponseSuccess$4(luvio, config, resourceParams, response), () => getResponseCacheKeys$d(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$d(luvio, config, dispatchOptions);
+}
+function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$e(luvio, config),
+        node: adapterFragment$4(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$d(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getContextAttributeAdapterFactory = (luvio) => function IndustriesContext__getContextAttribute(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$d(untrustedConfig, getContextAttribute_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$4, buildNetworkSnapshotCachePolicy$4);
+};
+
+function select$c(luvio, params) {
+    return select$f();
+}
+function getResponseCacheKeys$c(luvio, resourceParams, response) {
+    return getTypeCacheKeys$3(luvio, response);
+}
+function ingestSuccess$9(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$3(luvio, body);
+    luvio.storeIngest(key, ingest$3, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$c(),
+        variables: {},
+    });
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    return snapshot;
+}
+function createResourceRequest$c(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/contextdefinition/attributenode/' + config.urlParams.contextAttributeId + '',
+        method: 'patch',
+        body: config.body,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const updateContextAttribute_ConfigPropertyNames = {
+    displayName: 'updateContextAttribute',
+    parameters: {
+        required: ['contextAttributeId', 'contextAttributeInput'],
+        optional: []
+    }
+};
+function createResourceParams$c(config) {
+    const resourceParams = {
+        urlParams: {
+            contextAttributeId: config.contextAttributeId
+        },
+        body: {
+            contextAttributeInput: config.contextAttributeInput
+        }
+    };
+    return resourceParams;
+}
+function typeCheckConfig$c(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contextAttributeId = untrustedConfig.contextAttributeId;
+    if (typeof untrustedConfig_contextAttributeId === 'string') {
+        config.contextAttributeId = untrustedConfig_contextAttributeId;
+    }
+    const untrustedConfig_contextAttributeInput = untrustedConfig.contextAttributeInput;
+    const referenceContextAttributeInputRepresentationValidationError = validate$b(untrustedConfig_contextAttributeInput);
+    if (referenceContextAttributeInputRepresentationValidationError === null) {
+        config.contextAttributeInput = untrustedConfig_contextAttributeInput;
+    }
+    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$9(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => getResponseCacheKeys$c(luvio, resourceParams, response.body));
+    }, (response) => {
+        deepFreeze$8(response);
+        throw response;
+    });
+}
+const updateContextAttributeAdapterFactory = (luvio) => {
+    return function updateContextAttribute(untrustedConfig) {
+        const config = validateAdapterConfig$c(untrustedConfig, updateContextAttribute_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "updateContextAttribute"');
+        }
+        return buildNetworkSnapshot$c(luvio, config);
+    };
+};
+
+function select$b(luvio, params) {
+    return select$k();
+}
+function keyBuilder$d(luvio, params) {
+    return keyBuilder$l(luvio, {
+        id: params.urlParams.contextDefinitionId
+    });
+}
+function getResponseCacheKeys$b(luvio, resourceParams, response) {
+    return getTypeCacheKeys$6(luvio, response);
+}
+function ingestSuccess$8(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$d(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$6, 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$d(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    const storeMetadataParams = {
+        ttl: TTL$6,
+        namespace: keyPrefix,
+        version: VERSION$6,
+        representationName: RepresentationType$6
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
+function createResourceRequest$b(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/contextdefinition/info/' + config.urlParams.contextDefinitionId + '',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const getContextDefinitionInfo_ConfigPropertyNames = {
+    displayName: 'getContextDefinitionInfo',
+    parameters: {
+        required: ['contextDefinitionId'],
+        optional: []
+    }
+};
+function createResourceParams$b(config) {
+    const resourceParams = {
+        urlParams: {
+            contextDefinitionId: config.contextDefinitionId
+        }
+    };
+    return resourceParams;
+}
+function keyBuilder$c(luvio, config) {
+    const resourceParams = createResourceParams$b(config);
+    return keyBuilder$d(luvio, resourceParams);
+}
+function typeCheckConfig$b(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contextDefinitionId = untrustedConfig.contextDefinitionId;
+    if (typeof untrustedConfig_contextDefinitionId === 'string') {
+        config.contextDefinitionId = untrustedConfig_contextDefinitionId;
+    }
+    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 adapterFragment$3(luvio, config) {
+    createResourceParams$b(config);
+    return select$b();
+}
+function onFetchResponseSuccess$3(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$8(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$b(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$b(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+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(() => onFetchResponseSuccess$3(luvio, config, resourceParams, response), () => getResponseCacheKeys$b(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$b(luvio, config, dispatchOptions);
+}
+function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$c(luvio, config),
+        node: adapterFragment$3(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$b(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getContextDefinitionInfoAdapterFactory = (luvio) => function IndustriesContext__getContextDefinitionInfo(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$b(untrustedConfig, getContextDefinitionInfo_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$3, buildNetworkSnapshotCachePolicy$3);
+};
+
+function validate$8(obj, path = 'ContextNodeInputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.attributes !== undefined) {
+            const obj_attributes = obj.attributes;
+            const path_attributes = path + '.attributes';
+            if (!ArrayIsArray(obj_attributes)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_attributes + '" (at "' + path_attributes + '")');
+            }
+            for (let i = 0; i < obj_attributes.length; i++) {
+                const obj_attributes_item = obj_attributes[i];
+                const path_attributes_item = path_attributes + '[' + i + ']';
+                if (typeof obj_attributes_item !== 'object' || ArrayIsArray(obj_attributes_item) || obj_attributes_item === null) {
+                    return new TypeError('Expected "object" but received "' + typeof obj_attributes_item + '" (at "' + path_attributes_item + '")');
+                }
+            }
+        }
+        if (obj.childNodes !== undefined) {
+            const obj_childNodes = obj.childNodes;
+            const path_childNodes = path + '.childNodes';
+            if (!ArrayIsArray(obj_childNodes)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_childNodes + '" (at "' + path_childNodes + '")');
+            }
+            for (let i = 0; i < obj_childNodes.length; i++) {
+                const obj_childNodes_item = obj_childNodes[i];
+                const path_childNodes_item = path_childNodes + '[' + i + ']';
+                if (typeof obj_childNodes_item !== 'object' || ArrayIsArray(obj_childNodes_item) || obj_childNodes_item === null) {
+                    return new TypeError('Expected "object" but received "' + typeof obj_childNodes_item + '" (at "' + path_childNodes_item + '")');
+                }
+            }
+        }
+        const obj_contextDefinitionVersionId = obj.contextDefinitionVersionId;
+        const path_contextDefinitionVersionId = path + '.contextDefinitionVersionId';
+        if (typeof obj_contextDefinitionVersionId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contextDefinitionVersionId + '" (at "' + path_contextDefinitionVersionId + '")');
+        }
+        if (obj.isTransposable !== undefined) {
+            const obj_isTransposable = obj.isTransposable;
+            const path_isTransposable = path + '.isTransposable';
+            if (typeof obj_isTransposable !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isTransposable + '" (at "' + path_isTransposable + '")');
+            }
+        }
+        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.parentNodeId !== undefined) {
+            const obj_parentNodeId = obj.parentNodeId;
+            const path_parentNodeId = path + '.parentNodeId';
+            if (typeof obj_parentNodeId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_parentNodeId + '" (at "' + path_parentNodeId + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+const TTL$2 = 30000;
+const VERSION$2 = "c2d43b78f118eaf92b53cec62f704b4b";
+function validate$7(obj, path = 'ContextNodeRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_attributes = obj.attributes;
+        const path_attributes = path + '.attributes';
+        if (!ArrayIsArray(obj_attributes)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_attributes + '" (at "' + path_attributes + '")');
+        }
+        for (let i = 0; i < obj_attributes.length; i++) {
+            const obj_attributes_item = obj_attributes[i];
+            const path_attributes_item = path_attributes + '[' + i + ']';
+            const referencepath_attributes_itemValidationError = validate$9(obj_attributes_item, path_attributes_item);
+            if (referencepath_attributes_itemValidationError !== null) {
+                let message = 'Object doesn\'t match ContextAttributeRepresentation (at "' + path_attributes_item + '")\n';
+                message += referencepath_attributes_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_childNodes = obj.childNodes;
+        const path_childNodes = path + '.childNodes';
+        if (!ArrayIsArray(obj_childNodes)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_childNodes + '" (at "' + path_childNodes + '")');
+        }
+        for (let i = 0; i < obj_childNodes.length; i++) {
+            const obj_childNodes_item = obj_childNodes[i];
+            const path_childNodes_item = path_childNodes + '[' + i + ']';
+            const referencepath_childNodes_itemValidationError = validate$7(obj_childNodes_item, path_childNodes_item);
+            if (referencepath_childNodes_itemValidationError !== null) {
+                let message = 'Object doesn\'t match ContextNodeRepresentation (at "' + path_childNodes_item + '")\n';
+                message += referencepath_childNodes_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_contextDefinitionVersionId = obj.contextDefinitionVersionId;
+        const path_contextDefinitionVersionId = path + '.contextDefinitionVersionId';
+        if (typeof obj_contextDefinitionVersionId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contextDefinitionVersionId + '" (at "' + path_contextDefinitionVersionId + '")');
+        }
+        const obj_contextNodeId = obj.contextNodeId;
+        const path_contextNodeId = path + '.contextNodeId';
+        if (typeof obj_contextNodeId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contextNodeId + '" (at "' + path_contextNodeId + '")');
+        }
+        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 + '")');
+            }
+        }
+        if (obj.isTransposable !== undefined) {
+            const obj_isTransposable = obj.isTransposable;
+            const path_isTransposable = path + '.isTransposable';
+            if (typeof obj_isTransposable !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isTransposable + '" (at "' + path_isTransposable + '")');
+            }
+        }
+        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.parentNodeId !== undefined) {
+            const obj_parentNodeId = obj.parentNodeId;
+            const path_parentNodeId = path + '.parentNodeId';
+            if (typeof obj_parentNodeId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_parentNodeId + '" (at "' + path_parentNodeId + '")');
+            }
+        }
+        const obj_tags = obj.tags;
+        const path_tags = path + '.tags';
+        if (!ArrayIsArray(obj_tags)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_tags + '" (at "' + path_tags + '")');
+        }
+        for (let i = 0; i < obj_tags.length; i++) {
+            const obj_tags_item = obj_tags[i];
+            const path_tags_item = path_tags + '[' + i + ']';
+            const referencepath_tags_itemValidationError = validate$a(obj_tags_item, path_tags_item);
+            if (referencepath_tags_itemValidationError !== null) {
+                let message = 'Object doesn\'t match ContextAttributeTagRepresentation (at "' + path_tags_item + '")\n';
+                message += referencepath_tags_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$2 = 'ContextNodeRepresentation';
+function keyBuilder$b(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$2 + ':' + config.id;
+}
+function keyBuilderFromType$2(luvio, object) {
+    const keyParams = {
+        id: object.contextNodeId
+    };
+    return keyBuilder$b(luvio, keyParams);
+}
+function normalize$2(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$a = function ContextNodeRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$2,
+        private: [],
+        opaque: true
+    };
+};
+function equals$2(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
+function deepFreeze$5(input) {
+    const input_attributes = input.attributes;
+    for (let i = 0; i < input_attributes.length; i++) {
+        const input_attributes_item = input_attributes[i];
+        deepFreeze$6(input_attributes_item);
+    }
+    ObjectFreeze(input_attributes);
+    const input_childNodes = input.childNodes;
+    for (let i = 0; i < input_childNodes.length; i++) {
+        const input_childNodes_item = input_childNodes[i];
+        deepFreeze$5(input_childNodes_item);
+    }
+    ObjectFreeze(input_childNodes);
+    const input_tags = input.tags;
+    for (let i = 0; i < input_tags.length; i++) {
+        const input_tags_item = input_tags[i];
+        deepFreeze$7(input_tags_item);
+    }
+    ObjectFreeze(input_tags);
+    ObjectFreeze(input);
+}
+const ingest$2 = function ContextNodeRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$7(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$2(luvio, input);
+    const existingRecord = store.readEntry(key);
+    const ttlToUse = TTL$2;
+    let incomingRecord = normalize$2(input, store.readEntry(key), {
+        fullPath: key,
+        parent: path.parent,
+        propertyName: path.propertyName,
+        ttl: ttlToUse
+    });
+    deepFreeze$5(input);
+    if (existingRecord === undefined || equals$2(existingRecord, incomingRecord) === false) {
+        luvio.storePublish(key, incomingRecord);
+    }
+    {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "IndustriesContext",
+            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 = keyBuilderFromType$2(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$2,
+        mergeable: false
+    });
+    return rootKeySet;
+}
+
+function select$9(luvio, params) {
+    return select$a();
+}
+function getResponseCacheKeys$a(luvio, resourceParams, response) {
+    return getTypeCacheKeys$2(luvio, response);
+}
+function ingestSuccess$7(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$2(luvio, body);
+    luvio.storeIngest(key, ingest$2, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$9(),
+        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$a(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/contextdefinition/node',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const createContextNode_ConfigPropertyNames = {
+    displayName: 'createContextNode',
+    parameters: {
+        required: ['contextNodeInput'],
+        optional: []
+    }
+};
+function createResourceParams$a(config) {
+    const resourceParams = {
+        body: {
+            contextNodeInput: config.contextNodeInput
+        }
+    };
+    return resourceParams;
+}
+function typeCheckConfig$a(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contextNodeInput = untrustedConfig.contextNodeInput;
+    const referenceContextNodeInputRepresentationValidationError = validate$8(untrustedConfig_contextNodeInput);
+    if (referenceContextNodeInputRepresentationValidationError === null) {
+        config.contextNodeInput = untrustedConfig_contextNodeInput;
+    }
+    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((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$7(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => getResponseCacheKeys$a(luvio, resourceParams, response.body));
+    }, (response) => {
+        deepFreeze$8(response);
+        throw response;
+    });
+}
+const createContextNodeAdapterFactory = (luvio) => {
+    return function createContextNode(untrustedConfig) {
+        const config = validateAdapterConfig$a(untrustedConfig, createContextNode_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "createContextNode"');
+        }
+        return buildNetworkSnapshot$a(luvio, config);
+    };
+};
+
+function keyBuilder$a(luvio, params) {
+    return keyBuilder$b(luvio, {
+        id: params.urlParams.contextNodeId
+    });
+}
+function getResponseCacheKeys$9(luvio, resourceParams) {
+    const key = keyBuilder$a(luvio, resourceParams);
+    const cacheKeyMap = new StoreKeyMap();
+    cacheKeyMap.set(key, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$2,
+        mergeable: false
+    });
+    return cacheKeyMap;
+}
+function evictSuccess$2(luvio, resourceParams) {
+    const key = keyBuilder$a(luvio, resourceParams);
+    luvio.storeEvict(key);
+}
+function createResourceRequest$9(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/contextdefinition/node/' + config.urlParams.contextNodeId + '',
+        method: 'delete',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$2 = 'deleteContextNode';
+const deleteContextNode_ConfigPropertyNames = {
+    displayName: 'deleteContextNode',
+    parameters: {
+        required: ['contextNodeId'],
+        optional: []
+    }
+};
+function createResourceParams$9(config) {
+    const resourceParams = {
+        urlParams: {
+            contextNodeId: config.contextNodeId
+        }
+    };
+    return resourceParams;
+}
+function typeCheckConfig$9(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contextNodeId = untrustedConfig.contextNodeId;
+    if (typeof untrustedConfig_contextNodeId === 'string') {
+        config.contextNodeId = untrustedConfig_contextNodeId;
+    }
+    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(() => {
+        return luvio.handleSuccessResponse(() => {
+            evictSuccess$2(luvio, resourceParams);
+            return luvio.storeBroadcast();
+        }, () => getResponseCacheKeys$9(luvio, resourceParams));
+    }, (response) => {
+        deepFreeze$8(response);
+        throw response;
+    });
+}
+const deleteContextNodeAdapterFactory = (luvio) => {
+    return function IndustriesContextdeleteContextNode(untrustedConfig) {
+        const config = validateAdapterConfig$9(untrustedConfig, deleteContextNode_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error(`Invalid config for "${adapterName$2}"`);
+        }
+        return buildNetworkSnapshot$9(luvio, config);
+    };
+};
+
+function select$8(luvio, params) {
+    return select$a();
+}
+function keyBuilder$9(luvio, params) {
+    return keyBuilder$b(luvio, {
+        id: params.urlParams.contextNodeId
+    });
+}
+function getResponseCacheKeys$8(luvio, resourceParams, response) {
+    return getTypeCacheKeys$2(luvio, response);
+}
+function ingestSuccess$6(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$9(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$2, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$8(),
+        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$9(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    const storeMetadataParams = {
+        ttl: TTL$2,
+        namespace: keyPrefix,
+        version: VERSION$2,
+        representationName: RepresentationType$2
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
+function createResourceRequest$8(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/contextdefinition/node/' + config.urlParams.contextNodeId + '',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const getContextNode_ConfigPropertyNames = {
+    displayName: 'getContextNode',
+    parameters: {
+        required: ['contextNodeId'],
+        optional: []
+    }
+};
+function createResourceParams$8(config) {
+    const resourceParams = {
+        urlParams: {
+            contextNodeId: config.contextNodeId
+        }
+    };
+    return resourceParams;
+}
+function keyBuilder$8(luvio, config) {
+    const resourceParams = createResourceParams$8(config);
+    return keyBuilder$9(luvio, resourceParams);
+}
+function typeCheckConfig$8(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contextNodeId = untrustedConfig.contextNodeId;
+    if (typeof untrustedConfig_contextNodeId === 'string') {
+        config.contextNodeId = untrustedConfig_contextNodeId;
+    }
+    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$2(luvio, config) {
+    createResourceParams$8(config);
+    return select$8();
+}
+function onFetchResponseSuccess$2(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$6(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$8(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$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$2(luvio, config, resourceParams, response), () => getResponseCacheKeys$8(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$8(luvio, config, dispatchOptions);
+}
+function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$8(luvio, config),
+        node: adapterFragment$2(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getContextNodeAdapterFactory = (luvio) => function IndustriesContext__getContextNode(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$8(untrustedConfig, getContextNode_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$2, buildNetworkSnapshotCachePolicy$2);
+};
+
+function select$7(luvio, params) {
+    return select$a();
+}
+function getResponseCacheKeys$7(luvio, resourceParams, response) {
+    return getTypeCacheKeys$2(luvio, response);
+}
+function ingestSuccess$5(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$2(luvio, body);
+    luvio.storeIngest(key, ingest$2, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$7(),
+        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$7(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/contextdefinition/node/' + config.urlParams.contextNodeId + '',
+        method: 'patch',
+        body: config.body,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const updateContextNode_ConfigPropertyNames = {
+    displayName: 'updateContextNode',
+    parameters: {
+        required: ['contextNodeId', 'contextNodeInput'],
+        optional: []
+    }
+};
+function createResourceParams$7(config) {
+    const resourceParams = {
+        urlParams: {
+            contextNodeId: config.contextNodeId
+        },
+        body: {
+            contextNodeInput: config.contextNodeInput
+        }
+    };
+    return resourceParams;
+}
+function typeCheckConfig$7(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contextNodeId = untrustedConfig.contextNodeId;
+    if (typeof untrustedConfig_contextNodeId === 'string') {
+        config.contextNodeId = untrustedConfig_contextNodeId;
+    }
+    const untrustedConfig_contextNodeInput = untrustedConfig.contextNodeInput;
+    const referenceContextNodeInputRepresentationValidationError = validate$8(untrustedConfig_contextNodeInput);
+    if (referenceContextNodeInputRepresentationValidationError === null) {
+        config.contextNodeInput = untrustedConfig_contextNodeInput;
+    }
+    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 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(() => {
+            const snapshot = ingestSuccess$5(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => getResponseCacheKeys$7(luvio, resourceParams, response.body));
+    }, (response) => {
+        deepFreeze$8(response);
+        throw response;
+    });
+}
+const updateContextNodeAdapterFactory = (luvio) => {
+    return function updateContextNode(untrustedConfig) {
+        const config = validateAdapterConfig$7(untrustedConfig, updateContextNode_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "updateContextNode"');
+        }
+        return buildNetworkSnapshot$7(luvio, config);
+    };
+};
+
+function validate$6(obj, path = 'ContextDefinitionVersionInputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_contextDefinitionId = obj.contextDefinitionId;
+        const path_contextDefinitionId = path + '.contextDefinitionId';
+        if (typeof obj_contextDefinitionId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contextDefinitionId + '" (at "' + path_contextDefinitionId + '")');
+        }
+        if (obj.contextMappings !== undefined) {
+            const obj_contextMappings = obj.contextMappings;
+            const path_contextMappings = path + '.contextMappings';
+            if (!ArrayIsArray(obj_contextMappings)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_contextMappings + '" (at "' + path_contextMappings + '")');
+            }
+            for (let i = 0; i < obj_contextMappings.length; i++) {
+                const obj_contextMappings_item = obj_contextMappings[i];
+                const path_contextMappings_item = path_contextMappings + '[' + i + ']';
+                if (typeof obj_contextMappings_item !== 'object' || ArrayIsArray(obj_contextMappings_item) || obj_contextMappings_item === null) {
+                    return new TypeError('Expected "object" but received "' + typeof obj_contextMappings_item + '" (at "' + path_contextMappings_item + '")');
+                }
+            }
+        }
+        if (obj.contextNodes !== undefined) {
+            const obj_contextNodes = obj.contextNodes;
+            const path_contextNodes = path + '.contextNodes';
+            if (!ArrayIsArray(obj_contextNodes)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_contextNodes + '" (at "' + path_contextNodes + '")');
+            }
+            for (let i = 0; i < obj_contextNodes.length; i++) {
+                const obj_contextNodes_item = obj_contextNodes[i];
+                const path_contextNodes_item = path_contextNodes + '[' + i + ']';
+                if (typeof obj_contextNodes_item !== 'object' || ArrayIsArray(obj_contextNodes_item) || obj_contextNodes_item === null) {
+                    return new TypeError('Expected "object" but received "' + typeof obj_contextNodes_item + '" (at "' + path_contextNodes_item + '")');
+                }
+            }
+        }
+        if (obj.definition !== undefined) {
+            const obj_definition = obj.definition;
+            const path_definition = path + '.definition';
+            if (typeof obj_definition !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_definition + '" (at "' + path_definition + '")');
+            }
+        }
+        if (obj.description !== undefined) {
+            const obj_description = obj.description;
+            const path_description = path + '.description';
+            if (typeof obj_description !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_description + '" (at "' + path_description + '")');
+            }
+        }
+        if (obj.endDate !== undefined) {
+            const obj_endDate = obj.endDate;
+            const path_endDate = path + '.endDate';
+            if (typeof obj_endDate !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_endDate + '" (at "' + path_endDate + '")');
+            }
+        }
+        if (obj.isActive !== undefined) {
+            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 + '")');
+            }
+        }
+        if (obj.startDate !== undefined) {
+            const obj_startDate = obj.startDate;
+            const path_startDate = path + '.startDate';
+            if (typeof obj_startDate !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_startDate + '" (at "' + path_startDate + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$5(obj, path = 'ContextAttrHydrationDetailRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_contextAttrHydrationDetailId = obj.contextAttrHydrationDetailId;
+        const path_contextAttrHydrationDetailId = path + '.contextAttrHydrationDetailId';
+        if (typeof obj_contextAttrHydrationDetailId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contextAttrHydrationDetailId + '" (at "' + path_contextAttrHydrationDetailId + '")');
+        }
+        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 + '")');
+        }
+        const obj_parentDetails = obj.parentDetails;
+        const path_parentDetails = path + '.parentDetails';
+        if (!ArrayIsArray(obj_parentDetails)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_parentDetails + '" (at "' + path_parentDetails + '")');
+        }
+        for (let i = 0; i < obj_parentDetails.length; i++) {
+            const obj_parentDetails_item = obj_parentDetails[i];
+            const path_parentDetails_item = path_parentDetails + '[' + i + ']';
+            const referencepath_parentDetails_itemValidationError = validate$5(obj_parentDetails_item, path_parentDetails_item);
+            if (referencepath_parentDetails_itemValidationError !== null) {
+                let message = 'Object doesn\'t match ContextAttrHydrationDetailRepresentation (at "' + path_parentDetails_item + '")\n';
+                message += referencepath_parentDetails_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_parentMappingAttributeId = obj.parentMappingAttributeId;
+        const path_parentMappingAttributeId = path + '.parentMappingAttributeId';
+        if (typeof obj_parentMappingAttributeId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_parentMappingAttributeId + '" (at "' + path_parentMappingAttributeId + '")');
+        }
+        const obj_queryAttribute = obj.queryAttribute;
+        const path_queryAttribute = path + '.queryAttribute';
+        if (typeof obj_queryAttribute !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_queryAttribute + '" (at "' + path_queryAttribute + '")');
+        }
+        const obj_sObjectDomain = obj.sObjectDomain;
+        const path_sObjectDomain = path + '.sObjectDomain';
+        if (typeof obj_sObjectDomain !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_sObjectDomain + '" (at "' + path_sObjectDomain + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+function deepFreeze$4(input) {
+    const input_parentDetails = input.parentDetails;
+    for (let i = 0; i < input_parentDetails.length; i++) {
+        const input_parentDetails_item = input_parentDetails[i];
+        deepFreeze$4(input_parentDetails_item);
+    }
+    ObjectFreeze(input_parentDetails);
+    ObjectFreeze(input);
+}
+
+function validate$4(obj, path = 'ContextAttributeMappingRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_contextAttrHydrationDetailList = obj.contextAttrHydrationDetailList;
+        const path_contextAttrHydrationDetailList = path + '.contextAttrHydrationDetailList';
+        if (!ArrayIsArray(obj_contextAttrHydrationDetailList)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_contextAttrHydrationDetailList + '" (at "' + path_contextAttrHydrationDetailList + '")');
+        }
+        for (let i = 0; i < obj_contextAttrHydrationDetailList.length; i++) {
+            const obj_contextAttrHydrationDetailList_item = obj_contextAttrHydrationDetailList[i];
+            const path_contextAttrHydrationDetailList_item = path_contextAttrHydrationDetailList + '[' + i + ']';
+            const referencepath_contextAttrHydrationDetailList_itemValidationError = validate$5(obj_contextAttrHydrationDetailList_item, path_contextAttrHydrationDetailList_item);
+            if (referencepath_contextAttrHydrationDetailList_itemValidationError !== null) {
+                let message = 'Object doesn\'t match ContextAttrHydrationDetailRepresentation (at "' + path_contextAttrHydrationDetailList_item + '")\n';
+                message += referencepath_contextAttrHydrationDetailList_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_contextAttributeId = obj.contextAttributeId;
+        const path_contextAttributeId = path + '.contextAttributeId';
+        if (typeof obj_contextAttributeId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contextAttributeId + '" (at "' + path_contextAttributeId + '")');
+        }
+        const obj_contextAttributeMappingId = obj.contextAttributeMappingId;
+        const path_contextAttributeMappingId = path + '.contextAttributeMappingId';
+        if (typeof obj_contextAttributeMappingId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contextAttributeMappingId + '" (at "' + path_contextAttributeMappingId + '")');
+        }
+        const obj_contextInputAttributeId = obj.contextInputAttributeId;
+        const path_contextInputAttributeId = path + '.contextInputAttributeId';
+        if (typeof obj_contextInputAttributeId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contextInputAttributeId + '" (at "' + path_contextInputAttributeId + '")');
+        }
+        const obj_hydrationSource = obj.hydrationSource;
+        const path_hydrationSource = path + '.hydrationSource';
+        if (typeof obj_hydrationSource !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_hydrationSource + '" (at "' + path_hydrationSource + '")');
+        }
+        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 + '")');
+        }
+        const obj_parentNodeMappingId = obj.parentNodeMappingId;
+        const path_parentNodeMappingId = path + '.parentNodeMappingId';
+        if (typeof obj_parentNodeMappingId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_parentNodeMappingId + '" (at "' + path_parentNodeMappingId + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+function deepFreeze$3(input) {
+    const input_contextAttrHydrationDetailList = input.contextAttrHydrationDetailList;
+    for (let i = 0; i < input_contextAttrHydrationDetailList.length; i++) {
+        const input_contextAttrHydrationDetailList_item = input_contextAttrHydrationDetailList[i];
+        deepFreeze$4(input_contextAttrHydrationDetailList_item);
+    }
+    ObjectFreeze(input_contextAttrHydrationDetailList);
+    ObjectFreeze(input);
+}
+
+function validate$3(obj, path = 'ContextNodeMappingRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_attributeMappings = obj.attributeMappings;
+        const path_attributeMappings = path + '.attributeMappings';
+        if (!ArrayIsArray(obj_attributeMappings)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_attributeMappings + '" (at "' + path_attributeMappings + '")');
+        }
+        for (let i = 0; i < obj_attributeMappings.length; i++) {
+            const obj_attributeMappings_item = obj_attributeMappings[i];
+            const path_attributeMappings_item = path_attributeMappings + '[' + i + ']';
+            const referencepath_attributeMappings_itemValidationError = validate$4(obj_attributeMappings_item, path_attributeMappings_item);
+            if (referencepath_attributeMappings_itemValidationError !== null) {
+                let message = 'Object doesn\'t match ContextAttributeMappingRepresentation (at "' + path_attributeMappings_item + '")\n';
+                message += referencepath_attributeMappings_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_businessObjectTypeId = obj.businessObjectTypeId;
+        const path_businessObjectTypeId = path + '.businessObjectTypeId';
+        if (typeof obj_businessObjectTypeId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_businessObjectTypeId + '" (at "' + path_businessObjectTypeId + '")');
+        }
+        const obj_contextInputNodeId = obj.contextInputNodeId;
+        const path_contextInputNodeId = path + '.contextInputNodeId';
+        if (typeof obj_contextInputNodeId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contextInputNodeId + '" (at "' + path_contextInputNodeId + '")');
+        }
+        const obj_contextMappingId = obj.contextMappingId;
+        const path_contextMappingId = path + '.contextMappingId';
+        if (typeof obj_contextMappingId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contextMappingId + '" (at "' + path_contextMappingId + '")');
+        }
+        const obj_contextNodeId = obj.contextNodeId;
+        const path_contextNodeId = path + '.contextNodeId';
+        if (typeof obj_contextNodeId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contextNodeId + '" (at "' + path_contextNodeId + '")');
+        }
+        const obj_contextNodeMappingId = obj.contextNodeMappingId;
+        const path_contextNodeMappingId = path + '.contextNodeMappingId';
+        if (typeof obj_contextNodeMappingId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contextNodeMappingId + '" (at "' + path_contextNodeMappingId + '")');
+        }
+        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 + '")');
+        }
+        const obj_sObjectName = obj.sObjectName;
+        const path_sObjectName = path + '.sObjectName';
+        if (typeof obj_sObjectName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_sObjectName + '" (at "' + path_sObjectName + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+function deepFreeze$2(input) {
+    const input_attributeMappings = input.attributeMappings;
+    for (let i = 0; i < input_attributeMappings.length; i++) {
+        const input_attributeMappings_item = input_attributeMappings[i];
+        deepFreeze$3(input_attributeMappings_item);
+    }
+    ObjectFreeze(input_attributeMappings);
+    ObjectFreeze(input);
+}
+
+function validate$2(obj, path = 'ContextMappingRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_contextDefinitionVersionId = obj.contextDefinitionVersionId;
+        const path_contextDefinitionVersionId = path + '.contextDefinitionVersionId';
+        if (typeof obj_contextDefinitionVersionId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contextDefinitionVersionId + '" (at "' + path_contextDefinitionVersionId + '")');
+        }
+        const obj_contextMappingId = obj.contextMappingId;
+        const path_contextMappingId = path + '.contextMappingId';
+        if (typeof obj_contextMappingId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contextMappingId + '" (at "' + path_contextMappingId + '")');
+        }
+        const obj_contextNodeMappings = obj.contextNodeMappings;
+        const path_contextNodeMappings = path + '.contextNodeMappings';
+        if (!ArrayIsArray(obj_contextNodeMappings)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_contextNodeMappings + '" (at "' + path_contextNodeMappings + '")');
+        }
+        for (let i = 0; i < obj_contextNodeMappings.length; i++) {
+            const obj_contextNodeMappings_item = obj_contextNodeMappings[i];
+            const path_contextNodeMappings_item = path_contextNodeMappings + '[' + i + ']';
+            const referencepath_contextNodeMappings_itemValidationError = validate$3(obj_contextNodeMappings_item, path_contextNodeMappings_item);
+            if (referencepath_contextNodeMappings_itemValidationError !== null) {
+                let message = 'Object doesn\'t match ContextNodeMappingRepresentation (at "' + path_contextNodeMappings_item + '")\n';
+                message += referencepath_contextNodeMappings_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_description = obj.description;
+        const path_description = path + '.description';
+        if (typeof obj_description !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_description + '" (at "' + path_description + '")');
+        }
+        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 + '")');
+        }
+        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 + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+function deepFreeze$1(input) {
+    const input_contextNodeMappings = input.contextNodeMappings;
+    for (let i = 0; i < input_contextNodeMappings.length; i++) {
+        const input_contextNodeMappings_item = input_contextNodeMappings[i];
+        deepFreeze$2(input_contextNodeMappings_item);
+    }
+    ObjectFreeze(input_contextNodeMappings);
+    ObjectFreeze(input);
+}
+
+const TTL$1 = 30000;
+const VERSION$1 = "83a62f2a41f46f52ba3d412d65504cd7";
+function validate$1(obj, path = 'ContextDefinitionVersionRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_contextDefinitionId = obj.contextDefinitionId;
+        const path_contextDefinitionId = path + '.contextDefinitionId';
+        if (typeof obj_contextDefinitionId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contextDefinitionId + '" (at "' + path_contextDefinitionId + '")');
+        }
+        const obj_contextDefinitionVersionId = obj.contextDefinitionVersionId;
+        const path_contextDefinitionVersionId = path + '.contextDefinitionVersionId';
+        if (typeof obj_contextDefinitionVersionId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contextDefinitionVersionId + '" (at "' + path_contextDefinitionVersionId + '")');
+        }
+        const obj_contextMappings = obj.contextMappings;
+        const path_contextMappings = path + '.contextMappings';
+        if (!ArrayIsArray(obj_contextMappings)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_contextMappings + '" (at "' + path_contextMappings + '")');
+        }
+        for (let i = 0; i < obj_contextMappings.length; i++) {
+            const obj_contextMappings_item = obj_contextMappings[i];
+            const path_contextMappings_item = path_contextMappings + '[' + i + ']';
+            const referencepath_contextMappings_itemValidationError = validate$2(obj_contextMappings_item, path_contextMappings_item);
+            if (referencepath_contextMappings_itemValidationError !== null) {
+                let message = 'Object doesn\'t match ContextMappingRepresentation (at "' + path_contextMappings_item + '")\n';
+                message += referencepath_contextMappings_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_contextNodes = obj.contextNodes;
+        const path_contextNodes = path + '.contextNodes';
+        if (!ArrayIsArray(obj_contextNodes)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_contextNodes + '" (at "' + path_contextNodes + '")');
+        }
+        for (let i = 0; i < obj_contextNodes.length; i++) {
+            const obj_contextNodes_item = obj_contextNodes[i];
+            const path_contextNodes_item = path_contextNodes + '[' + i + ']';
+            const referencepath_contextNodes_itemValidationError = validate$7(obj_contextNodes_item, path_contextNodes_item);
+            if (referencepath_contextNodes_itemValidationError !== null) {
+                let message = 'Object doesn\'t match ContextNodeRepresentation (at "' + path_contextNodes_item + '")\n';
+                message += referencepath_contextNodes_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.definition !== undefined) {
+            const obj_definition = obj.definition;
+            const path_definition = path + '.definition';
+            if (typeof obj_definition !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_definition + '" (at "' + path_definition + '")');
+            }
+        }
+        if (obj.description !== undefined) {
+            const obj_description = obj.description;
+            const path_description = path + '.description';
+            if (typeof obj_description !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_description + '" (at "' + path_description + '")');
+            }
+        }
+        if (obj.endDate !== undefined) {
+            const obj_endDate = obj.endDate;
+            const path_endDate = path + '.endDate';
+            if (typeof obj_endDate !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_endDate + '" (at "' + path_endDate + '")');
+            }
+        }
+        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 + '")');
+        }
+        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 + '")');
+            }
+        }
+        if (obj.startDate !== undefined) {
+            const obj_startDate = obj.startDate;
+            const path_startDate = path + '.startDate';
+            if (typeof obj_startDate !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_startDate + '" (at "' + path_startDate + '")');
+            }
+        }
+        if (obj.versionNumber !== undefined) {
+            const obj_versionNumber = obj.versionNumber;
+            const path_versionNumber = path + '.versionNumber';
+            if (typeof obj_versionNumber !== 'number' || (typeof obj_versionNumber === 'number' && Math.floor(obj_versionNumber) !== obj_versionNumber)) {
+                return new TypeError('Expected "integer" but received "' + typeof obj_versionNumber + '" (at "' + path_versionNumber + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$1 = 'ContextDefinitionVersionRepresentation';
+function keyBuilder$7(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$1 + ':' + config.id;
+}
+function keyBuilderFromType$1(luvio, object) {
+    const keyParams = {
+        id: object.contextDefinitionVersionId
+    };
+    return keyBuilder$7(luvio, keyParams);
+}
+function normalize$1(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$6 = function ContextDefinitionVersionRepresentationSelect() {
+    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(input) {
+    const input_contextMappings = input.contextMappings;
+    for (let i = 0; i < input_contextMappings.length; i++) {
+        const input_contextMappings_item = input_contextMappings[i];
+        deepFreeze$1(input_contextMappings_item);
+    }
+    ObjectFreeze(input_contextMappings);
+    const input_contextNodes = input.contextNodes;
+    for (let i = 0; i < input_contextNodes.length; i++) {
+        const input_contextNodes_item = input_contextNodes[i];
+        deepFreeze$5(input_contextNodes_item);
+    }
+    ObjectFreeze(input_contextNodes);
+    ObjectFreeze(input);
+}
+const ingest$1 = function ContextDefinitionVersionRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$1(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$1(luvio, input);
+    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(input);
+    if (existingRecord === undefined || equals$1(existingRecord, incomingRecord) === false) {
+        luvio.storePublish(key, incomingRecord);
+    }
+    {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "IndustriesContext",
+            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 = keyBuilderFromType$1(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$1,
+        mergeable: false
+    });
+    return rootKeySet;
+}
+
+function select$5(luvio, params) {
+    return select$6();
+}
+function getResponseCacheKeys$6(luvio, resourceParams, response) {
+    return getTypeCacheKeys$1(luvio, response);
+}
+function ingestSuccess$4(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$1(luvio, body);
+    luvio.storeIngest(key, ingest$1, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$5(),
+        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$6(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/contextdefinition/version',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const createContextDefinitionVersion_ConfigPropertyNames = {
+    displayName: 'createContextDefinitionVersion',
+    parameters: {
+        required: ['contextDefinitionVersionInput'],
+        optional: []
+    }
+};
+function createResourceParams$6(config) {
+    const resourceParams = {
+        body: {
+            contextDefinitionVersionInput: config.contextDefinitionVersionInput
+        }
+    };
+    return resourceParams;
+}
+function typeCheckConfig$6(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contextDefinitionVersionInput = untrustedConfig.contextDefinitionVersionInput;
+    const referenceContextDefinitionVersionInputRepresentationValidationError = validate$6(untrustedConfig_contextDefinitionVersionInput);
+    if (referenceContextDefinitionVersionInputRepresentationValidationError === null) {
+        config.contextDefinitionVersionInput = untrustedConfig_contextDefinitionVersionInput;
+    }
+    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 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(() => {
+            const snapshot = ingestSuccess$4(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => getResponseCacheKeys$6(luvio, resourceParams, response.body));
+    }, (response) => {
+        deepFreeze$8(response);
+        throw response;
+    });
+}
+const createContextDefinitionVersionAdapterFactory = (luvio) => {
+    return function createContextDefinitionVersion(untrustedConfig) {
+        const config = validateAdapterConfig$6(untrustedConfig, createContextDefinitionVersion_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "createContextDefinitionVersion"');
+        }
+        return buildNetworkSnapshot$6(luvio, config);
+    };
+};
+
+function keyBuilder$6(luvio, params) {
+    return keyBuilder$7(luvio, {
+        id: params.urlParams.contextDefinitionVersionId
+    });
+}
+function getResponseCacheKeys$5(luvio, resourceParams) {
+    const key = keyBuilder$6(luvio, resourceParams);
+    const cacheKeyMap = new StoreKeyMap();
+    cacheKeyMap.set(key, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$1,
+        mergeable: false
+    });
+    return cacheKeyMap;
+}
+function evictSuccess$1(luvio, resourceParams) {
+    const key = keyBuilder$6(luvio, resourceParams);
+    luvio.storeEvict(key);
+}
+function createResourceRequest$5(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/contextdefinition/version/' + config.urlParams.contextDefinitionVersionId + '',
+        method: 'delete',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$1 = 'deleteContextDefinitionVersion';
+const deleteContextDefinitionVersion_ConfigPropertyNames = {
+    displayName: 'deleteContextDefinitionVersion',
+    parameters: {
+        required: ['contextDefinitionVersionId'],
+        optional: []
+    }
+};
+function createResourceParams$5(config) {
+    const resourceParams = {
+        urlParams: {
+            contextDefinitionVersionId: config.contextDefinitionVersionId
+        }
+    };
+    return resourceParams;
+}
+function typeCheckConfig$5(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contextDefinitionVersionId = untrustedConfig.contextDefinitionVersionId;
+    if (typeof untrustedConfig_contextDefinitionVersionId === 'string') {
+        config.contextDefinitionVersionId = untrustedConfig_contextDefinitionVersionId;
+    }
+    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 buildNetworkSnapshot$5(luvio, config, options) {
+    const resourceParams = createResourceParams$5(config);
+    const request = createResourceRequest$5(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then(() => {
+        return luvio.handleSuccessResponse(() => {
+            evictSuccess$1(luvio, resourceParams);
+            return luvio.storeBroadcast();
+        }, () => getResponseCacheKeys$5(luvio, resourceParams));
+    }, (response) => {
+        deepFreeze$8(response);
+        throw response;
+    });
+}
+const deleteContextDefinitionVersionAdapterFactory = (luvio) => {
+    return function IndustriesContextdeleteContextDefinitionVersion(untrustedConfig) {
+        const config = validateAdapterConfig$5(untrustedConfig, deleteContextDefinitionVersion_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error(`Invalid config for "${adapterName$1}"`);
+        }
+        return buildNetworkSnapshot$5(luvio, config);
+    };
+};
+
+function select$4(luvio, params) {
+    return select$6();
+}
+function keyBuilder$5(luvio, params) {
+    return keyBuilder$7(luvio, {
+        id: params.urlParams.contextDefinitionVersionId
+    });
+}
+function getResponseCacheKeys$4(luvio, resourceParams, response) {
+    return getTypeCacheKeys$1(luvio, response);
+}
+function ingestSuccess$3(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$5(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$1, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$4(),
+        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$5(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/contextdefinition/version/' + config.urlParams.contextDefinitionVersionId + '',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const getContextDefinitionVersion_ConfigPropertyNames = {
+    displayName: 'getContextDefinitionVersion',
+    parameters: {
+        required: ['contextDefinitionVersionId'],
+        optional: []
+    }
+};
+function createResourceParams$4(config) {
+    const resourceParams = {
+        urlParams: {
+            contextDefinitionVersionId: config.contextDefinitionVersionId
+        }
+    };
+    return resourceParams;
+}
+function keyBuilder$4(luvio, config) {
+    const resourceParams = createResourceParams$4(config);
+    return keyBuilder$5(luvio, resourceParams);
+}
+function typeCheckConfig$4(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contextDefinitionVersionId = untrustedConfig.contextDefinitionVersionId;
+    if (typeof untrustedConfig_contextDefinitionVersionId === 'string') {
+        config.contextDefinitionVersionId = untrustedConfig_contextDefinitionVersionId;
+    }
+    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$1(luvio, config) {
+    createResourceParams$4(config);
+    return select$4();
+}
+function onFetchResponseSuccess$1(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$3(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$4(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$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$1(luvio, config, resourceParams, response), () => getResponseCacheKeys$4(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$4(luvio, config, dispatchOptions);
+}
+function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$4(luvio, config),
+        node: adapterFragment$1(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getContextDefinitionVersionAdapterFactory = (luvio) => function IndustriesContext__getContextDefinitionVersion(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$4(untrustedConfig, getContextDefinitionVersion_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$1, buildNetworkSnapshotCachePolicy$1);
+};
+
+function select$3(luvio, params) {
+    return select$6();
+}
+function getResponseCacheKeys$3(luvio, resourceParams, response) {
+    return getTypeCacheKeys$1(luvio, response);
+}
+function ingestSuccess$2(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$1(luvio, body);
+    luvio.storeIngest(key, ingest$1, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$3(),
+        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/contextdefinition/version/' + config.urlParams.contextDefinitionVersionId + '',
+        method: 'patch',
+        body: config.body,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const updateContextDefinitionVersion_ConfigPropertyNames = {
+    displayName: 'updateContextDefinitionVersion',
+    parameters: {
+        required: ['contextDefinitionVersionId', 'contextDefinitionVersionInput'],
+        optional: []
+    }
+};
+function createResourceParams$3(config) {
+    const resourceParams = {
+        urlParams: {
+            contextDefinitionVersionId: config.contextDefinitionVersionId
+        },
+        body: {
+            contextDefinitionVersionInput: config.contextDefinitionVersionInput
+        }
+    };
+    return resourceParams;
+}
+function typeCheckConfig$3(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contextDefinitionVersionId = untrustedConfig.contextDefinitionVersionId;
+    if (typeof untrustedConfig_contextDefinitionVersionId === 'string') {
+        config.contextDefinitionVersionId = untrustedConfig_contextDefinitionVersionId;
+    }
+    const untrustedConfig_contextDefinitionVersionInput = untrustedConfig.contextDefinitionVersionInput;
+    const referenceContextDefinitionVersionInputRepresentationValidationError = validate$6(untrustedConfig_contextDefinitionVersionInput);
+    if (referenceContextDefinitionVersionInputRepresentationValidationError === null) {
+        config.contextDefinitionVersionInput = untrustedConfig_contextDefinitionVersionInput;
+    }
+    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$2(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => getResponseCacheKeys$3(luvio, resourceParams, response.body));
+    }, (response) => {
+        deepFreeze$8(response);
+        throw response;
+    });
+}
+const updateContextDefinitionVersionAdapterFactory = (luvio) => {
+    return function updateContextDefinitionVersion(untrustedConfig) {
+        const config = validateAdapterConfig$3(untrustedConfig, updateContextDefinitionVersion_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "updateContextDefinitionVersion"');
+        }
+        return buildNetworkSnapshot$3(luvio, config);
+    };
+};
+
+const TTL = 30000;
+const VERSION = "fea3658cfe2699ab96f7f7fec5d4ce9e";
+function validate(obj, path = 'ContextDefinitionRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.activeVersionId !== undefined) {
+            const obj_activeVersionId = obj.activeVersionId;
+            const path_activeVersionId = path + '.activeVersionId';
+            if (typeof obj_activeVersionId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_activeVersionId + '" (at "' + path_activeVersionId + '")');
+            }
+        }
+        const obj_contextDefinitionId = obj.contextDefinitionId;
+        const path_contextDefinitionId = path + '.contextDefinitionId';
+        if (typeof obj_contextDefinitionId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contextDefinitionId + '" (at "' + path_contextDefinitionId + '")');
+        }
+        const obj_contextDefinitionVersionList = obj.contextDefinitionVersionList;
+        const path_contextDefinitionVersionList = path + '.contextDefinitionVersionList';
+        if (!ArrayIsArray(obj_contextDefinitionVersionList)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_contextDefinitionVersionList + '" (at "' + path_contextDefinitionVersionList + '")');
+        }
+        for (let i = 0; i < obj_contextDefinitionVersionList.length; i++) {
+            const obj_contextDefinitionVersionList_item = obj_contextDefinitionVersionList[i];
+            const path_contextDefinitionVersionList_item = path_contextDefinitionVersionList + '[' + i + ']';
+            if (typeof obj_contextDefinitionVersionList_item !== 'object') {
+                return new TypeError('Expected "object" but received "' + typeof obj_contextDefinitionVersionList_item + '" (at "' + path_contextDefinitionVersionList_item + '")');
+            }
+        }
+        const obj_definition = obj.definition;
+        const path_definition = path + '.definition';
+        if (typeof obj_definition !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_definition + '" (at "' + path_definition + '")');
+        }
+        const obj_description = obj.description;
+        const path_description = path + '.description';
+        if (typeof obj_description !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_description + '" (at "' + path_description + '")');
+        }
+        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 = 'ContextDefinitionRepresentation';
+function keyBuilder$3(luvio, config) {
+    return keyPrefix + '::' + RepresentationType + ':' + config.id;
+}
+function keyBuilderFromType(luvio, object) {
+    const keyParams = {
+        id: object.contextDefinitionId
+    };
+    return keyBuilder$3(luvio, keyParams);
+}
+function normalize(input, existing, path, luvio, store, timestamp) {
+    const input_contextDefinitionVersionList = input.contextDefinitionVersionList;
+    const input_contextDefinitionVersionList_id = path.fullPath + '__contextDefinitionVersionList';
+    for (let i = 0; i < input_contextDefinitionVersionList.length; i++) {
+        const input_contextDefinitionVersionList_item = input_contextDefinitionVersionList[i];
+        let input_contextDefinitionVersionList_item_id = input_contextDefinitionVersionList_id + '__' + i;
+        input_contextDefinitionVersionList[i] = ingest$1(input_contextDefinitionVersionList_item, {
+            fullPath: input_contextDefinitionVersionList_item_id,
+            propertyName: i,
+            parent: {
+                data: input,
+                key: path.fullPath,
+                existing: existing,
+            },
+            ttl: path.ttl
+        }, luvio, store);
+    }
+    return input;
+}
+const select$2 = function ContextDefinitionRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION,
+        private: [],
+        selections: [
+            {
+                name: 'activeVersionId',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'contextDefinitionId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'contextDefinitionVersionList',
+                kind: 'Link',
+                plural: true,
+                fragment: select$6()
+            },
+            {
+                name: 'definition',
+                kind: 'Scalar'
+            },
+            {
+                name: 'description',
+                kind: 'Scalar'
+            },
+            {
+                name: 'isSuccess',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals(existing, incoming) {
+    const existing_isSuccess = existing.isSuccess;
+    const incoming_isSuccess = incoming.isSuccess;
+    if (!(existing_isSuccess === incoming_isSuccess)) {
+        return false;
+    }
+    const existing_activeVersionId = existing.activeVersionId;
+    const incoming_activeVersionId = incoming.activeVersionId;
+    // if at least one of these optionals is defined
+    if (existing_activeVersionId !== undefined || incoming_activeVersionId !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_activeVersionId === undefined || incoming_activeVersionId === undefined) {
+            return false;
+        }
+        if (!(existing_activeVersionId === incoming_activeVersionId)) {
+            return false;
+        }
+    }
+    const existing_contextDefinitionId = existing.contextDefinitionId;
+    const incoming_contextDefinitionId = incoming.contextDefinitionId;
+    if (!(existing_contextDefinitionId === incoming_contextDefinitionId)) {
+        return false;
+    }
+    const existing_definition = existing.definition;
+    const incoming_definition = incoming.definition;
+    if (!(existing_definition === incoming_definition)) {
+        return false;
+    }
+    const existing_description = existing.description;
+    const incoming_description = incoming.description;
+    if (!(existing_description === incoming_description)) {
+        return false;
+    }
+    const existing_contextDefinitionVersionList = existing.contextDefinitionVersionList;
+    const incoming_contextDefinitionVersionList = incoming.contextDefinitionVersionList;
+    const equals_contextDefinitionVersionList_items = equalsArray(existing_contextDefinitionVersionList, incoming_contextDefinitionVersionList, (existing_contextDefinitionVersionList_item, incoming_contextDefinitionVersionList_item) => {
+        if (!(existing_contextDefinitionVersionList_item.__ref === incoming_contextDefinitionVersionList_item.__ref)) {
+            return false;
+        }
+    });
+    if (equals_contextDefinitionVersionList_items === false) {
+        return false;
+    }
+    return true;
+}
+const ingest = function ContextDefinitionRepresentationIngest(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
+    }, luvio, store);
+    if (existingRecord === undefined || equals(existingRecord, incomingRecord) === false) {
+        luvio.storePublish(key, incomingRecord);
+    }
+    {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "IndustriesContext",
+            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
+    });
+    const input_contextDefinitionVersionList_length = input.contextDefinitionVersionList.length;
+    for (let i = 0; i < input_contextDefinitionVersionList_length; i++) {
+        rootKeySet.merge(getTypeCacheKeys$1(luvio, input.contextDefinitionVersionList[i]));
+    }
+    return rootKeySet;
+}
+
+function keyBuilder$2(luvio, params) {
+    return keyBuilder$3(luvio, {
+        id: params.urlParams.contextDefinitionId
+    });
+}
+function getResponseCacheKeys$2(luvio, resourceParams) {
+    const key = keyBuilder$2(luvio, resourceParams);
+    const cacheKeyMap = new StoreKeyMap();
+    cacheKeyMap.set(key, {
+        namespace: keyPrefix,
+        representationName: RepresentationType,
+        mergeable: false
+    });
+    return cacheKeyMap;
+}
+function evictSuccess(luvio, resourceParams) {
+    const key = keyBuilder$2(luvio, resourceParams);
+    luvio.storeEvict(key);
+}
+function createResourceRequest$2(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/contextdefinition/' + config.urlParams.contextDefinitionId + '',
+        method: 'delete',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName = 'deleteContextDefinition';
+const deleteContextDefinition_ConfigPropertyNames = {
+    displayName: 'deleteContextDefinition',
+    parameters: {
+        required: ['contextDefinitionId'],
+        optional: []
+    }
+};
+function createResourceParams$2(config) {
+    const resourceParams = {
+        urlParams: {
+            contextDefinitionId: config.contextDefinitionId
+        }
+    };
+    return resourceParams;
+}
+function typeCheckConfig$2(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contextDefinitionId = untrustedConfig.contextDefinitionId;
+    if (typeof untrustedConfig_contextDefinitionId === 'string') {
+        config.contextDefinitionId = untrustedConfig_contextDefinitionId;
+    }
+    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(() => {
+        return luvio.handleSuccessResponse(() => {
+            evictSuccess(luvio, resourceParams);
+            return luvio.storeBroadcast();
+        }, () => getResponseCacheKeys$2(luvio, resourceParams));
+    }, (response) => {
+        deepFreeze$8(response);
+        throw response;
+    });
+}
+const deleteContextDefinitionAdapterFactory = (luvio) => {
+    return function IndustriesContextdeleteContextDefinition(untrustedConfig) {
+        const config = validateAdapterConfig$2(untrustedConfig, deleteContextDefinition_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error(`Invalid config for "${adapterName}"`);
+        }
+        return buildNetworkSnapshot$2(luvio, config);
+    };
+};
+
+function select$1(luvio, params) {
+    return select$2();
+}
+function keyBuilder$1(luvio, params) {
+    return keyBuilder$3(luvio, {
+        id: params.urlParams.contextDefinitionId
+    });
+}
+function getResponseCacheKeys$1(luvio, resourceParams, response) {
+    return getTypeCacheKeys(luvio, response);
+}
+function ingestSuccess$1(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$1(luvio, resourceParams);
+    luvio.storeIngest(key, ingest, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$1(),
+        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$1(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    const storeMetadataParams = {
+        ttl: TTL,
+        namespace: keyPrefix,
+        version: VERSION,
+        representationName: RepresentationType
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
+function createResourceRequest$1(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/connect/contextdefinition/' + config.urlParams.contextDefinitionId + '',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const getContextDefinition_ConfigPropertyNames = {
+    displayName: 'getContextDefinition',
+    parameters: {
+        required: ['contextDefinitionId'],
+        optional: []
+    }
+};
+function createResourceParams$1(config) {
+    const resourceParams = {
+        urlParams: {
+            contextDefinitionId: config.contextDefinitionId
+        }
+    };
+    return resourceParams;
+}
+function keyBuilder(luvio, config) {
+    const resourceParams = createResourceParams$1(config);
+    return keyBuilder$1(luvio, resourceParams);
+}
+function typeCheckConfig$1(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contextDefinitionId = untrustedConfig.contextDefinitionId;
+    if (typeof untrustedConfig_contextDefinitionId === 'string') {
+        config.contextDefinitionId = untrustedConfig_contextDefinitionId;
+    }
+    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 adapterFragment(luvio, config) {
+    createResourceParams$1(config);
+    return select$1();
+}
+function onFetchResponseSuccess(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$1(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError(luvio, config, resourceParams, response) {
+    const snapshot = ingestError(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+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(() => onFetchResponseSuccess(luvio, config, resourceParams, response), () => getResponseCacheKeys$1(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$1(luvio, config, dispatchOptions);
+}
+function buildCachedSnapshotCachePolicy(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder(luvio, config),
+        node: adapterFragment(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getContextDefinitionAdapterFactory = (luvio) => function IndustriesContext__getContextDefinition(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$1(untrustedConfig, getContextDefinition_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
+};
+
+function select(luvio, params) {
+    return select$k();
+}
+function getResponseCacheKeys(luvio, resourceParams, response) {
+    return getTypeCacheKeys$6(luvio, response);
+}
+function ingestSuccess(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$5(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/contextdefinition/' + config.urlParams.contextDefinitionId + '',
+        method: 'patch',
+        body: config.body,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const updateContextDefinition_ConfigPropertyNames = {
+    displayName: 'updateContextDefinition',
+    parameters: {
+        required: ['contextDefinitionId', 'contextDefinitionInput'],
+        optional: []
+    }
+};
+function createResourceParams(config) {
+    const resourceParams = {
+        urlParams: {
+            contextDefinitionId: config.contextDefinitionId
+        },
+        body: {
+            contextDefinitionInput: config.contextDefinitionInput
+        }
+    };
+    return resourceParams;
+}
+function typeCheckConfig(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contextDefinitionId = untrustedConfig.contextDefinitionId;
+    if (typeof untrustedConfig_contextDefinitionId === 'string') {
+        config.contextDefinitionId = untrustedConfig_contextDefinitionId;
+    }
+    const untrustedConfig_contextDefinitionInput = untrustedConfig.contextDefinitionInput;
+    const referenceContextDefinitionInputRepresentationValidationError = validate$c(untrustedConfig_contextDefinitionInput);
+    if (referenceContextDefinitionInputRepresentationValidationError === null) {
+        config.contextDefinitionInput = untrustedConfig_contextDefinitionInput;
+    }
+    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$8(response);
+        throw response;
+    });
+}
+const updateContextDefinitionAdapterFactory = (luvio) => {
+    return function updateContextDefinition(untrustedConfig) {
+        const config = validateAdapterConfig(untrustedConfig, updateContextDefinition_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "updateContextDefinition"');
+        }
+        return buildNetworkSnapshot(luvio, config);
+    };
+};
+
+export { createContextAttributeAdapterFactory, createContextDefinitionAdapterFactory, createContextDefinitionVersionAdapterFactory, createContextNodeAdapterFactory, deleteContextAttributeAdapterFactory, deleteContextDefinitionAdapterFactory, deleteContextDefinitionVersionAdapterFactory, deleteContextNodeAdapterFactory, getContextAttributeAdapterFactory, getContextDefinitionAdapterFactory, getContextDefinitionInfoAdapterFactory, getContextDefinitionListAdapterFactory, getContextDefinitionVersionAdapterFactory, getContextNodeAdapterFactory, updateContextAttributeAdapterFactory, updateContextDefinitionAdapterFactory, updateContextDefinitionVersionAdapterFactory, updateContextNodeAdapterFactory };