@salesforce/lds-adapters-cdp-engmt-config 1.312.0 → 1.313.0

package/dist/es/es2018/cdp-engmt-config.js

@@ -84,75 +84,334 @@ function createLink(ref) {
     };
 }
 
-const VERSION$1 = "d7a7eda1fcf9765638e82c899066e8b1";
-function validate$1(obj, path = 'EngagementSignalErrorResponseRepresentation') {
+const VERSION$4 = "fa8c8d4e8876d7425228cbf115d34ff8";
+function validate$4(obj, path = 'EngagementSignalFilterRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
         }
-        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 + '")');
+        const obj_action = obj.action;
+        const path_action = path + '.action';
+        if (typeof obj_action !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_action + '" (at "' + path_action + '")');
         }
-        const obj_message = obj.message;
-        const path_message = path + '.message';
-        if (typeof obj_message !== 'string') {
-            return new TypeError('Expected "string" but received "' + typeof obj_message + '" (at "' + path_message + '")');
+        const obj_field = obj.field;
+        const path_field = path + '.field';
+        if (typeof obj_field !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_field + '" (at "' + path_field + '")');
+        }
+        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_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 select$5 = function EngagementSignalFilterRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$4,
+        private: [],
+        selections: [
+            {
+                name: 'action',
+                kind: 'Scalar'
+            },
+            {
+                name: 'field',
+                kind: 'Scalar'
+            },
+            {
+                name: 'operator',
+                kind: 'Scalar'
+            },
+            {
+                name: 'values',
+                kind: 'Scalar',
+                plural: true
+            }
+        ]
+    };
+};
+function equals$4(existing, incoming) {
+    const existing_action = existing.action;
+    const incoming_action = incoming.action;
+    if (!(existing_action === incoming_action)) {
+        return false;
+    }
+    const existing_field = existing.field;
+    const incoming_field = incoming.field;
+    if (!(existing_field === incoming_field)) {
+        return false;
+    }
+    const existing_operator = existing.operator;
+    const incoming_operator = incoming.operator;
+    if (!(existing_operator === incoming_operator)) {
+        return false;
+    }
+    const existing_values = existing.values;
+    const incoming_values = incoming.values;
+    const equals_values_items = equalsArray(existing_values, incoming_values, (existing_values_item, incoming_values_item) => {
+        if (!(existing_values_item === incoming_values_item)) {
+            return false;
+        }
+    });
+    if (equals_values_items === false) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$3 = "7764b6c0ac7f8728bb7b5bb6275205c9";
+function validate$3(obj, path = 'EngagementSignalFilterGroupRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_condition = obj.condition;
+        const path_condition = path + '.condition';
+        if (typeof obj_condition !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_condition + '" (at "' + path_condition + '")');
+        }
+        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 + ']';
+            const referencepath_filters_itemValidationError = validate$4(obj_filters_item, path_filters_item);
+            if (referencepath_filters_itemValidationError !== null) {
+                let message = 'Object doesn\'t match EngagementSignalFilterRepresentation (at "' + path_filters_item + '")\n';
+                message += referencepath_filters_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$4 = function EngagementSignalFilterGroupRepresentationSelect() {
+    const { selections: EngagementSignalFilterRepresentation__selections, opaque: EngagementSignalFilterRepresentation__opaque, } = select$5();
+    return {
+        kind: 'Fragment',
+        version: VERSION$3,
+        private: [],
+        selections: [
+            {
+                name: 'condition',
+                kind: 'Scalar'
+            },
+            {
+                name: 'filters',
+                kind: 'Object',
+                plural: true,
+                selections: EngagementSignalFilterRepresentation__selections
+            }
+        ]
+    };
+};
+function equals$3(existing, incoming) {
+    const existing_condition = existing.condition;
+    const incoming_condition = incoming.condition;
+    if (!(existing_condition === incoming_condition)) {
+        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 (!(equals$4(existing_filters_item, incoming_filters_item))) {
+            return false;
+        }
+    });
+    if (equals_filters_items === false) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$2 = "4002358550767b5517bab1932461184c";
+function validate$2(obj, path = 'EngagementSignalMetricRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_aggregateFunction = obj.aggregateFunction;
+        const path_aggregateFunction = path + '.aggregateFunction';
+        if (typeof obj_aggregateFunction !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_aggregateFunction + '" (at "' + path_aggregateFunction + '")');
+        }
+        const obj_field = obj.field;
+        const path_field = path + '.field';
+        if (typeof obj_field !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_field + '" (at "' + path_field + '")');
+        }
+        const obj_name = obj.name;
+        const path_name = path + '.name';
+        if (typeof obj_name !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
         }
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$2 = function EngagementSignalErrorResponseRepresentationSelect() {
+const select$3 = function EngagementSignalMetricRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$2,
+        private: [],
+        selections: [
+            {
+                name: 'aggregateFunction',
+                kind: 'Scalar'
+            },
+            {
+                name: 'field',
+                kind: 'Scalar'
+            },
+            {
+                name: 'name',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$2(existing, incoming) {
+    const existing_aggregateFunction = existing.aggregateFunction;
+    const incoming_aggregateFunction = incoming.aggregateFunction;
+    if (!(existing_aggregateFunction === incoming_aggregateFunction)) {
+        return false;
+    }
+    const existing_field = existing.field;
+    const incoming_field = incoming.field;
+    if (!(existing_field === incoming_field)) {
+        return false;
+    }
+    const existing_name = existing.name;
+    const incoming_name = incoming.name;
+    if (!(existing_name === incoming_name)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$1 = "610f115936516819ec203253177a4ea1";
+function validate$1(obj, path = 'EngagementSignalRateMetricRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_denominatorMetric = obj.denominatorMetric;
+        const path_denominatorMetric = path + '.denominatorMetric';
+        if (typeof obj_denominatorMetric !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_denominatorMetric + '" (at "' + path_denominatorMetric + '")');
+        }
+        const obj_name = obj.name;
+        const path_name = path + '.name';
+        if (typeof obj_name !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
+        }
+        const obj_numeratorMetric = obj.numeratorMetric;
+        const path_numeratorMetric = path + '.numeratorMetric';
+        if (typeof obj_numeratorMetric !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_numeratorMetric + '" (at "' + path_numeratorMetric + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$2 = function EngagementSignalRateMetricRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$1,
         private: [],
         selections: [
             {
-                name: 'errorCode',
+                name: 'denominatorMetric',
+                kind: 'Scalar'
+            },
+            {
+                name: 'name',
                 kind: 'Scalar'
             },
             {
-                name: 'message',
+                name: 'numeratorMetric',
                 kind: 'Scalar'
             }
         ]
     };
 };
 function equals$1(existing, incoming) {
-    const existing_errorCode = existing.errorCode;
-    const incoming_errorCode = incoming.errorCode;
-    if (!(existing_errorCode === incoming_errorCode)) {
+    const existing_denominatorMetric = existing.denominatorMetric;
+    const incoming_denominatorMetric = incoming.denominatorMetric;
+    if (!(existing_denominatorMetric === incoming_denominatorMetric)) {
         return false;
     }
-    const existing_message = existing.message;
-    const incoming_message = incoming.message;
-    if (!(existing_message === incoming_message)) {
+    const existing_name = existing.name;
+    const incoming_name = incoming.name;
+    if (!(existing_name === incoming_name)) {
+        return false;
+    }
+    const existing_numeratorMetric = existing.numeratorMetric;
+    const incoming_numeratorMetric = incoming.numeratorMetric;
+    if (!(existing_numeratorMetric === incoming_numeratorMetric)) {
         return false;
     }
     return true;
 }
 
 const TTL = 6000;
-const VERSION = "e25f060239c45264ef9dd5f19d035df6";
+const VERSION = "6e4a34ece2fd93b118b8036eddaaa9a9";
 function validate(obj, path = 'EngagementSignalRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
         }
-        const obj_errors = obj.errors;
-        const path_errors = path + '.errors';
-        if (!ArrayIsArray(obj_errors)) {
-            return new TypeError('Expected "array" but received "' + typeof obj_errors + '" (at "' + path_errors + '")');
-        }
-        for (let i = 0; i < obj_errors.length; i++) {
-            const obj_errors_item = obj_errors[i];
-            const path_errors_item = path_errors + '[' + i + ']';
-            const referencepath_errors_itemValidationError = validate$1(obj_errors_item, path_errors_item);
-            if (referencepath_errors_itemValidationError !== null) {
-                let message = 'Object doesn\'t match EngagementSignalErrorResponseRepresentation (at "' + path_errors_item + '")\n';
-                message += referencepath_errors_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+        const obj_catalogIdField = obj.catalogIdField;
+        const path_catalogIdField = path + '.catalogIdField';
+        if (typeof obj_catalogIdField !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_catalogIdField + '" (at "' + path_catalogIdField + '")');
+        }
+        const obj_dataSpace = obj.dataSpace;
+        const path_dataSpace = path + '.dataSpace';
+        if (typeof obj_dataSpace !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_dataSpace + '" (at "' + path_dataSpace + '")');
+        }
+        const obj_distinctFields = obj.distinctFields;
+        const path_distinctFields = path + '.distinctFields';
+        if (!ArrayIsArray(obj_distinctFields)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_distinctFields + '" (at "' + path_distinctFields + '")');
+        }
+        for (let i = 0; i < obj_distinctFields.length; i++) {
+            const obj_distinctFields_item = obj_distinctFields[i];
+            const path_distinctFields_item = path_distinctFields + '[' + i + ']';
+            if (typeof obj_distinctFields_item !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_distinctFields_item + '" (at "' + path_distinctFields_item + '")');
+            }
+        }
+        const obj_filterGroups = obj.filterGroups;
+        const path_filterGroups = path + '.filterGroups';
+        if (!ArrayIsArray(obj_filterGroups)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_filterGroups + '" (at "' + path_filterGroups + '")');
+        }
+        for (let i = 0; i < obj_filterGroups.length; i++) {
+            const obj_filterGroups_item = obj_filterGroups[i];
+            const path_filterGroups_item = path_filterGroups + '[' + i + ']';
+            const referencepath_filterGroups_itemValidationError = validate$3(obj_filterGroups_item, path_filterGroups_item);
+            if (referencepath_filterGroups_itemValidationError !== null) {
+                let message = 'Object doesn\'t match EngagementSignalFilterGroupRepresentation (at "' + path_filterGroups_item + '")\n';
+                message += referencepath_filterGroups_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
                 return new TypeError(message);
             }
         }
@@ -161,10 +420,77 @@ function validate(obj, path = 'EngagementSignalRepresentation') {
         if (typeof obj_id !== 'string') {
             return new TypeError('Expected "string" but received "' + typeof obj_id + '" (at "' + path_id + '")');
         }
-        const obj_success = obj.success;
-        const path_success = path + '.success';
-        if (typeof obj_success !== 'boolean') {
-            return new TypeError('Expected "boolean" but received "' + typeof obj_success + '" (at "' + path_success + '")');
+        const obj_joinDimensions = obj.joinDimensions;
+        const path_joinDimensions = path + '.joinDimensions';
+        if (!ArrayIsArray(obj_joinDimensions)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_joinDimensions + '" (at "' + path_joinDimensions + '")');
+        }
+        for (let i = 0; i < obj_joinDimensions.length; i++) {
+            const obj_joinDimensions_item = obj_joinDimensions[i];
+            const path_joinDimensions_item = path_joinDimensions + '[' + i + ']';
+            if (typeof obj_joinDimensions_item !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_joinDimensions_item + '" (at "' + path_joinDimensions_item + '")');
+            }
+        }
+        const obj_label = obj.label;
+        const path_label = path + '.label';
+        if (typeof obj_label !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_label + '" (at "' + path_label + '")');
+        }
+        const obj_metrics = obj.metrics;
+        const path_metrics = path + '.metrics';
+        if (!ArrayIsArray(obj_metrics)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_metrics + '" (at "' + path_metrics + '")');
+        }
+        for (let i = 0; i < obj_metrics.length; i++) {
+            const obj_metrics_item = obj_metrics[i];
+            const path_metrics_item = path_metrics + '[' + i + ']';
+            const referencepath_metrics_itemValidationError = validate$2(obj_metrics_item, path_metrics_item);
+            if (referencepath_metrics_itemValidationError !== null) {
+                let message = 'Object doesn\'t match EngagementSignalMetricRepresentation (at "' + path_metrics_item + '")\n';
+                message += referencepath_metrics_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_name = obj.name;
+        const path_name = path + '.name';
+        if (typeof obj_name !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
+        }
+        const obj_object = obj.object;
+        const path_object = path + '.object';
+        if (typeof obj_object !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_object + '" (at "' + path_object + '")');
+        }
+        const obj_rateMetrics = obj.rateMetrics;
+        const path_rateMetrics = path + '.rateMetrics';
+        if (!ArrayIsArray(obj_rateMetrics)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_rateMetrics + '" (at "' + path_rateMetrics + '")');
+        }
+        for (let i = 0; i < obj_rateMetrics.length; i++) {
+            const obj_rateMetrics_item = obj_rateMetrics[i];
+            const path_rateMetrics_item = path_rateMetrics + '[' + i + ']';
+            const referencepath_rateMetrics_itemValidationError = validate$1(obj_rateMetrics_item, path_rateMetrics_item);
+            if (referencepath_rateMetrics_itemValidationError !== null) {
+                let message = 'Object doesn\'t match EngagementSignalRateMetricRepresentation (at "' + path_rateMetrics_item + '")\n';
+                message += referencepath_rateMetrics_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_timestampField = obj.timestampField;
+        const path_timestampField = path + '.timestampField';
+        if (typeof obj_timestampField !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_timestampField + '" (at "' + path_timestampField + '")');
+        }
+        const obj_uniqueIdentifier = obj.uniqueIdentifier;
+        const path_uniqueIdentifier = path + '.uniqueIdentifier';
+        if (typeof obj_uniqueIdentifier !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_uniqueIdentifier + '" (at "' + path_uniqueIdentifier + '")');
+        }
+        const obj_userIdField = obj.userIdField;
+        const path_userIdField = path + '.userIdField';
+        if (typeof obj_userIdField !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_userIdField + '" (at "' + path_userIdField + '")');
         }
     })();
     return v_error === undefined ? null : v_error;
@@ -183,33 +509,90 @@ function normalize(input, existing, path, luvio, store, timestamp) {
     return input;
 }
 const select$1 = function EngagementSignalRepresentationSelect() {
-    const { selections: EngagementSignalErrorResponseRepresentation__selections, opaque: EngagementSignalErrorResponseRepresentation__opaque, } = select$2();
+    const { selections: EngagementSignalFilterGroupRepresentation__selections, opaque: EngagementSignalFilterGroupRepresentation__opaque, } = select$4();
+    const { selections: EngagementSignalMetricRepresentation__selections, opaque: EngagementSignalMetricRepresentation__opaque, } = select$3();
+    const { selections: EngagementSignalRateMetricRepresentation__selections, opaque: EngagementSignalRateMetricRepresentation__opaque, } = select$2();
     return {
         kind: 'Fragment',
         version: VERSION,
         private: [],
         selections: [
             {
-                name: 'errors',
+                name: 'catalogIdField',
+                kind: 'Scalar'
+            },
+            {
+                name: 'dataSpace',
+                kind: 'Scalar'
+            },
+            {
+                name: 'distinctFields',
+                kind: 'Scalar',
+                plural: true
+            },
+            {
+                name: 'filterGroups',
                 kind: 'Object',
                 plural: true,
-                selections: EngagementSignalErrorResponseRepresentation__selections
+                selections: EngagementSignalFilterGroupRepresentation__selections
             },
             {
                 name: 'id',
                 kind: 'Scalar'
             },
             {
-                name: 'success',
+                name: 'joinDimensions',
+                kind: 'Scalar',
+                plural: true
+            },
+            {
+                name: 'label',
+                kind: 'Scalar'
+            },
+            {
+                name: 'metrics',
+                kind: 'Object',
+                plural: true,
+                selections: EngagementSignalMetricRepresentation__selections
+            },
+            {
+                name: 'name',
+                kind: 'Scalar'
+            },
+            {
+                name: 'object',
+                kind: 'Scalar'
+            },
+            {
+                name: 'rateMetrics',
+                kind: 'Object',
+                plural: true,
+                selections: EngagementSignalRateMetricRepresentation__selections
+            },
+            {
+                name: 'timestampField',
+                kind: 'Scalar'
+            },
+            {
+                name: 'uniqueIdentifier',
+                kind: 'Scalar'
+            },
+            {
+                name: 'userIdField',
                 kind: 'Scalar'
             }
         ]
     };
 };
 function equals(existing, incoming) {
-    const existing_success = existing.success;
-    const incoming_success = incoming.success;
-    if (!(existing_success === incoming_success)) {
+    const existing_catalogIdField = existing.catalogIdField;
+    const incoming_catalogIdField = incoming.catalogIdField;
+    if (!(existing_catalogIdField === incoming_catalogIdField)) {
+        return false;
+    }
+    const existing_dataSpace = existing.dataSpace;
+    const incoming_dataSpace = incoming.dataSpace;
+    if (!(existing_dataSpace === incoming_dataSpace)) {
         return false;
     }
     const existing_id = existing.id;
@@ -217,14 +600,84 @@ function equals(existing, incoming) {
     if (!(existing_id === incoming_id)) {
         return false;
     }
-    const existing_errors = existing.errors;
-    const incoming_errors = incoming.errors;
-    const equals_errors_items = equalsArray(existing_errors, incoming_errors, (existing_errors_item, incoming_errors_item) => {
-        if (!(equals$1(existing_errors_item, incoming_errors_item))) {
+    const existing_label = existing.label;
+    const incoming_label = incoming.label;
+    if (!(existing_label === incoming_label)) {
+        return false;
+    }
+    const existing_name = existing.name;
+    const incoming_name = incoming.name;
+    if (!(existing_name === incoming_name)) {
+        return false;
+    }
+    const existing_object = existing.object;
+    const incoming_object = incoming.object;
+    if (!(existing_object === incoming_object)) {
+        return false;
+    }
+    const existing_timestampField = existing.timestampField;
+    const incoming_timestampField = incoming.timestampField;
+    if (!(existing_timestampField === incoming_timestampField)) {
+        return false;
+    }
+    const existing_uniqueIdentifier = existing.uniqueIdentifier;
+    const incoming_uniqueIdentifier = incoming.uniqueIdentifier;
+    if (!(existing_uniqueIdentifier === incoming_uniqueIdentifier)) {
+        return false;
+    }
+    const existing_userIdField = existing.userIdField;
+    const incoming_userIdField = incoming.userIdField;
+    if (!(existing_userIdField === incoming_userIdField)) {
+        return false;
+    }
+    const existing_distinctFields = existing.distinctFields;
+    const incoming_distinctFields = incoming.distinctFields;
+    const equals_distinctFields_items = equalsArray(existing_distinctFields, incoming_distinctFields, (existing_distinctFields_item, incoming_distinctFields_item) => {
+        if (!(existing_distinctFields_item === incoming_distinctFields_item)) {
+            return false;
+        }
+    });
+    if (equals_distinctFields_items === false) {
+        return false;
+    }
+    const existing_filterGroups = existing.filterGroups;
+    const incoming_filterGroups = incoming.filterGroups;
+    const equals_filterGroups_items = equalsArray(existing_filterGroups, incoming_filterGroups, (existing_filterGroups_item, incoming_filterGroups_item) => {
+        if (!(equals$3(existing_filterGroups_item, incoming_filterGroups_item))) {
+            return false;
+        }
+    });
+    if (equals_filterGroups_items === false) {
+        return false;
+    }
+    const existing_joinDimensions = existing.joinDimensions;
+    const incoming_joinDimensions = incoming.joinDimensions;
+    const equals_joinDimensions_items = equalsArray(existing_joinDimensions, incoming_joinDimensions, (existing_joinDimensions_item, incoming_joinDimensions_item) => {
+        if (!(existing_joinDimensions_item === incoming_joinDimensions_item)) {
+            return false;
+        }
+    });
+    if (equals_joinDimensions_items === false) {
+        return false;
+    }
+    const existing_metrics = existing.metrics;
+    const incoming_metrics = incoming.metrics;
+    const equals_metrics_items = equalsArray(existing_metrics, incoming_metrics, (existing_metrics_item, incoming_metrics_item) => {
+        if (!(equals$2(existing_metrics_item, incoming_metrics_item))) {
+            return false;
+        }
+    });
+    if (equals_metrics_items === false) {
+        return false;
+    }
+    const existing_rateMetrics = existing.rateMetrics;
+    const incoming_rateMetrics = incoming.rateMetrics;
+    const equals_rateMetrics_items = equalsArray(existing_rateMetrics, incoming_rateMetrics, (existing_rateMetrics_item, incoming_rateMetrics_item) => {
+        if (!(equals$1(existing_rateMetrics_item, incoming_rateMetrics_item))) {
             return false;
         }
     });
-    if (equals_errors_items === false) {
+    if (equals_rateMetrics_items === false) {
         return false;
     }
     return true;
@@ -278,7 +731,7 @@ function createResourceRequest(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
-        basePath: '/engagementsignal/engagement-signals',
+        basePath: '/personalization/engagement-signals',
         method: 'post',
         body: config.body,
         urlParams: {},
@@ -290,17 +743,17 @@ function createResourceRequest(config) {
 
 const adapterName = 'createEngagementSignal';
 const createEngagementSignal_ConfigPropertyMetadata = [
-    generateParamConfigMetadata('catalogIdField', true, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('catalogIdField', false, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('dataSpace', true, 2 /* Body */, 0 /* String */),
-    generateParamConfigMetadata('description', true, 2 /* Body */, 0 /* String */),
-    generateParamConfigMetadata('distinctFields', true, 2 /* Body */, 0 /* String */, true),
-    generateParamConfigMetadata('filterGroups', true, 2 /* Body */, 4 /* Unsupported */, true),
-    generateParamConfigMetadata('joinDimensions', true, 2 /* Body */, 0 /* String */, true),
+    generateParamConfigMetadata('description', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('distinctFields', false, 2 /* Body */, 0 /* String */, true),
+    generateParamConfigMetadata('filterGroups', false, 2 /* Body */, 4 /* Unsupported */, true),
+    generateParamConfigMetadata('joinDimensions', false, 2 /* Body */, 0 /* String */, true),
     generateParamConfigMetadata('label', true, 2 /* Body */, 0 /* String */),
-    generateParamConfigMetadata('metrics', true, 2 /* Body */, 4 /* Unsupported */, true),
+    generateParamConfigMetadata('metrics', false, 2 /* Body */, 4 /* Unsupported */, true),
     generateParamConfigMetadata('name', true, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('object', true, 2 /* Body */, 0 /* String */),
-    generateParamConfigMetadata('rateMetrics', true, 2 /* Body */, 4 /* Unsupported */, true),
+    generateParamConfigMetadata('rateMetrics', false, 2 /* Body */, 4 /* Unsupported */, true),
     generateParamConfigMetadata('timestampField', true, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('uniqueIdentifier', true, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('userIdField', true, 2 /* Body */, 0 /* String */),