@salesforce/lds-adapters-cdp-personalization-service 1.302.0 → 1.304.0

package/dist/es/es2018/cdp-personalization-service.js

@@ -72,6 +72,7 @@ function buildAdapterValidationConfig(displayName, paramsMeta) {
 const keyPrefix = 'personalization-service';
 
 const { isArray: ArrayIsArray } = Array;
+const { stringify: JSONStringify } = JSON;
 function equalsArray(a, b, equalsItem) {
     const aLength = a.length;
     const bLength = b.length;
@@ -91,7 +92,7 @@ function createLink(ref) {
     };
 }
 
-function validate$7(obj, path = 'PersonalizationAttributeValueInputRepresentation') {
+function validate$b(obj, path = 'PersonalizationAttributeValueInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -178,7 +179,7 @@ function validate$7(obj, path = 'PersonalizationAttributeValueInputRepresentatio
     return v_error === undefined ? null : v_error;
 }
 
-function validate$6(obj, path = 'PersonalizationDecisionInputRepresentation') {
+function validate$a(obj, path = 'PersonalizationDecisionInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -191,7 +192,7 @@ function validate$6(obj, path = 'PersonalizationDecisionInputRepresentation') {
         for (let i = 0; i < obj_attributeValues.length; i++) {
             const obj_attributeValues_item = obj_attributeValues[i];
             const path_attributeValues_item = path_attributeValues + '[' + i + ']';
-            const referencepath_attributeValues_itemValidationError = validate$7(obj_attributeValues_item, path_attributeValues_item);
+            const referencepath_attributeValues_itemValidationError = validate$b(obj_attributeValues_item, path_attributeValues_item);
             if (referencepath_attributeValues_itemValidationError !== null) {
                 let message = 'Object doesn\'t match PersonalizationAttributeValueInputRepresentation (at "' + path_attributeValues_item + '")\n';
                 message += referencepath_attributeValues_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -332,8 +333,8 @@ function validate$6(obj, path = 'PersonalizationDecisionInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const VERSION$4 = "52ea9c14b7a747a28cedbcff0e7ab169";
-function validate$5(obj, path = 'PersonalizationAttributeValueRepresentation') {
+const VERSION$6 = "52ea9c14b7a747a28cedbcff0e7ab169";
+function validate$9(obj, path = 'PersonalizationAttributeValueRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -419,10 +420,10 @@ function validate$5(obj, path = 'PersonalizationAttributeValueRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$9 = function PersonalizationAttributeValueRepresentationSelect() {
+const select$b = function PersonalizationAttributeValueRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$4,
+        version: VERSION$6,
         private: [],
         selections: [
             {
@@ -440,7 +441,7 @@ const select$9 = function PersonalizationAttributeValueRepresentationSelect() {
         ]
     };
 };
-function equals$4(existing, incoming) {
+function equals$6(existing, incoming) {
     const existing_attributeEnum = existing.attributeEnum;
     const incoming_attributeEnum = incoming.attributeEnum;
     if (!(existing_attributeEnum === incoming_attributeEnum)) {
@@ -459,7 +460,656 @@ function equals$4(existing, incoming) {
     return true;
 }
 
-const VERSION$3 = "a3c1b816177380fe8095a6b0eb674f08";
+function validate$8(obj, path = 'FiltersWrapRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.filters !== undefined) {
+            const obj_filters = obj.filters;
+            const path_filters = path + '.filters';
+            if (!ArrayIsArray(obj_filters)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_filters + '" (at "' + path_filters + '")');
+            }
+            for (let i = 0; i < obj_filters.length; i++) {
+                const obj_filters_item = obj_filters[i];
+                const path_filters_item = path_filters + '[' + i + ']';
+                if (typeof obj_filters_item !== 'object') {
+                    return new TypeError('Expected "object" but received "' + typeof obj_filters_item + '" (at "' + path_filters_item + '")');
+                }
+            }
+        }
+        if (obj.operator !== undefined) {
+            const obj_operator = obj.operator;
+            const path_operator = path + '.operator';
+            let obj_operator_union0 = null;
+            const obj_operator_union0_error = (() => {
+                if (typeof obj_operator !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_operator + '" (at "' + path_operator + '")');
+                }
+            })();
+            if (obj_operator_union0_error != null) {
+                obj_operator_union0 = obj_operator_union0_error.message;
+            }
+            let obj_operator_union1 = null;
+            const obj_operator_union1_error = (() => {
+                if (obj_operator !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_operator + '" (at "' + path_operator + '")');
+                }
+            })();
+            if (obj_operator_union1_error != null) {
+                obj_operator_union1 = obj_operator_union1_error.message;
+            }
+            if (obj_operator_union0 && obj_operator_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_operator + '")';
+                message += '\n' + obj_operator_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_operator_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.type !== undefined) {
+            const obj_type = obj.type;
+            const path_type = path + '.type';
+            let obj_type_union0 = null;
+            const obj_type_union0_error = (() => {
+                if (typeof obj_type !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_type + '" (at "' + path_type + '")');
+                }
+            })();
+            if (obj_type_union0_error != null) {
+                obj_type_union0 = obj_type_union0_error.message;
+            }
+            let obj_type_union1 = null;
+            const obj_type_union1_error = (() => {
+                if (obj_type !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_type + '" (at "' + path_type + '")');
+                }
+            })();
+            if (obj_type_union1_error != null) {
+                obj_type_union1 = obj_type_union1_error.message;
+            }
+            if (obj_type_union0 && obj_type_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_type + '")';
+                message += '\n' + obj_type_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_type_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$7(obj, path = 'SubjectRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_fieldApiName = obj.fieldApiName;
+        const path_fieldApiName = path + '.fieldApiName';
+        if (typeof obj_fieldApiName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_fieldApiName + '" (at "' + path_fieldApiName + '")');
+        }
+        if (obj.fieldLabel !== undefined) {
+            const obj_fieldLabel = obj.fieldLabel;
+            const path_fieldLabel = path + '.fieldLabel';
+            if (typeof obj_fieldLabel !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_fieldLabel + '" (at "' + path_fieldLabel + '")');
+            }
+        }
+        const obj_objectApiName = obj.objectApiName;
+        const path_objectApiName = path + '.objectApiName';
+        if (typeof obj_objectApiName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_objectApiName + '" (at "' + path_objectApiName + '")');
+        }
+        if (obj.objectLabel !== undefined) {
+            const obj_objectLabel = obj.objectLabel;
+            const path_objectLabel = path + '.objectLabel';
+            if (typeof obj_objectLabel !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_objectLabel + '" (at "' + path_objectLabel + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+const VERSION$5 = "437fc3300d85b1cb5bc34ec53413937d";
+function validate$6(obj, path = 'FilterRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.aggregateFunction !== undefined) {
+            const obj_aggregateFunction = obj.aggregateFunction;
+            const path_aggregateFunction = path + '.aggregateFunction';
+            let obj_aggregateFunction_union0 = null;
+            const obj_aggregateFunction_union0_error = (() => {
+                if (typeof obj_aggregateFunction !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_aggregateFunction + '" (at "' + path_aggregateFunction + '")');
+                }
+            })();
+            if (obj_aggregateFunction_union0_error != null) {
+                obj_aggregateFunction_union0 = obj_aggregateFunction_union0_error.message;
+            }
+            let obj_aggregateFunction_union1 = null;
+            const obj_aggregateFunction_union1_error = (() => {
+                if (obj_aggregateFunction !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_aggregateFunction + '" (at "' + path_aggregateFunction + '")');
+                }
+            })();
+            if (obj_aggregateFunction_union1_error != null) {
+                obj_aggregateFunction_union1 = obj_aggregateFunction_union1_error.message;
+            }
+            if (obj_aggregateFunction_union0 && obj_aggregateFunction_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_aggregateFunction + '")';
+                message += '\n' + obj_aggregateFunction_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_aggregateFunction_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.comparison !== undefined) {
+            const obj_comparison = obj.comparison;
+            const path_comparison = path + '.comparison';
+            let obj_comparison_union0 = null;
+            const obj_comparison_union0_error = (() => {
+                const referencepath_comparisonValidationError = validate$6(obj_comparison, path_comparison);
+                if (referencepath_comparisonValidationError !== null) {
+                    let message = 'Object doesn\'t match FilterRepresentation (at "' + path_comparison + '")\n';
+                    message += referencepath_comparisonValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            })();
+            if (obj_comparison_union0_error != null) {
+                obj_comparison_union0 = obj_comparison_union0_error.message;
+            }
+            let obj_comparison_union1 = null;
+            const obj_comparison_union1_error = (() => {
+                if (obj_comparison !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_comparison + '" (at "' + path_comparison + '")');
+                }
+            })();
+            if (obj_comparison_union1_error != null) {
+                obj_comparison_union1 = obj_comparison_union1_error.message;
+            }
+            if (obj_comparison_union0 && obj_comparison_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_comparison + '")';
+                message += '\n' + obj_comparison_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_comparison_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.filter !== undefined) {
+            const obj_filter = obj.filter;
+            const path_filter = path + '.filter';
+            let obj_filter_union0 = null;
+            const obj_filter_union0_error = (() => {
+                const referencepath_filterValidationError = validate$8(obj_filter, path_filter);
+                if (referencepath_filterValidationError !== null) {
+                    let message = 'Object doesn\'t match FiltersWrapRepresentation (at "' + path_filter + '")\n';
+                    message += referencepath_filterValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            })();
+            if (obj_filter_union0_error != null) {
+                obj_filter_union0 = obj_filter_union0_error.message;
+            }
+            let obj_filter_union1 = null;
+            const obj_filter_union1_error = (() => {
+                if (obj_filter !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_filter + '" (at "' + path_filter + '")');
+                }
+            })();
+            if (obj_filter_union1_error != null) {
+                obj_filter_union1 = obj_filter_union1_error.message;
+            }
+            if (obj_filter_union0 && obj_filter_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_filter + '")';
+                message += '\n' + obj_filter_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_filter_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.filters !== undefined) {
+            const obj_filters = obj.filters;
+            const path_filters = path + '.filters';
+            if (!ArrayIsArray(obj_filters)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_filters + '" (at "' + path_filters + '")');
+            }
+            for (let i = 0; i < obj_filters.length; i++) {
+                const obj_filters_item = obj_filters[i];
+                const path_filters_item = path_filters + '[' + i + ']';
+                let obj_filters_item_union0 = null;
+                const obj_filters_item_union0_error = (() => {
+                    const referencepath_filters_itemValidationError = validate$6(obj_filters_item, path_filters_item);
+                    if (referencepath_filters_itemValidationError !== null) {
+                        let message = 'Object doesn\'t match FilterRepresentation (at "' + path_filters_item + '")\n';
+                        message += referencepath_filters_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                        return new TypeError(message);
+                    }
+                })();
+                if (obj_filters_item_union0_error != null) {
+                    obj_filters_item_union0 = obj_filters_item_union0_error.message;
+                }
+                let obj_filters_item_union1 = null;
+                const obj_filters_item_union1_error = (() => {
+                    if (obj_filters_item !== null) {
+                        return new TypeError('Expected "null" but received "' + typeof obj_filters_item + '" (at "' + path_filters_item + '")');
+                    }
+                })();
+                if (obj_filters_item_union1_error != null) {
+                    obj_filters_item_union1 = obj_filters_item_union1_error.message;
+                }
+                if (obj_filters_item_union0 && obj_filters_item_union1) {
+                    let message = 'Object doesn\'t match union (at "' + path_filters_item + '")';
+                    message += '\n' + obj_filters_item_union0.split('\n').map((line) => '\t' + line).join('\n');
+                    message += '\n' + obj_filters_item_union1.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+        if (obj.firstBoundValue !== undefined) {
+            const obj_firstBoundValue = obj.firstBoundValue;
+            const path_firstBoundValue = path + '.firstBoundValue';
+            let obj_firstBoundValue_union0 = null;
+            const obj_firstBoundValue_union0_error = (() => {
+                if (typeof obj_firstBoundValue !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_firstBoundValue + '" (at "' + path_firstBoundValue + '")');
+                }
+            })();
+            if (obj_firstBoundValue_union0_error != null) {
+                obj_firstBoundValue_union0 = obj_firstBoundValue_union0_error.message;
+            }
+            let obj_firstBoundValue_union1 = null;
+            const obj_firstBoundValue_union1_error = (() => {
+                if (obj_firstBoundValue !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_firstBoundValue + '" (at "' + path_firstBoundValue + '")');
+                }
+            })();
+            if (obj_firstBoundValue_union1_error != null) {
+                obj_firstBoundValue_union1 = obj_firstBoundValue_union1_error.message;
+            }
+            if (obj_firstBoundValue_union0 && obj_firstBoundValue_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_firstBoundValue + '")';
+                message += '\n' + obj_firstBoundValue_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_firstBoundValue_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.operator !== undefined) {
+            const obj_operator = obj.operator;
+            const path_operator = path + '.operator';
+            let obj_operator_union0 = null;
+            const obj_operator_union0_error = (() => {
+                if (typeof obj_operator !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_operator + '" (at "' + path_operator + '")');
+                }
+            })();
+            if (obj_operator_union0_error != null) {
+                obj_operator_union0 = obj_operator_union0_error.message;
+            }
+            let obj_operator_union1 = null;
+            const obj_operator_union1_error = (() => {
+                if (obj_operator !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_operator + '" (at "' + path_operator + '")');
+                }
+            })();
+            if (obj_operator_union1_error != null) {
+                obj_operator_union1 = obj_operator_union1_error.message;
+            }
+            if (obj_operator_union0 && obj_operator_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_operator + '")';
+                message += '\n' + obj_operator_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_operator_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.path !== undefined) {
+            const obj_path = obj.path;
+            const path_path = path + '.path';
+            if (!ArrayIsArray(obj_path)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_path + '" (at "' + path_path + '")');
+            }
+            for (let i = 0; i < obj_path.length; i++) {
+                const obj_path_item = obj_path[i];
+                const path_path_item = path_path + '[' + i + ']';
+                if (!ArrayIsArray(obj_path_item)) {
+                    return new TypeError('Expected "array" but received "' + typeof obj_path_item + '" (at "' + path_path_item + '")');
+                }
+                for (let i = 0; i < obj_path_item.length; i++) {
+                    const obj_path_item_item = obj_path_item[i];
+                    const path_path_item_item = path_path_item + '[' + i + ']';
+                    const referencepath_path_item_itemValidationError = validate$7(obj_path_item_item, path_path_item_item);
+                    if (referencepath_path_item_itemValidationError !== null) {
+                        let message = 'Object doesn\'t match SubjectRepresentation (at "' + path_path_item_item + '")\n';
+                        message += referencepath_path_item_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                        return new TypeError(message);
+                    }
+                }
+            }
+        }
+        if (obj.ruleTimeZone !== undefined) {
+            const obj_ruleTimeZone = obj.ruleTimeZone;
+            const path_ruleTimeZone = path + '.ruleTimeZone';
+            let obj_ruleTimeZone_union0 = null;
+            const obj_ruleTimeZone_union0_error = (() => {
+                if (typeof obj_ruleTimeZone !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_ruleTimeZone + '" (at "' + path_ruleTimeZone + '")');
+                }
+            })();
+            if (obj_ruleTimeZone_union0_error != null) {
+                obj_ruleTimeZone_union0 = obj_ruleTimeZone_union0_error.message;
+            }
+            let obj_ruleTimeZone_union1 = null;
+            const obj_ruleTimeZone_union1_error = (() => {
+                if (obj_ruleTimeZone !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_ruleTimeZone + '" (at "' + path_ruleTimeZone + '")');
+                }
+            })();
+            if (obj_ruleTimeZone_union1_error != null) {
+                obj_ruleTimeZone_union1 = obj_ruleTimeZone_union1_error.message;
+            }
+            if (obj_ruleTimeZone_union0 && obj_ruleTimeZone_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_ruleTimeZone + '")';
+                message += '\n' + obj_ruleTimeZone_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_ruleTimeZone_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.secondBoundValue !== undefined) {
+            const obj_secondBoundValue = obj.secondBoundValue;
+            const path_secondBoundValue = path + '.secondBoundValue';
+            let obj_secondBoundValue_union0 = null;
+            const obj_secondBoundValue_union0_error = (() => {
+                if (typeof obj_secondBoundValue !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_secondBoundValue + '" (at "' + path_secondBoundValue + '")');
+                }
+            })();
+            if (obj_secondBoundValue_union0_error != null) {
+                obj_secondBoundValue_union0 = obj_secondBoundValue_union0_error.message;
+            }
+            let obj_secondBoundValue_union1 = null;
+            const obj_secondBoundValue_union1_error = (() => {
+                if (obj_secondBoundValue !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_secondBoundValue + '" (at "' + path_secondBoundValue + '")');
+                }
+            })();
+            if (obj_secondBoundValue_union1_error != null) {
+                obj_secondBoundValue_union1 = obj_secondBoundValue_union1_error.message;
+            }
+            if (obj_secondBoundValue_union0 && obj_secondBoundValue_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_secondBoundValue + '")';
+                message += '\n' + obj_secondBoundValue_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_secondBoundValue_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.subject !== undefined) {
+            const obj_subject = obj.subject;
+            const path_subject = path + '.subject';
+            let obj_subject_union0 = null;
+            const obj_subject_union0_error = (() => {
+                const referencepath_subjectValidationError = validate$7(obj_subject, path_subject);
+                if (referencepath_subjectValidationError !== null) {
+                    let message = 'Object doesn\'t match SubjectRepresentation (at "' + path_subject + '")\n';
+                    message += referencepath_subjectValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            })();
+            if (obj_subject_union0_error != null) {
+                obj_subject_union0 = obj_subject_union0_error.message;
+            }
+            let obj_subject_union1 = null;
+            const obj_subject_union1_error = (() => {
+                if (obj_subject !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_subject + '" (at "' + path_subject + '")');
+                }
+            })();
+            if (obj_subject_union1_error != null) {
+                obj_subject_union1 = obj_subject_union1_error.message;
+            }
+            if (obj_subject_union0 && obj_subject_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_subject + '")';
+                message += '\n' + obj_subject_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_subject_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.type !== undefined) {
+            const obj_type = obj.type;
+            const path_type = path + '.type';
+            let obj_type_union0 = null;
+            const obj_type_union0_error = (() => {
+                if (typeof obj_type !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_type + '" (at "' + path_type + '")');
+                }
+            })();
+            if (obj_type_union0_error != null) {
+                obj_type_union0 = obj_type_union0_error.message;
+            }
+            let obj_type_union1 = null;
+            const obj_type_union1_error = (() => {
+                if (obj_type !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_type + '" (at "' + path_type + '")');
+                }
+            })();
+            if (obj_type_union1_error != null) {
+                obj_type_union1 = obj_type_union1_error.message;
+            }
+            if (obj_type_union0 && obj_type_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_type + '")';
+                message += '\n' + obj_type_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_type_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.value !== undefined) {
+            const obj_value = obj.value;
+            const path_value = path + '.value';
+            let obj_value_union0 = null;
+            const obj_value_union0_error = (() => {
+                if (typeof obj_value !== 'number' || (typeof obj_value === 'number' && Math.floor(obj_value) !== obj_value)) {
+                    return new TypeError('Expected "integer" but received "' + typeof obj_value + '" (at "' + path_value + '")');
+                }
+            })();
+            if (obj_value_union0_error != null) {
+                obj_value_union0 = obj_value_union0_error.message;
+            }
+            let obj_value_union1 = null;
+            const obj_value_union1_error = (() => {
+                if (obj_value !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_value + '" (at "' + path_value + '")');
+                }
+            })();
+            if (obj_value_union1_error != null) {
+                obj_value_union1 = obj_value_union1_error.message;
+            }
+            if (obj_value_union0 && obj_value_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_value + '")';
+                message += '\n' + obj_value_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_value_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.values !== undefined) {
+            const obj_values = obj.values;
+            const path_values = path + '.values';
+            if (!ArrayIsArray(obj_values)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_values + '" (at "' + path_values + '")');
+            }
+            for (let i = 0; i < obj_values.length; i++) {
+                const obj_values_item = obj_values[i];
+                const path_values_item = path_values + '[' + i + ']';
+                if (typeof obj_values_item !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_values_item + '" (at "' + path_values_item + '")');
+                }
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$4 = 'FilterRepresentation';
+function normalize$4(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$a = function FilterRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$5,
+        private: [],
+        opaque: true
+    };
+};
+function equals$5(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
+const ingest$4 = function FilterRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$6(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = path.fullPath;
+    const ttlToUse = path.ttl;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$4, "personalization-service", VERSION$5, RepresentationType$4, equals$5);
+    return createLink(key);
+};
+function getTypeCacheKeys$4(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = fullPathFactory();
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$4,
+        mergeable: false
+    });
+}
+
+const VERSION$4 = "ea475f10b4c028f8b97a44af1cf0be14";
+function validate$5(obj, path = 'CriteriaRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_filters = obj.filters;
+        const path_filters = path + '.filters';
+        if (!ArrayIsArray(obj_filters)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_filters + '" (at "' + path_filters + '")');
+        }
+        for (let i = 0; i < obj_filters.length; i++) {
+            const obj_filters_item = obj_filters[i];
+            const path_filters_item = path_filters + '[' + i + ']';
+            if (typeof obj_filters_item !== 'object') {
+                return new TypeError('Expected "object" but received "' + typeof obj_filters_item + '" (at "' + path_filters_item + '")');
+            }
+        }
+        const obj_operator = obj.operator;
+        const path_operator = path + '.operator';
+        if (typeof obj_operator !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_operator + '" (at "' + path_operator + '")');
+        }
+        const obj_type = obj.type;
+        const path_type = path + '.type';
+        if (typeof obj_type !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_type + '" (at "' + path_type + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$3 = 'CriteriaRepresentation';
+function normalize$3(input, existing, path, luvio, store, timestamp) {
+    const input_filters = input.filters;
+    const input_filters_id = path.fullPath + '__filters';
+    for (let i = 0; i < input_filters.length; i++) {
+        const input_filters_item = input_filters[i];
+        let input_filters_item_id = input_filters_id + '__' + i;
+        input_filters[i] = ingest$4(input_filters_item, {
+            fullPath: input_filters_item_id,
+            propertyName: i,
+            parent: {
+                data: input,
+                key: path.fullPath,
+                existing: existing,
+            },
+            ttl: path.ttl
+        }, luvio, store, timestamp);
+    }
+    return input;
+}
+const select$9 = function CriteriaRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$4,
+        private: [],
+        selections: [
+            {
+                name: 'filters',
+                kind: 'Link',
+                plural: true,
+                fragment: select$a()
+            },
+            {
+                name: 'operator',
+                kind: 'Scalar'
+            },
+            {
+                name: 'type',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$4(existing, incoming) {
+    const existing_operator = existing.operator;
+    const incoming_operator = incoming.operator;
+    if (!(existing_operator === incoming_operator)) {
+        return false;
+    }
+    const existing_type = existing.type;
+    const incoming_type = incoming.type;
+    if (!(existing_type === incoming_type)) {
+        return false;
+    }
+    const existing_filters = existing.filters;
+    const incoming_filters = incoming.filters;
+    const equals_filters_items = equalsArray(existing_filters, incoming_filters, (existing_filters_item, incoming_filters_item) => {
+        if (!(existing_filters_item.__ref === incoming_filters_item.__ref)) {
+            return false;
+        }
+    });
+    if (equals_filters_items === false) {
+        return false;
+    }
+    return true;
+}
+const ingest$3 = function CriteriaRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$5(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = path.fullPath;
+    const ttlToUse = path.ttl;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$3, "personalization-service", VERSION$4, RepresentationType$3, equals$4);
+    return createLink(key);
+};
+function getTypeCacheKeys$3(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = fullPathFactory();
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$3,
+        mergeable: false
+    });
+    const input_filters_length = input.filters.length;
+    for (let i = 0; i < input_filters_length; i++) {
+        getTypeCacheKeys$4(rootKeySet, luvio, input.filters[i], () => '');
+    }
+}
+
+const VERSION$3 = "4c6e23e63e764c028a88f2f6c2f7c6a3";
 function validate$4(obj, path = 'PersonalizationDecisionRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -473,7 +1123,7 @@ function validate$4(obj, path = 'PersonalizationDecisionRepresentation') {
         for (let i = 0; i < obj_attributeValues.length; i++) {
             const obj_attributeValues_item = obj_attributeValues[i];
             const path_attributeValues_item = path_attributeValues + '[' + i + ']';
-            const referencepath_attributeValues_itemValidationError = validate$5(obj_attributeValues_item, path_attributeValues_item);
+            const referencepath_attributeValues_itemValidationError = validate$9(obj_attributeValues_item, path_attributeValues_item);
             if (referencepath_attributeValues_itemValidationError !== null) {
                 let message = 'Object doesn\'t match PersonalizationAttributeValueRepresentation (at "' + path_attributeValues_item + '")\n';
                 message += referencepath_attributeValues_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -536,8 +1186,8 @@ function validate$4(obj, path = 'PersonalizationDecisionRepresentation') {
         const path_criteria = path + '.criteria';
         let obj_criteria_union0 = null;
         const obj_criteria_union0_error = (() => {
-            if (typeof obj_criteria !== 'string') {
-                return new TypeError('Expected "string" but received "' + typeof obj_criteria + '" (at "' + path_criteria + '")');
+            if (typeof obj_criteria !== 'object') {
+                return new TypeError('Expected "object" but received "' + typeof obj_criteria + '" (at "' + path_criteria + '")');
             }
         })();
         if (obj_criteria_union0_error != null) {
@@ -769,8 +1419,26 @@ function validate$4(obj, path = 'PersonalizationDecisionRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
+const RepresentationType$2 = 'PersonalizationDecisionRepresentation';
+function normalize$2(input, existing, path, luvio, store, timestamp) {
+    const input_criteria = input.criteria;
+    const input_criteria_id = path.fullPath + '__criteria';
+    if (input_criteria !== null && typeof input_criteria === 'object') {
+        input.criteria = ingest$3(input_criteria, {
+            fullPath: input_criteria_id,
+            propertyName: 'criteria',
+            parent: {
+                data: input,
+                key: path.fullPath,
+                existing: existing,
+            },
+            ttl: path.ttl
+        }, luvio, store, timestamp);
+    }
+    return input;
+}
 const select$8 = function PersonalizationDecisionRepresentationSelect() {
-    const { selections: PersonalizationAttributeValueRepresentation__selections, opaque: PersonalizationAttributeValueRepresentation__opaque, } = select$9();
+    const { selections: PersonalizationAttributeValueRepresentation__selections, opaque: PersonalizationAttributeValueRepresentation__opaque, } = select$b();
     return {
         kind: 'Fragment',
         version: VERSION$3,
@@ -792,7 +1460,9 @@ const select$8 = function PersonalizationDecisionRepresentationSelect() {
             },
             {
                 name: 'criteria',
-                kind: 'Scalar'
+                kind: 'Link',
+                nullable: true,
+                fragment: select$9()
             },
             {
                 name: 'description',
@@ -833,7 +1503,7 @@ function equals$3(existing, incoming) {
     const existing_attributeValues = existing.attributeValues;
     const incoming_attributeValues = incoming.attributeValues;
     const equals_attributeValues_items = equalsArray(existing_attributeValues, incoming_attributeValues, (existing_attributeValues_item, incoming_attributeValues_item) => {
-        if (!(equals$4(existing_attributeValues_item, incoming_attributeValues_item))) {
+        if (!(equals$6(existing_attributeValues_item, incoming_attributeValues_item))) {
             return false;
         }
     });
@@ -852,7 +1522,12 @@ function equals$3(existing, incoming) {
     }
     const existing_criteria = existing.criteria;
     const incoming_criteria = incoming.criteria;
-    if (!(existing_criteria === incoming_criteria)) {
+    if (!(existing_criteria === incoming_criteria
+        || (existing_criteria != null &&
+            incoming_criteria != null &&
+            existing_criteria.__ref != null &&
+            incoming_criteria.__ref != null &&
+            existing_criteria.__ref === incoming_criteria.__ref))) {
         return false;
     }
     const existing_description = existing.description;
@@ -897,9 +1572,33 @@ function equals$3(existing, incoming) {
     }
     return true;
 }
+const ingest$2 = function PersonalizationDecisionRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$4(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = path.fullPath;
+    const ttlToUse = path.ttl;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$2, "personalization-service", VERSION$3, RepresentationType$2, equals$3);
+    return createLink(key);
+};
+function getTypeCacheKeys$2(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = fullPathFactory();
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$2,
+        mergeable: false
+    });
+    if (input.criteria !== null && typeof input.criteria === 'object') {
+        getTypeCacheKeys$3(rootKeySet, luvio, input.criteria, () => rootKey + "__" + "criteria");
+    }
+}
 
 const TTL$1 = 600;
-const VERSION$2 = "ee1ca8342609b01b292f149ed9209840";
+const VERSION$2 = "da1bfa46416530ff1aeab78ba84646bb";
 function validate$3(obj, path = 'PersonalizationPointRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -1017,11 +1716,8 @@ function validate$3(obj, path = 'PersonalizationPointRepresentation') {
         for (let i = 0; i < obj_decisions.length; i++) {
             const obj_decisions_item = obj_decisions[i];
             const path_decisions_item = path_decisions + '[' + i + ']';
-            const referencepath_decisions_itemValidationError = validate$4(obj_decisions_item, path_decisions_item);
-            if (referencepath_decisions_itemValidationError !== null) {
-                let message = 'Object doesn\'t match PersonalizationDecisionRepresentation (at "' + path_decisions_item + '")\n';
-                message += referencepath_decisions_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
-                return new TypeError(message);
+            if (typeof obj_decisions_item !== 'object') {
+                return new TypeError('Expected "object" but received "' + typeof obj_decisions_item + '" (at "' + path_decisions_item + '")');
             }
         }
         const obj_description = obj.description;
@@ -1308,10 +2004,25 @@ function keyBuilderFromType$1(luvio, object) {
     return keyBuilder$7(luvio, keyParams);
 }
 function normalize$1(input, existing, path, luvio, store, timestamp) {
+    const input_decisions = input.decisions;
+    const input_decisions_id = path.fullPath + '__decisions';
+    for (let i = 0; i < input_decisions.length; i++) {
+        const input_decisions_item = input_decisions[i];
+        let input_decisions_item_id = input_decisions_id + '__' + i;
+        input_decisions[i] = ingest$2(input_decisions_item, {
+            fullPath: input_decisions_item_id,
+            propertyName: i,
+            parent: {
+                data: input,
+                key: path.fullPath,
+                existing: existing,
+            },
+            ttl: path.ttl
+        }, luvio, store, timestamp);
+    }
     return input;
 }
 const select$7 = function PersonalizationPointRepresentationSelect() {
-    const { selections: PersonalizationDecisionRepresentation__selections, opaque: PersonalizationDecisionRepresentation__opaque, } = select$8();
     return {
         kind: 'Fragment',
         version: VERSION$2,
@@ -1335,9 +2046,9 @@ const select$7 = function PersonalizationPointRepresentationSelect() {
             },
             {
                 name: 'decisions',
-                kind: 'Object',
+                kind: 'Link',
                 plural: true,
-                selections: PersonalizationDecisionRepresentation__selections
+                fragment: select$8()
             },
             {
                 name: 'description',
@@ -1424,7 +2135,7 @@ function equals$2(existing, incoming) {
     const existing_decisions = existing.decisions;
     const incoming_decisions = incoming.decisions;
     const equals_decisions_items = equalsArray(existing_decisions, incoming_decisions, (existing_decisions_item, incoming_decisions_item) => {
-        if (!(equals$3(existing_decisions_item, incoming_decisions_item))) {
+        if (!(existing_decisions_item.__ref === incoming_decisions_item.__ref)) {
             return false;
         }
     });
@@ -1503,6 +2214,10 @@ function getTypeCacheKeys$1(rootKeySet, luvio, input, fullPathFactory) {
         representationName: RepresentationType$1,
         mergeable: false
     });
+    const input_decisions_length = input.decisions.length;
+    for (let i = 0; i < input_decisions_length; i++) {
+        getTypeCacheKeys$2(rootKeySet, luvio, input.decisions[i], () => '');
+    }
 }
 
 function select$6(luvio, params) {
@@ -1600,7 +2315,7 @@ function typeCheckConfig$6(untrustedConfig) {
         const untrustedConfig_decisions_array = [];
         for (let i = 0, arrayLength = untrustedConfig_decisions.length; i < arrayLength; i++) {
             const untrustedConfig_decisions_item = untrustedConfig_decisions[i];
-            const referencePersonalizationDecisionInputRepresentationValidationError = validate$6(untrustedConfig_decisions_item);
+            const referencePersonalizationDecisionInputRepresentationValidationError = validate$a(untrustedConfig_decisions_item);
             if (referencePersonalizationDecisionInputRepresentationValidationError === null) {
                 untrustedConfig_decisions_array.push(untrustedConfig_decisions_item);
             }
@@ -1992,7 +2707,7 @@ function typeCheckConfig$3(untrustedConfig) {
         const untrustedConfig_decisions_array = [];
         for (let i = 0, arrayLength = untrustedConfig_decisions.length; i < arrayLength; i++) {
             const untrustedConfig_decisions_item = untrustedConfig_decisions[i];
-            const referencePersonalizationDecisionInputRepresentationValidationError = validate$6(untrustedConfig_decisions_item);
+            const referencePersonalizationDecisionInputRepresentationValidationError = validate$a(untrustedConfig_decisions_item);
             if (referencePersonalizationDecisionInputRepresentationValidationError === null) {
                 untrustedConfig_decisions_array.push(untrustedConfig_decisions_item);
             }