@salesforce/lds-adapters-industries-context 1.162.0 → 1.163.0

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

@@ -7,7 +7,7 @@
 import { serializeStructuredKey, StoreKeyMap, deepFreeze } from '@luvio/engine';
 
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
-const { keys: ObjectKeys, create: ObjectCreate } = Object;
+const { keys: ObjectKeys$1, create: ObjectCreate$1 } = Object;
 const { isArray: ArrayIsArray$1 } = Array;
 /**
  * Validates an adapter config is well-formed.
@@ -31,7 +31,7 @@ function validateConfig(config, adapter, oneOf) {
         throw new TypeError(`adapter ${displayName} does not yet support ${unsupported.sort().join(', ')}`);
     }
     const supported = required.concat(optional);
-    if (ObjectKeys(config).some(key => !supported.includes(key))) {
+    if (ObjectKeys$1(config).some(key => !supported.includes(key))) {
         throw new TypeError(`adapter ${displayName} configuration supports only ${supported.sort().join(', ')}`);
     }
 }
@@ -50,6 +50,7 @@ const snapshotRefreshOptions = {
 };
 const keyPrefix = 'IndustriesContext';
 
+const { keys: ObjectKeys, create: ObjectCreate, assign: ObjectAssign } = Object;
 const { isArray: ArrayIsArray } = Array;
 const { stringify: JSONStringify } = JSON;
 function equalsArray(a, b, equalsItem) {
@@ -65,15 +66,1080 @@ function equalsArray(a, b, equalsItem) {
     }
     return true;
 }
+function equalsObject(a, b, equalsProp) {
+    const aKeys = ObjectKeys(a).sort();
+    const bKeys = ObjectKeys(b).sort();
+    const aKeysLength = aKeys.length;
+    const bKeysLength = bKeys.length;
+    if (aKeysLength !== bKeysLength) {
+        return false;
+    }
+    for (let i = 0; i < aKeys.length; i++) {
+        const key = aKeys[i];
+        if (key !== bKeys[i]) {
+            return false;
+        }
+        if (equalsProp(a[key], b[key]) === false) {
+            return false;
+        }
+    }
+    return true;
+}
 function createLink(ref) {
     return {
-        __ref: serializeStructuredKey(ref),
+        __ref: serializeStructuredKey(ref),
+    };
+}
+
+function validate$t(obj, path = 'QueryContextRecordInputRepresentation') {
+    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 !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_attributes_item + '" (at "' + path_attributes_item + '")');
+                }
+            }
+        }
+        if (obj.businessObjectTypeFilter !== undefined) {
+            const obj_businessObjectTypeFilter = obj.businessObjectTypeFilter;
+            const path_businessObjectTypeFilter = path + '.businessObjectTypeFilter';
+            if (typeof obj_businessObjectTypeFilter !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_businessObjectTypeFilter + '" (at "' + path_businessObjectTypeFilter + '")');
+            }
+        }
+        const obj_contextId = obj.contextId;
+        const path_contextId = path + '.contextId';
+        if (typeof obj_contextId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contextId + '" (at "' + path_contextId + '")');
+        }
+        if (obj.queryPath !== undefined) {
+            const obj_queryPath = obj.queryPath;
+            const path_queryPath = path + '.queryPath';
+            if (!ArrayIsArray(obj_queryPath)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_queryPath + '" (at "' + path_queryPath + '")');
+            }
+            for (let i = 0; i < obj_queryPath.length; i++) {
+                const obj_queryPath_item = obj_queryPath[i];
+                const path_queryPath_item = path_queryPath + '[' + i + ']';
+                if (typeof obj_queryPath_item !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_queryPath_item + '" (at "' + path_queryPath_item + '")');
+                }
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+const VERSION$h = "6fc1ed5f9fdcaa261c69ec3614505566";
+function validate$s(obj, path = 'ContextDataRecordRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.attributesAndValues !== undefined) {
+            const obj_attributesAndValues = obj.attributesAndValues;
+            const path_attributesAndValues = path + '.attributesAndValues';
+            if (typeof obj_attributesAndValues !== 'object' || ArrayIsArray(obj_attributesAndValues) || obj_attributesAndValues === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj_attributesAndValues + '" (at "' + path_attributesAndValues + '")');
+            }
+            const obj_attributesAndValues_keys = ObjectKeys(obj_attributesAndValues);
+            for (let i = 0; i < obj_attributesAndValues_keys.length; i++) {
+                const key = obj_attributesAndValues_keys[i];
+                const obj_attributesAndValues_prop = obj_attributesAndValues[key];
+                const path_attributesAndValues_prop = path_attributesAndValues + '["' + key + '"]';
+                if (obj_attributesAndValues_prop === undefined) {
+                    return new TypeError('Expected "defined" but received "' + typeof obj_attributesAndValues_prop + '" (at "' + path_attributesAndValues_prop + '")');
+                }
+            }
+        }
+        if (obj.childBusinessObjectTypes !== undefined) {
+            const obj_childBusinessObjectTypes = obj.childBusinessObjectTypes;
+            const path_childBusinessObjectTypes = path + '.childBusinessObjectTypes';
+            if (!ArrayIsArray(obj_childBusinessObjectTypes)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_childBusinessObjectTypes + '" (at "' + path_childBusinessObjectTypes + '")');
+            }
+            for (let i = 0; i < obj_childBusinessObjectTypes.length; i++) {
+                const obj_childBusinessObjectTypes_item = obj_childBusinessObjectTypes[i];
+                const path_childBusinessObjectTypes_item = path_childBusinessObjectTypes + '[' + i + ']';
+                if (typeof obj_childBusinessObjectTypes_item !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_childBusinessObjectTypes_item + '" (at "' + path_childBusinessObjectTypes_item + '")');
+                }
+            }
+        }
+        if (obj.contextDataRecordId !== undefined) {
+            const obj_contextDataRecordId = obj.contextDataRecordId;
+            const path_contextDataRecordId = path + '.contextDataRecordId';
+            if (typeof obj_contextDataRecordId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_contextDataRecordId + '" (at "' + path_contextDataRecordId + '")');
+            }
+        }
+        if (obj.contextDefinitionId !== undefined) {
+            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.contextMappingId !== undefined) {
+            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 + '")');
+            }
+        }
+        if (obj.currentState !== undefined) {
+            const obj_currentState = obj.currentState;
+            const path_currentState = path + '.currentState';
+            if (typeof obj_currentState !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_currentState + '" (at "' + path_currentState + '")');
+            }
+        }
+        if (obj.errorCode !== undefined) {
+            const obj_errorCode = obj.errorCode;
+            const path_errorCode = path + '.errorCode';
+            if (typeof obj_errorCode !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_errorCode + '" (at "' + path_errorCode + '")');
+            }
+        }
+        if (obj.errorMessages !== undefined) {
+            const obj_errorMessages = obj.errorMessages;
+            const path_errorMessages = path + '.errorMessages';
+            if (!ArrayIsArray(obj_errorMessages)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_errorMessages + '" (at "' + path_errorMessages + '")');
+            }
+            for (let i = 0; i < obj_errorMessages.length; i++) {
+                const obj_errorMessages_item = obj_errorMessages[i];
+                const path_errorMessages_item = path_errorMessages + '[' + i + ']';
+                if (typeof obj_errorMessages_item !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_errorMessages_item + '" (at "' + path_errorMessages_item + '")');
+                }
+            }
+        }
+        if (obj.lastProcessedTimeStamp !== undefined) {
+            const obj_lastProcessedTimeStamp = obj.lastProcessedTimeStamp;
+            const path_lastProcessedTimeStamp = path + '.lastProcessedTimeStamp';
+            if (typeof obj_lastProcessedTimeStamp !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_lastProcessedTimeStamp + '" (at "' + path_lastProcessedTimeStamp + '")');
+            }
+        }
+        if (obj.lastUpdatedTimeStamp !== undefined) {
+            const obj_lastUpdatedTimeStamp = obj.lastUpdatedTimeStamp;
+            const path_lastUpdatedTimeStamp = path + '.lastUpdatedTimeStamp';
+            if (typeof obj_lastUpdatedTimeStamp !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_lastUpdatedTimeStamp + '" (at "' + path_lastUpdatedTimeStamp + '")');
+            }
+        }
+        if (obj.processingStatus !== undefined) {
+            const obj_processingStatus = obj.processingStatus;
+            const path_processingStatus = path + '.processingStatus';
+            if (typeof obj_processingStatus !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_processingStatus + '" (at "' + path_processingStatus + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$N = function ContextDataRecordRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$h,
+        private: [],
+        selections: [
+            {
+                name: 'attributesAndValues',
+                kind: 'Object',
+                // any
+            },
+            {
+                name: 'childBusinessObjectTypes',
+                kind: 'Scalar',
+                plural: true,
+                required: false
+            },
+            {
+                name: 'contextDataRecordId',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'contextDefinitionId',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'contextMappingId',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'currentState',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'errorCode',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'errorMessages',
+                kind: 'Scalar',
+                plural: true,
+                required: false
+            },
+            {
+                name: 'lastProcessedTimeStamp',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'lastUpdatedTimeStamp',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'processingStatus',
+                kind: 'Scalar',
+                required: false
+            }
+        ]
+    };
+};
+function equals$h(existing, incoming) {
+    const existing_contextDataRecordId = existing.contextDataRecordId;
+    const incoming_contextDataRecordId = incoming.contextDataRecordId;
+    // if at least one of these optionals is defined
+    if (existing_contextDataRecordId !== undefined || incoming_contextDataRecordId !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_contextDataRecordId === undefined || incoming_contextDataRecordId === undefined) {
+            return false;
+        }
+        if (!(existing_contextDataRecordId === incoming_contextDataRecordId)) {
+            return false;
+        }
+    }
+    const existing_contextDefinitionId = existing.contextDefinitionId;
+    const incoming_contextDefinitionId = incoming.contextDefinitionId;
+    // if at least one of these optionals is defined
+    if (existing_contextDefinitionId !== undefined || incoming_contextDefinitionId !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_contextDefinitionId === undefined || incoming_contextDefinitionId === undefined) {
+            return false;
+        }
+        if (!(existing_contextDefinitionId === incoming_contextDefinitionId)) {
+            return false;
+        }
+    }
+    const existing_contextMappingId = existing.contextMappingId;
+    const incoming_contextMappingId = incoming.contextMappingId;
+    // if at least one of these optionals is defined
+    if (existing_contextMappingId !== undefined || incoming_contextMappingId !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_contextMappingId === undefined || incoming_contextMappingId === undefined) {
+            return false;
+        }
+        if (!(existing_contextMappingId === incoming_contextMappingId)) {
+            return false;
+        }
+    }
+    const existing_currentState = existing.currentState;
+    const incoming_currentState = incoming.currentState;
+    // if at least one of these optionals is defined
+    if (existing_currentState !== undefined || incoming_currentState !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_currentState === undefined || incoming_currentState === undefined) {
+            return false;
+        }
+        if (!(existing_currentState === incoming_currentState)) {
+            return false;
+        }
+    }
+    const existing_errorCode = existing.errorCode;
+    const incoming_errorCode = incoming.errorCode;
+    // if at least one of these optionals is defined
+    if (existing_errorCode !== undefined || incoming_errorCode !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_errorCode === undefined || incoming_errorCode === undefined) {
+            return false;
+        }
+        if (!(existing_errorCode === incoming_errorCode)) {
+            return false;
+        }
+    }
+    const existing_lastProcessedTimeStamp = existing.lastProcessedTimeStamp;
+    const incoming_lastProcessedTimeStamp = incoming.lastProcessedTimeStamp;
+    // if at least one of these optionals is defined
+    if (existing_lastProcessedTimeStamp !== undefined || incoming_lastProcessedTimeStamp !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_lastProcessedTimeStamp === undefined || incoming_lastProcessedTimeStamp === undefined) {
+            return false;
+        }
+        if (!(existing_lastProcessedTimeStamp === incoming_lastProcessedTimeStamp)) {
+            return false;
+        }
+    }
+    const existing_lastUpdatedTimeStamp = existing.lastUpdatedTimeStamp;
+    const incoming_lastUpdatedTimeStamp = incoming.lastUpdatedTimeStamp;
+    // if at least one of these optionals is defined
+    if (existing_lastUpdatedTimeStamp !== undefined || incoming_lastUpdatedTimeStamp !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_lastUpdatedTimeStamp === undefined || incoming_lastUpdatedTimeStamp === undefined) {
+            return false;
+        }
+        if (!(existing_lastUpdatedTimeStamp === incoming_lastUpdatedTimeStamp)) {
+            return false;
+        }
+    }
+    const existing_processingStatus = existing.processingStatus;
+    const incoming_processingStatus = incoming.processingStatus;
+    // if at least one of these optionals is defined
+    if (existing_processingStatus !== undefined || incoming_processingStatus !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_processingStatus === undefined || incoming_processingStatus === undefined) {
+            return false;
+        }
+        if (!(existing_processingStatus === incoming_processingStatus)) {
+            return false;
+        }
+    }
+    const existing_attributesAndValues = existing.attributesAndValues;
+    const incoming_attributesAndValues = incoming.attributesAndValues;
+    // if at least one of these optionals is defined
+    if (existing_attributesAndValues !== undefined || incoming_attributesAndValues !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_attributesAndValues === undefined || incoming_attributesAndValues === undefined) {
+            return false;
+        }
+        const equals_attributesAndValues_props = equalsObject(existing_attributesAndValues, incoming_attributesAndValues, (existing_attributesAndValues_prop, incoming_attributesAndValues_prop) => {
+            if (JSONStringify(incoming_attributesAndValues_prop) !== JSONStringify(existing_attributesAndValues_prop)) {
+                return false;
+            }
+        });
+        if (equals_attributesAndValues_props === false) {
+            return false;
+        }
+    }
+    const existing_childBusinessObjectTypes = existing.childBusinessObjectTypes;
+    const incoming_childBusinessObjectTypes = incoming.childBusinessObjectTypes;
+    // if at least one of these optionals is defined
+    if (existing_childBusinessObjectTypes !== undefined || incoming_childBusinessObjectTypes !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_childBusinessObjectTypes === undefined || incoming_childBusinessObjectTypes === undefined) {
+            return false;
+        }
+        const equals_childBusinessObjectTypes_items = equalsArray(existing_childBusinessObjectTypes, incoming_childBusinessObjectTypes, (existing_childBusinessObjectTypes_item, incoming_childBusinessObjectTypes_item) => {
+            if (!(existing_childBusinessObjectTypes_item === incoming_childBusinessObjectTypes_item)) {
+                return false;
+            }
+        });
+        if (equals_childBusinessObjectTypes_items === false) {
+            return false;
+        }
+    }
+    const existing_errorMessages = existing.errorMessages;
+    const incoming_errorMessages = incoming.errorMessages;
+    // if at least one of these optionals is defined
+    if (existing_errorMessages !== undefined || incoming_errorMessages !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_errorMessages === undefined || incoming_errorMessages === undefined) {
+            return false;
+        }
+        const equals_errorMessages_items = equalsArray(existing_errorMessages, incoming_errorMessages, (existing_errorMessages_item, incoming_errorMessages_item) => {
+            if (!(existing_errorMessages_item === incoming_errorMessages_item)) {
+                return false;
+            }
+        });
+        if (equals_errorMessages_items === false) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const VERSION$g = "49d8c0b4cc8734f68ac1bc90a4614c4a";
+function validate$r(obj, path = 'ContextQueryRecordRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.childQueryRecords !== undefined) {
+            const obj_childQueryRecords = obj.childQueryRecords;
+            const path_childQueryRecords = path + '.childQueryRecords';
+            if (!ArrayIsArray(obj_childQueryRecords)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_childQueryRecords + '" (at "' + path_childQueryRecords + '")');
+            }
+            for (let i = 0; i < obj_childQueryRecords.length; i++) {
+                const obj_childQueryRecords_item = obj_childQueryRecords[i];
+                const path_childQueryRecords_item = path_childQueryRecords + '[' + i + ']';
+                if (obj_childQueryRecords_item === undefined) {
+                    return new TypeError('Expected "defined" but received "' + typeof obj_childQueryRecords_item + '" (at "' + path_childQueryRecords_item + '")');
+                }
+            }
+        }
+        if (obj.record !== undefined) {
+            const obj_record = obj.record;
+            const path_record = path + '.record';
+            const referencepath_recordValidationError = validate$s(obj_record, path_record);
+            if (referencepath_recordValidationError !== null) {
+                let message = 'Object doesn\'t match ContextDataRecordRepresentation (at "' + path_record + '")\n';
+                message += referencepath_recordValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$M = function ContextQueryRecordRepresentationSelect() {
+    const { selections: ContextDataRecordRepresentation__selections, opaque: ContextDataRecordRepresentation__opaque, } = select$N();
+    return {
+        kind: 'Fragment',
+        version: VERSION$g,
+        private: [],
+        selections: [
+            {
+                name: 'childQueryRecords',
+                kind: 'Object',
+                // any
+            },
+            {
+                name: 'record',
+                kind: 'Object',
+                selections: ContextDataRecordRepresentation__selections,
+                required: false
+            }
+        ]
+    };
+};
+function equals$g(existing, incoming) {
+    const existing_childQueryRecords = existing.childQueryRecords;
+    const incoming_childQueryRecords = incoming.childQueryRecords;
+    // if at least one of these optionals is defined
+    if (existing_childQueryRecords !== undefined || incoming_childQueryRecords !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_childQueryRecords === undefined || incoming_childQueryRecords === undefined) {
+            return false;
+        }
+        const equals_childQueryRecords_items = equalsArray(existing_childQueryRecords, incoming_childQueryRecords, (existing_childQueryRecords_item, incoming_childQueryRecords_item) => {
+            if (JSONStringify(incoming_childQueryRecords_item) !== JSONStringify(existing_childQueryRecords_item)) {
+                return false;
+            }
+        });
+        if (equals_childQueryRecords_items === false) {
+            return false;
+        }
+    }
+    const existing_record = existing.record;
+    const incoming_record = incoming.record;
+    // if at least one of these optionals is defined
+    if (existing_record !== undefined || incoming_record !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_record === undefined || incoming_record === undefined) {
+            return false;
+        }
+        if (!(equals$h(existing_record, incoming_record))) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const TTL$f = 10000;
+const VERSION$f = "d6e0481a792086c09a70a174a9232ada";
+function validate$q(obj, path = 'QueryContextRecordResultRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_contextId = obj.contextId;
+        const path_contextId = path + '.contextId';
+        if (typeof obj_contextId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contextId + '" (at "' + path_contextId + '")');
+        }
+        if (obj.isDone !== undefined) {
+            const obj_isDone = obj.isDone;
+            const path_isDone = path + '.isDone';
+            if (typeof obj_isDone !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isDone + '" (at "' + path_isDone + '")');
+            }
+        }
+        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.queryRecords !== undefined) {
+            const obj_queryRecords = obj.queryRecords;
+            const path_queryRecords = path + '.queryRecords';
+            if (!ArrayIsArray(obj_queryRecords)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_queryRecords + '" (at "' + path_queryRecords + '")');
+            }
+            for (let i = 0; i < obj_queryRecords.length; i++) {
+                const obj_queryRecords_item = obj_queryRecords[i];
+                const path_queryRecords_item = path_queryRecords + '[' + i + ']';
+                const referencepath_queryRecords_itemValidationError = validate$r(obj_queryRecords_item, path_queryRecords_item);
+                if (referencepath_queryRecords_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match ContextQueryRecordRepresentation (at "' + path_queryRecords_item + '")\n';
+                    message += referencepath_queryRecords_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$f = 'QueryContextRecordResultRepresentation';
+function keyBuilder$L(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$f + ':' + config.id;
+}
+function keyBuilderFromType$d(luvio, object) {
+    const keyParams = {
+        id: object.contextId
+    };
+    return keyBuilder$L(luvio, keyParams);
+}
+function normalize$f(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$L = function QueryContextRecordResultRepresentationSelect() {
+    const { selections: ContextQueryRecordRepresentation__selections, opaque: ContextQueryRecordRepresentation__opaque, } = select$M();
+    return {
+        kind: 'Fragment',
+        version: VERSION$f,
+        private: [],
+        selections: [
+            {
+                name: 'contextId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'isDone',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'isSuccess',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'queryRecords',
+                kind: 'Object',
+                plural: true,
+                selections: ContextQueryRecordRepresentation__selections,
+                required: false
+            }
+        ]
+    };
+};
+function equals$f(existing, incoming) {
+    const existing_isDone = existing.isDone;
+    const incoming_isDone = incoming.isDone;
+    // if at least one of these optionals is defined
+    if (existing_isDone !== undefined || incoming_isDone !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_isDone === undefined || incoming_isDone === undefined) {
+            return false;
+        }
+        if (!(existing_isDone === incoming_isDone)) {
+            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_contextId = existing.contextId;
+    const incoming_contextId = incoming.contextId;
+    if (!(existing_contextId === incoming_contextId)) {
+        return false;
+    }
+    const existing_queryRecords = existing.queryRecords;
+    const incoming_queryRecords = incoming.queryRecords;
+    // if at least one of these optionals is defined
+    if (existing_queryRecords !== undefined || incoming_queryRecords !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_queryRecords === undefined || incoming_queryRecords === undefined) {
+            return false;
+        }
+        const equals_queryRecords_items = equalsArray(existing_queryRecords, incoming_queryRecords, (existing_queryRecords_item, incoming_queryRecords_item) => {
+            if (!(equals$g(existing_queryRecords_item, incoming_queryRecords_item))) {
+                return false;
+            }
+        });
+        if (equals_queryRecords_items === false) {
+            return false;
+        }
+    }
+    return true;
+}
+const ingest$f = function QueryContextRecordResultRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$q(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$d(luvio, input);
+    const existingRecord = store.readEntry(key);
+    const ttlToUse = TTL$f;
+    let incomingRecord = normalize$f(input, store.readEntry(key), {
+        fullPath: key,
+        parent: path.parent,
+        propertyName: path.propertyName,
+        ttl: ttlToUse
+    });
+    if (existingRecord === undefined || equals$f(existingRecord, incomingRecord) === false) {
+        luvio.storePublish(key, incomingRecord);
+    }
+    {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "IndustriesContext",
+            version: VERSION$f,
+            representationName: RepresentationType$f,
+        };
+        luvio.publishStoreMetadata(key, storeMetadataParams);
+    }
+    return createLink(key);
+};
+function getTypeCacheKeys$f(luvio, input, fullPathFactory) {
+    const rootKeySet = new StoreKeyMap();
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$d(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$f,
+        mergeable: false
+    });
+    return rootKeySet;
+}
+
+function select$K(luvio, params) {
+    return select$L();
+}
+function getResponseCacheKeys$D(luvio, resourceParams, response) {
+    return getTypeCacheKeys$f(luvio, response);
+}
+function ingestSuccess$v(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$d(luvio, body);
+    luvio.storeIngest(key, ingest$f, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$K(),
+        variables: {},
+    });
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
+}
+function createResourceRequest$D(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v59.0',
+        basePath: '/connect/context/queryrecord',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: config.queryParams,
+        headers,
+        priority: 'normal',
+    };
+}
+
+const queryContextRecordAndChildren_ConfigPropertyNames = {
+    displayName: 'queryContextRecordAndChildren',
+    parameters: {
+        required: ['queryContextRecordInput'],
+        optional: ['children']
+    }
+};
+function createResourceParams$D(config) {
+    const resourceParams = {
+        queryParams: {
+            children: config.children
+        },
+        body: {
+            queryContextRecordInput: config.queryContextRecordInput
+        }
+    };
+    return resourceParams;
+}
+function typeCheckConfig$D(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_children = untrustedConfig.children;
+    if (typeof untrustedConfig_children === 'boolean') {
+        config.children = untrustedConfig_children;
+    }
+    const untrustedConfig_queryContextRecordInput = untrustedConfig.queryContextRecordInput;
+    const referenceQueryContextRecordInputRepresentationValidationError = validate$t(untrustedConfig_queryContextRecordInput);
+    if (referenceQueryContextRecordInputRepresentationValidationError === null) {
+        config.queryContextRecordInput = untrustedConfig_queryContextRecordInput;
+    }
+    return config;
+}
+function validateAdapterConfig$D(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$D(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$D(luvio, config, options) {
+    const resourceParams = createResourceParams$D(config);
+    const request = createResourceRequest$D(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$v(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => getResponseCacheKeys$D(luvio, resourceParams, response.body));
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const queryContextRecordAndChildrenAdapterFactory = (luvio) => {
+    return function queryContextRecordAndChildren(untrustedConfig) {
+        const config = validateAdapterConfig$D(untrustedConfig, queryContextRecordAndChildren_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "queryContextRecordAndChildren"');
+        }
+        return buildNetworkSnapshot$D(luvio, config);
+    };
+};
+
+const TTL$e = 30000;
+const VERSION$e = "f4529c1d2c50b9cc056022fbea50b225";
+function validate$p(obj, path = 'ContextInfoRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.childBusinessObjectTypes !== undefined) {
+            const obj_childBusinessObjectTypes = obj.childBusinessObjectTypes;
+            const path_childBusinessObjectTypes = path + '.childBusinessObjectTypes';
+            if (!ArrayIsArray(obj_childBusinessObjectTypes)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_childBusinessObjectTypes + '" (at "' + path_childBusinessObjectTypes + '")');
+            }
+            for (let i = 0; i < obj_childBusinessObjectTypes.length; i++) {
+                const obj_childBusinessObjectTypes_item = obj_childBusinessObjectTypes[i];
+                const path_childBusinessObjectTypes_item = path_childBusinessObjectTypes + '[' + i + ']';
+                if (typeof obj_childBusinessObjectTypes_item !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_childBusinessObjectTypes_item + '" (at "' + path_childBusinessObjectTypes_item + '")');
+                }
+            }
+        }
+        if (obj.contextDefinitionId !== undefined) {
+            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_contextId = obj.contextId;
+        const path_contextId = path + '.contextId';
+        if (typeof obj_contextId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contextId + '" (at "' + path_contextId + '")');
+        }
+        if (obj.contextMappingId !== undefined) {
+            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 + '")');
+            }
+        }
+        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$e = 'ContextInfoRepresentation';
+function keyBuilder$K(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$e + ':' + config.id;
+}
+function keyBuilderFromType$c(luvio, object) {
+    const keyParams = {
+        id: object.contextId
+    };
+    return keyBuilder$K(luvio, keyParams);
+}
+function normalize$e(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$J = function ContextInfoRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$e,
+        private: [],
+        opaque: true
+    };
+};
+function equals$e(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
+const ingest$e = function ContextInfoRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$p(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$c(luvio, input);
+    const existingRecord = store.readEntry(key);
+    const ttlToUse = TTL$e;
+    let incomingRecord = normalize$e(input, store.readEntry(key), {
+        fullPath: key,
+        parent: path.parent,
+        propertyName: path.propertyName,
+        ttl: ttlToUse
+    });
+    if (existingRecord === undefined || equals$e(existingRecord, incomingRecord) === false) {
+        luvio.storePublish(key, incomingRecord);
+    }
+    {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "IndustriesContext",
+            version: VERSION$e,
+            representationName: RepresentationType$e,
+        };
+        luvio.publishStoreMetadata(key, storeMetadataParams);
+    }
+    return createLink(key);
+};
+function getTypeCacheKeys$e(luvio, input, fullPathFactory) {
+    const rootKeySet = new StoreKeyMap();
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$c(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$e,
+        mergeable: false
+    });
+    return rootKeySet;
+}
+
+function select$I(luvio, params) {
+    return select$J();
+}
+function keyBuilder$J(luvio, params) {
+    return keyBuilder$K(luvio, {
+        id: params.urlParams.contextId
+    });
+}
+function getResponseCacheKeys$C(luvio, resourceParams, response) {
+    return getTypeCacheKeys$e(luvio, response);
+}
+function ingestSuccess$u(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$J(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$e, 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');
+        }
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
+}
+function ingestError$c(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$J(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    const storeMetadataParams = {
+        ttl: TTL$e,
+        namespace: keyPrefix,
+        version: VERSION$e,
+        representationName: RepresentationType$e
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
+function createResourceRequest$C(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v59.0',
+        basePath: '/connect/context/' + config.urlParams.contextId + '',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const getContext_ConfigPropertyNames = {
+    displayName: 'getContext',
+    parameters: {
+        required: ['contextId'],
+        optional: []
+    }
+};
+function createResourceParams$C(config) {
+    const resourceParams = {
+        urlParams: {
+            contextId: config.contextId
+        }
+    };
+    return resourceParams;
+}
+function keyBuilder$I(luvio, config) {
+    const resourceParams = createResourceParams$C(config);
+    return keyBuilder$J(luvio, resourceParams);
+}
+function typeCheckConfig$C(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_contextId = untrustedConfig.contextId;
+    if (typeof untrustedConfig_contextId === 'string') {
+        config.contextId = untrustedConfig_contextId;
+    }
+    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 adapterFragment$c(luvio, config) {
+    createResourceParams$C(config);
+    return select$I();
+}
+function onFetchResponseSuccess$c(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$u(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$C(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError$c(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$c(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$C(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+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(() => onFetchResponseSuccess$c(luvio, config, resourceParams, response), () => getResponseCacheKeys$C(luvio, resourceParams, response.body));
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$c(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$c(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$C(luvio, config, dispatchOptions);
+}
+function buildCachedSnapshotCachePolicy$c(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$I(luvio, config),
+        node: adapterFragment$c(luvio, config),
+        variables: {},
     };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$C(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
 }
+const getContextAdapterFactory = (luvio) => function IndustriesContext__getContext(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$C(untrustedConfig, getContext_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$c, buildNetworkSnapshotCachePolicy$c);
+};
 
 const TTL$d = 30000;
 const VERSION$d = "05ab63159c5733f63fae9f5eb081ee89";
-function validate$n(obj, path = 'ContextDefinitionInfoRepresentation') {
+function validate$o(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 + '")');
@@ -422,7 +1488,7 @@ function equals$d(existing, incoming) {
 }
 const ingest$d = function ContextDefinitionInfoRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$n(input);
+        const validateError = validate$o(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -464,7 +1530,7 @@ function getTypeCacheKeys$d(luvio, input, fullPathFactory) {
 
 const TTL$c = 10000;
 const VERSION$c = "847680af81af4497e1c8078978aa7a7e";
-function validate$m(obj, path = 'ContextDefinitionListRepresentation') {
+function validate$n(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 + '")');
@@ -559,7 +1625,7 @@ function equals$c(existing, incoming) {
 }
 const ingest$c = function ContextDefinitionListRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$m(input);
+        const validateError = validate$n(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -763,7 +1829,7 @@ const getContextDefinitionListAdapterFactory = (luvio) => function IndustriesCon
     buildCachedSnapshotCachePolicy$b, buildNetworkSnapshotCachePolicy$b);
 };
 
-function validate$l(obj, path = 'ContextDefinitionInputRepresentation') {
+function validate$m(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 + '")');
@@ -869,7 +1935,7 @@ function createResourceParams$A(config) {
 function typeCheckConfig$A(untrustedConfig) {
     const config = {};
     const untrustedConfig_contextDefinitionInput = untrustedConfig.contextDefinitionInput;
-    const referenceContextDefinitionInputRepresentationValidationError = validate$l(untrustedConfig_contextDefinitionInput);
+    const referenceContextDefinitionInputRepresentationValidationError = validate$m(untrustedConfig_contextDefinitionInput);
     if (referenceContextDefinitionInputRepresentationValidationError === null) {
         config.contextDefinitionInput = untrustedConfig_contextDefinitionInput;
     }
@@ -913,7 +1979,7 @@ const createContextDefinitionAdapterFactory = (luvio) => {
     };
 };
 
-function validate$k(obj, path = 'ContextAttributeInputRepresentation') {
+function validate$l(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 + '")');
@@ -939,6 +2005,13 @@ function validate$k(obj, path = 'ContextAttributeInputRepresentation') {
                 return new TypeError('Expected "string" but received "' + typeof obj_dataType + '" (at "' + path_dataType + '")');
             }
         }
+        if (obj.domainSet !== undefined) {
+            const obj_domainSet = obj.domainSet;
+            const path_domainSet = path + '.domainSet';
+            if (typeof obj_domainSet !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_domainSet + '" (at "' + path_domainSet + '")');
+            }
+        }
         if (obj.fieldType !== undefined) {
             const obj_fieldType = obj.fieldType;
             const path_fieldType = path + '.fieldType';
@@ -980,7 +2053,7 @@ function validate$k(obj, path = 'ContextAttributeInputRepresentation') {
 
 const TTL$b = 30000;
 const VERSION$b = "3a7bdb86e90ea4923b5b327dfec3f38f";
-function validate$j(obj, path = 'ContextAttributeTagRepresentation') {
+function validate$k(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 + '")');
@@ -1129,7 +2202,7 @@ function equals$b(existing, incoming) {
 }
 const ingest$b = function ContextAttributeTagRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$j(input);
+        const validateError = validate$k(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -1170,8 +2243,8 @@ function getTypeCacheKeys$b(luvio, input, fullPathFactory) {
 }
 
 const TTL$a = 30000;
-const VERSION$a = "76c1f590aae0019655fb831d93696edc";
-function validate$i(obj, path = 'ContextAttributeRepresentation') {
+const VERSION$a = "f668e8eb15a473a71c2a9c3ea8669c35";
+function validate$j(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 + '")');
@@ -1200,6 +2273,13 @@ function validate$i(obj, path = 'ContextAttributeRepresentation') {
                 return new TypeError('Expected "string" but received "' + typeof obj_dataType + '" (at "' + path_dataType + '")');
             }
         }
+        if (obj.domainSet !== undefined) {
+            const obj_domainSet = obj.domainSet;
+            const path_domainSet = path + '.domainSet';
+            if (typeof obj_domainSet !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_domainSet + '" (at "' + path_domainSet + '")');
+            }
+        }
         if (obj.fieldType !== undefined) {
             const obj_fieldType = obj.fieldType;
             const path_fieldType = path + '.fieldType';
@@ -1295,6 +2375,11 @@ const select$C = function ContextAttributeRepresentationSelect() {
                 kind: 'Scalar',
                 required: false
             },
+            {
+                name: 'domainSet',
+                kind: 'Scalar',
+                required: false
+            },
             {
                 name: 'fieldType',
                 kind: 'Scalar',
@@ -1386,6 +2471,19 @@ function equals$a(existing, incoming) {
             return false;
         }
     }
+    const existing_domainSet = existing.domainSet;
+    const incoming_domainSet = incoming.domainSet;
+    // if at least one of these optionals is defined
+    if (existing_domainSet !== undefined || incoming_domainSet !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_domainSet === undefined || incoming_domainSet === undefined) {
+            return false;
+        }
+        if (!(existing_domainSet === incoming_domainSet)) {
+            return false;
+        }
+    }
     const existing_fieldType = existing.fieldType;
     const incoming_fieldType = incoming.fieldType;
     // if at least one of these optionals is defined
@@ -1439,7 +2537,7 @@ function equals$a(existing, incoming) {
 }
 const ingest$a = function ContextAttributeRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$i(input);
+        const validateError = validate$j(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -1538,7 +2636,7 @@ function createResourceParams$z(config) {
 function typeCheckConfig$z(untrustedConfig) {
     const config = {};
     const untrustedConfig_contextAttributeInput = untrustedConfig.contextAttributeInput;
-    const referenceContextAttributeInputRepresentationValidationError = validate$k(untrustedConfig_contextAttributeInput);
+    const referenceContextAttributeInputRepresentationValidationError = validate$l(untrustedConfig_contextAttributeInput);
     if (referenceContextAttributeInputRepresentationValidationError === null) {
         config.contextAttributeInput = untrustedConfig_contextAttributeInput;
     }
@@ -1901,7 +2999,7 @@ function typeCheckConfig$w(untrustedConfig) {
         config.contextAttributeId = untrustedConfig_contextAttributeId;
     }
     const untrustedConfig_contextAttributeInput = untrustedConfig.contextAttributeInput;
-    const referenceContextAttributeInputRepresentationValidationError = validate$k(untrustedConfig_contextAttributeInput);
+    const referenceContextAttributeInputRepresentationValidationError = validate$l(untrustedConfig_contextAttributeInput);
     if (referenceContextAttributeInputRepresentationValidationError === null) {
         config.contextAttributeInput = untrustedConfig_contextAttributeInput;
     }
@@ -1947,7 +3045,7 @@ const updateContextAttributeAdapterFactory = (luvio) => {
 
 const TTL$9 = 10000;
 const VERSION$9 = "5d7bd042347d78b8c394239649db8f46";
-function validate$h(obj, path = 'ContextAttributeTagListRepresentation') {
+function validate$i(obj, path = 'ContextAttributeTagListRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1961,7 +3059,7 @@ function validate$h(obj, path = 'ContextAttributeTagListRepresentation') {
             for (let i = 0; i < obj_attributeTags.length; i++) {
                 const obj_attributeTags_item = obj_attributeTags[i];
                 const path_attributeTags_item = path_attributeTags + '[' + i + ']';
-                const referencepath_attributeTags_itemValidationError = validate$j(obj_attributeTags_item, path_attributeTags_item);
+                const referencepath_attributeTags_itemValidationError = validate$k(obj_attributeTags_item, path_attributeTags_item);
                 if (referencepath_attributeTags_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ContextAttributeTagRepresentation (at "' + path_attributeTags_item + '")\n';
                     message += referencepath_attributeTags_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -1999,7 +3097,7 @@ function equals$9(existing, incoming) {
 }
 const ingest$9 = function ContextAttributeTagListRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$h(input);
+        const validateError = validate$i(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -2199,7 +3297,7 @@ const getContextAttributeTagsByAttributeIdAdapterFactory = (luvio) => function I
     buildCachedSnapshotCachePolicy$9, buildNetworkSnapshotCachePolicy$9);
 };
 
-function validate$g(obj, path = 'ContextAttributeTagInputRepresentation') {
+function validate$h(obj, path = 'ContextAttributeTagInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -2282,7 +3380,7 @@ function createResourceParams$u(config) {
 function typeCheckConfig$u(untrustedConfig) {
     const config = {};
     const untrustedConfig_contextAttributeTagInput = untrustedConfig.contextAttributeTagInput;
-    const referenceContextAttributeTagInputRepresentationValidationError = validate$g(untrustedConfig_contextAttributeTagInput);
+    const referenceContextAttributeTagInputRepresentationValidationError = validate$h(untrustedConfig_contextAttributeTagInput);
     if (referenceContextAttributeTagInputRepresentationValidationError === null) {
         config.contextAttributeTagInput = untrustedConfig_contextAttributeTagInput;
     }
@@ -2645,7 +3743,7 @@ function typeCheckConfig$r(untrustedConfig) {
         config.contextAttributeTagId = untrustedConfig_contextAttributeTagId;
     }
     const untrustedConfig_contextAttributeTagInput = untrustedConfig.contextAttributeTagInput;
-    const referenceContextAttributeTagInputRepresentationValidationError = validate$g(untrustedConfig_contextAttributeTagInput);
+    const referenceContextAttributeTagInputRepresentationValidationError = validate$h(untrustedConfig_contextAttributeTagInput);
     if (referenceContextAttributeTagInputRepresentationValidationError === null) {
         config.contextAttributeTagInput = untrustedConfig_contextAttributeTagInput;
     }
@@ -2851,7 +3949,7 @@ const getContextDefinitionInfoAdapterFactory = (luvio) => function IndustriesCon
     buildCachedSnapshotCachePolicy$7, buildNetworkSnapshotCachePolicy$7);
 };
 
-function validate$f(obj, path = 'ContextNodeInputRepresentation') {
+function validate$g(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 + '")');
@@ -2928,7 +4026,7 @@ function validate$f(obj, path = 'ContextNodeInputRepresentation') {
 
 const TTL$8 = 30000;
 const VERSION$8 = "4022adb1f74fc3b3538535fc2e6861ce";
-function validate$e(obj, path = 'ContextNodeRepresentation') {
+function validate$f(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 + '")');
@@ -2942,7 +4040,7 @@ function validate$e(obj, path = 'ContextNodeRepresentation') {
             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$i(obj_attributes_item, path_attributes_item);
+                const referencepath_attributes_itemValidationError = validate$j(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');
@@ -2959,7 +4057,7 @@ function validate$e(obj, path = 'ContextNodeRepresentation') {
             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$e(obj_childNodes_item, path_childNodes_item);
+                const referencepath_childNodes_itemValidationError = validate$f(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');
@@ -3016,7 +4114,7 @@ function validate$e(obj, path = 'ContextNodeRepresentation') {
             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$j(obj_tags_item, path_tags_item);
+                const referencepath_tags_itemValidationError = validate$k(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');
@@ -3056,7 +4154,7 @@ function equals$8(existing, incoming) {
 }
 const ingest$8 = function ContextNodeRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$e(input);
+        const validateError = validate$f(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -3151,7 +4249,7 @@ function createResourceParams$p(config) {
 function typeCheckConfig$p(untrustedConfig) {
     const config = {};
     const untrustedConfig_contextNodeInput = untrustedConfig.contextNodeInput;
-    const referenceContextNodeInputRepresentationValidationError = validate$f(untrustedConfig_contextNodeInput);
+    const referenceContextNodeInputRepresentationValidationError = validate$g(untrustedConfig_contextNodeInput);
     if (referenceContextNodeInputRepresentationValidationError === null) {
         config.contextNodeInput = untrustedConfig_contextNodeInput;
     }
@@ -3514,7 +4612,7 @@ function typeCheckConfig$m(untrustedConfig) {
         config.contextNodeId = untrustedConfig_contextNodeId;
     }
     const untrustedConfig_contextNodeInput = untrustedConfig.contextNodeInput;
-    const referenceContextNodeInputRepresentationValidationError = validate$f(untrustedConfig_contextNodeInput);
+    const referenceContextNodeInputRepresentationValidationError = validate$g(untrustedConfig_contextNodeInput);
     if (referenceContextNodeInputRepresentationValidationError === null) {
         config.contextNodeInput = untrustedConfig_contextNodeInput;
     }
@@ -3558,7 +4656,7 @@ const updateContextNodeAdapterFactory = (luvio) => {
     };
 };
 
-function validate$d(obj, path = 'ContextAttributeListInputRepresentation') {
+function validate$e(obj, path = 'ContextAttributeListInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -3581,7 +4679,7 @@ function validate$d(obj, path = 'ContextAttributeListInputRepresentation') {
 
 const TTL$7 = 10000;
 const VERSION$7 = "6bbfbaed88b7bd009de04a1002ab7022";
-function validate$c(obj, path = 'ContextAttributeListRepresentation') {
+function validate$d(obj, path = 'ContextAttributeListRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -3699,7 +4797,7 @@ function equals$7(existing, incoming) {
 }
 const ingest$7 = function ContextAttributeListRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$c(input);
+        const validateError = validate$d(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -3805,7 +4903,7 @@ function typeCheckConfig$l(untrustedConfig) {
         config.contextNodeId = untrustedConfig_contextNodeId;
     }
     const untrustedConfig_contextAttributeListInput = untrustedConfig.contextAttributeListInput;
-    const referenceContextAttributeListInputRepresentationValidationError = validate$d(untrustedConfig_contextAttributeListInput);
+    const referenceContextAttributeListInputRepresentationValidationError = validate$e(untrustedConfig_contextAttributeListInput);
     if (referenceContextAttributeListInputRepresentationValidationError === null) {
         config.contextAttributeListInput = untrustedConfig_contextAttributeListInput;
     }
@@ -3849,7 +4947,7 @@ const createContextAttributeListAdapterFactory = (luvio) => {
     };
 };
 
-function validate$b(obj, path = 'ContextDefinitionVersionInputRepresentation') {
+function validate$c(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 + '")');
@@ -3912,8 +5010,38 @@ function validate$b(obj, path = 'ContextDefinitionVersionInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
+function validate$b(obj, path = 'MappedAttributeDataTypeInfoRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        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.supportedPicklistValues !== undefined) {
+            const obj_supportedPicklistValues = obj.supportedPicklistValues;
+            const path_supportedPicklistValues = path + '.supportedPicklistValues';
+            if (!ArrayIsArray(obj_supportedPicklistValues)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_supportedPicklistValues + '" (at "' + path_supportedPicklistValues + '")');
+            }
+            for (let i = 0; i < obj_supportedPicklistValues.length; i++) {
+                const obj_supportedPicklistValues_item = obj_supportedPicklistValues[i];
+                const path_supportedPicklistValues_item = path_supportedPicklistValues + '[' + i + ']';
+                if (typeof obj_supportedPicklistValues_item !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_supportedPicklistValues_item + '" (at "' + path_supportedPicklistValues_item + '")');
+                }
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
 const TTL$6 = 30000;
-const VERSION$6 = "02db6b8f5f8aa0607d9f784e68a6d867";
+const VERSION$6 = "d2590d21bfb4b591939abfe1e50521be";
 function validate$a(obj, path = 'ContextAttrHydrationDetailRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -3945,6 +5073,16 @@ function validate$a(obj, path = 'ContextAttrHydrationDetailRepresentation') {
                 return new TypeError('Expected "boolean" but received "' + typeof obj_isSuccess + '" (at "' + path_isSuccess + '")');
             }
         }
+        if (obj.mappedAttributeDataTypeInfo !== undefined) {
+            const obj_mappedAttributeDataTypeInfo = obj.mappedAttributeDataTypeInfo;
+            const path_mappedAttributeDataTypeInfo = path + '.mappedAttributeDataTypeInfo';
+            const referencepath_mappedAttributeDataTypeInfoValidationError = validate$b(obj_mappedAttributeDataTypeInfo, path_mappedAttributeDataTypeInfo);
+            if (referencepath_mappedAttributeDataTypeInfoValidationError !== null) {
+                let message = 'Object doesn\'t match MappedAttributeDataTypeInfoRepresentation (at "' + path_mappedAttributeDataTypeInfo + '")\n';
+                message += referencepath_mappedAttributeDataTypeInfoValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
         if (obj.parentMappingAttributeId !== undefined) {
             const obj_parentMappingAttributeId = obj.parentMappingAttributeId;
             const path_parentMappingAttributeId = path + '.parentMappingAttributeId';
@@ -4039,7 +5177,7 @@ function getTypeCacheKeys$6(luvio, input, fullPathFactory) {
 }
 
 const TTL$5 = 30000;
-const VERSION$5 = "0af25b309b2877b9a39f79b194299ca9";
+const VERSION$5 = "1a8ef2806a43e6f2685e46e157f53073";
 function validate$9(obj, path = 'ContextAttributeMappingRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -4069,11 +5207,11 @@ function validate$9(obj, path = 'ContextAttributeMappingRepresentation') {
         if (typeof obj_contextAttributeMappingId !== 'string') {
             return new TypeError('Expected "string" but received "' + typeof obj_contextAttributeMappingId + '" (at "' + path_contextAttributeMappingId + '")');
         }
-        if (obj.hydrationSource !== undefined) {
-            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 + '")');
+        if (obj.contextInputAttributeName !== undefined) {
+            const obj_contextInputAttributeName = obj.contextInputAttributeName;
+            const path_contextInputAttributeName = path + '.contextInputAttributeName';
+            if (typeof obj_contextInputAttributeName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_contextInputAttributeName + '" (at "' + path_contextInputAttributeName + '")');
             }
         }
         if (obj.isSuccess !== undefined) {
@@ -4144,7 +5282,7 @@ const select$l = function ContextAttributeMappingRepresentationSelect() {
                 kind: 'Scalar'
             },
             {
-                name: 'hydrationSource',
+                name: 'contextInputAttributeName',
                 kind: 'Scalar',
                 required: false
             },
@@ -4193,16 +5331,16 @@ function equals$5(existing, incoming) {
     if (!(existing_contextAttributeMappingId === incoming_contextAttributeMappingId)) {
         return false;
     }
-    const existing_hydrationSource = existing.hydrationSource;
-    const incoming_hydrationSource = incoming.hydrationSource;
+    const existing_contextInputAttributeName = existing.contextInputAttributeName;
+    const incoming_contextInputAttributeName = incoming.contextInputAttributeName;
     // if at least one of these optionals is defined
-    if (existing_hydrationSource !== undefined || incoming_hydrationSource !== undefined) {
+    if (existing_contextInputAttributeName !== undefined || incoming_contextInputAttributeName !== undefined) {
         // if one of these is not defined we know the other is defined and therefore
         // not equal
-        if (existing_hydrationSource === undefined || incoming_hydrationSource === undefined) {
+        if (existing_contextInputAttributeName === undefined || incoming_contextInputAttributeName === undefined) {
             return false;
         }
-        if (!(existing_hydrationSource === incoming_hydrationSource)) {
+        if (!(existing_contextInputAttributeName === incoming_contextInputAttributeName)) {
             return false;
         }
     }
@@ -4825,7 +5963,7 @@ function validate$6(obj, path = 'ContextDefinitionVersionRepresentation') {
             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$e(obj_contextNodes_item, path_contextNodes_item);
+                const referencepath_contextNodes_itemValidationError = validate$f(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');
@@ -4995,7 +6133,7 @@ function createResourceParams$k(config) {
 function typeCheckConfig$k(untrustedConfig) {
     const config = {};
     const untrustedConfig_contextDefinitionVersionInput = untrustedConfig.contextDefinitionVersionInput;
-    const referenceContextDefinitionVersionInputRepresentationValidationError = validate$b(untrustedConfig_contextDefinitionVersionInput);
+    const referenceContextDefinitionVersionInputRepresentationValidationError = validate$c(untrustedConfig_contextDefinitionVersionInput);
     if (referenceContextDefinitionVersionInputRepresentationValidationError === null) {
         config.contextDefinitionVersionInput = untrustedConfig_contextDefinitionVersionInput;
     }
@@ -5358,7 +6496,7 @@ function typeCheckConfig$h(untrustedConfig) {
         config.contextDefinitionVersionId = untrustedConfig_contextDefinitionVersionId;
     }
     const untrustedConfig_contextDefinitionVersionInput = untrustedConfig.contextDefinitionVersionInput;
-    const referenceContextDefinitionVersionInputRepresentationValidationError = validate$b(untrustedConfig_contextDefinitionVersionInput);
+    const referenceContextDefinitionVersionInputRepresentationValidationError = validate$c(untrustedConfig_contextDefinitionVersionInput);
     if (referenceContextDefinitionVersionInputRepresentationValidationError === null) {
         config.contextDefinitionVersionInput = untrustedConfig_contextDefinitionVersionInput;
     }
@@ -6010,7 +7148,7 @@ function typeCheckConfig$e(untrustedConfig) {
         config.contextDefinitionId = untrustedConfig_contextDefinitionId;
     }
     const untrustedConfig_contextDefinitionInput = untrustedConfig.contextDefinitionInput;
-    const referenceContextDefinitionInputRepresentationValidationError = validate$l(untrustedConfig_contextDefinitionInput);
+    const referenceContextDefinitionInputRepresentationValidationError = validate$m(untrustedConfig_contextDefinitionInput);
     if (referenceContextDefinitionInputRepresentationValidationError === null) {
         config.contextDefinitionInput = untrustedConfig_contextDefinitionInput;
     }
@@ -6238,6 +7376,13 @@ function validate$3(obj, path = 'ContextAttributeMappingInputRepresentation') {
         if (typeof obj_contextAttributeId !== 'string') {
             return new TypeError('Expected "string" but received "' + typeof obj_contextAttributeId + '" (at "' + path_contextAttributeId + '")');
         }
+        if (obj.contextInputAttributeName !== undefined) {
+            const obj_contextInputAttributeName = obj.contextInputAttributeName;
+            const path_contextInputAttributeName = path + '.contextInputAttributeName';
+            if (typeof obj_contextInputAttributeName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_contextInputAttributeName + '" (at "' + path_contextInputAttributeName + '")');
+            }
+        }
         if (obj.deleteExistingHydrationDetail !== undefined) {
             const obj_deleteExistingHydrationDetail = obj.deleteExistingHydrationDetail;
             const path_deleteExistingHydrationDetail = path + '.deleteExistingHydrationDetail';
@@ -6245,11 +7390,6 @@ function validate$3(obj, path = 'ContextAttributeMappingInputRepresentation') {
                 return new TypeError('Expected "boolean" but received "' + typeof obj_deleteExistingHydrationDetail + '" (at "' + path_deleteExistingHydrationDetail + '")');
             }
         }
-        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 + '")');
-        }
         if (obj.parentNodeMappingId !== undefined) {
             const obj_parentNodeMappingId = obj.parentNodeMappingId;
             const path_parentNodeMappingId = path + '.parentNodeMappingId';
@@ -7990,4 +9130,4 @@ const putContextServiceAccessAdapterFactory = (luvio) => {
     };
 };
 
-export { createContextAttributeAdapterFactory, createContextAttributeListAdapterFactory, createContextAttributeMappingAdapterFactory, createContextAttributeTagAdapterFactory, createContextDefinitionAdapterFactory, createContextDefinitionVersionAdapterFactory, createContextMappingAdapterFactory, createContextNodeAdapterFactory, createContextNodeMappingAdapterFactory, deleteContextAttributeAdapterFactory, deleteContextAttributeMappingAdapterFactory, deleteContextAttributeTagAdapterFactory, deleteContextDefinitionAdapterFactory, deleteContextDefinitionVersionAdapterFactory, deleteContextMappingAdapterFactory, deleteContextNodeAdapterFactory, deleteContextNodeMappingAdapterFactory, getContextAttributeAdapterFactory, getContextAttributeMappingAdapterFactory, getContextAttributeTagAdapterFactory, getContextAttributeTagsByAttributeIdAdapterFactory, getContextDefinitionAdapterFactory, getContextDefinitionInfoAdapterFactory, getContextDefinitionListAdapterFactory, getContextDefinitionVersionAdapterFactory, getContextMappingAdapterFactory, getContextNodeAdapterFactory, getContextNodeMappingAdapterFactory, getContextServiceAccessAdapterFactory, putContextServiceAccessAdapterFactory, updateContextAttributeAdapterFactory, updateContextAttributeMappingAdapterFactory, updateContextAttributeTagAdapterFactory, updateContextDefinitionAdapterFactory, updateContextDefinitionVersionAdapterFactory, updateContextMappingAdapterFactory, updateContextNodeAdapterFactory, updateContextNodeMappingAdapterFactory };
+export { createContextAttributeAdapterFactory, createContextAttributeListAdapterFactory, createContextAttributeMappingAdapterFactory, createContextAttributeTagAdapterFactory, createContextDefinitionAdapterFactory, createContextDefinitionVersionAdapterFactory, createContextMappingAdapterFactory, createContextNodeAdapterFactory, createContextNodeMappingAdapterFactory, deleteContextAttributeAdapterFactory, deleteContextAttributeMappingAdapterFactory, deleteContextAttributeTagAdapterFactory, deleteContextDefinitionAdapterFactory, deleteContextDefinitionVersionAdapterFactory, deleteContextMappingAdapterFactory, deleteContextNodeAdapterFactory, deleteContextNodeMappingAdapterFactory, getContextAdapterFactory, getContextAttributeAdapterFactory, getContextAttributeMappingAdapterFactory, getContextAttributeTagAdapterFactory, getContextAttributeTagsByAttributeIdAdapterFactory, getContextDefinitionAdapterFactory, getContextDefinitionInfoAdapterFactory, getContextDefinitionListAdapterFactory, getContextDefinitionVersionAdapterFactory, getContextMappingAdapterFactory, getContextNodeAdapterFactory, getContextNodeMappingAdapterFactory, getContextServiceAccessAdapterFactory, putContextServiceAccessAdapterFactory, queryContextRecordAndChildrenAdapterFactory, updateContextAttributeAdapterFactory, updateContextAttributeMappingAdapterFactory, updateContextAttributeTagAdapterFactory, updateContextDefinitionAdapterFactory, updateContextDefinitionVersionAdapterFactory, updateContextMappingAdapterFactory, updateContextNodeAdapterFactory, updateContextNodeMappingAdapterFactory };