@salesforce/lds-adapters-industries-sales-excellence 0.1.0-dev1

package/dist/es/es2018/industries-sales-excellence.js

@@ -0,0 +1,4825 @@
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, createResourceParams as createResourceParams$b, typeCheckConfig as typeCheckConfig$b, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$4 } from '@luvio/engine';
+
+const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
+const { keys: ObjectKeys, create: ObjectCreate } = Object;
+const { isArray: ArrayIsArray$1 } = Array;
+/**
+ * Validates an adapter config is well-formed.
+ * @param config The config to validate.
+ * @param adapter The adapter validation configuration.
+ * @param oneOf The keys the config must contain at least one of.
+ * @throws A TypeError if config doesn't satisfy the adapter's config validation.
+ */
+function validateConfig(config, adapter, oneOf) {
+    const { displayName } = adapter;
+    const { required, optional, unsupported } = adapter.parameters;
+    if (config === undefined ||
+        required.every(req => ObjectPrototypeHasOwnProperty.call(config, req)) === false) {
+        throw new TypeError(`adapter ${displayName} configuration must specify ${required.sort().join(', ')}`);
+    }
+    if (oneOf && oneOf.some(req => ObjectPrototypeHasOwnProperty.call(config, req)) === false) {
+        throw new TypeError(`adapter ${displayName} configuration must specify one of ${oneOf.sort().join(', ')}`);
+    }
+    if (unsupported !== undefined &&
+        unsupported.some(req => ObjectPrototypeHasOwnProperty.call(config, req))) {
+        throw new TypeError(`adapter ${displayName} does not yet support ${unsupported.sort().join(', ')}`);
+    }
+    const supported = required.concat(optional);
+    if (ObjectKeys(config).some(key => !supported.includes(key))) {
+        throw new TypeError(`adapter ${displayName} configuration supports only ${supported.sort().join(', ')}`);
+    }
+}
+function untrustedIsObject(untrusted) {
+    return typeof untrusted === 'object' && untrusted !== null && ArrayIsArray$1(untrusted) === false;
+}
+function areRequiredParametersPresent(config, configPropertyNames) {
+    return configPropertyNames.parameters.required.every(req => req in config);
+}
+const snapshotRefreshOptions = {
+    overrides: {
+        headers: {
+            'Cache-Control': 'no-cache',
+        },
+    }
+};
+function generateParamConfigMetadata(name, required, resourceType, typeCheckShape, isArrayShape = false, coerceFn) {
+    return {
+        name,
+        required,
+        resourceType,
+        typeCheckShape,
+        isArrayShape,
+        coerceFn,
+    };
+}
+function buildAdapterValidationConfig(displayName, paramsMeta) {
+    const required = paramsMeta.filter(p => p.required).map(p => p.name);
+    const optional = paramsMeta.filter(p => !p.required).map(p => p.name);
+    return {
+        displayName,
+        parameters: {
+            required,
+            optional,
+        }
+    };
+}
+const keyPrefix = 'sales-excellence';
+
+const { isArray: ArrayIsArray } = Array;
+const { stringify: JSONStringify } = JSON;
+function equalsArray(a, b, equalsItem) {
+    const aLength = a.length;
+    const bLength = b.length;
+    if (aLength !== bLength) {
+        return false;
+    }
+    for (let i = 0; i < aLength; i++) {
+        if (equalsItem(a[i], b[i]) === false) {
+            return false;
+        }
+    }
+    return true;
+}
+function createLink(ref) {
+    return {
+        __ref: serializeStructuredKey(ref),
+    };
+}
+
+const VERSION$m = "5bb77e8e38ab7a82cce880a970c7073b";
+function validate$z(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.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 + '")');
+            }
+        }
+        const obj_fieldName = obj.fieldName;
+        const path_fieldName = path + '.fieldName';
+        if (typeof obj_fieldName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_fieldName + '" (at "' + path_fieldName + '")');
+        }
+        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_value = obj.value;
+        const path_value = path + '.value';
+        if (typeof obj_value !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_value + '" (at "' + path_value + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$x = function FilterRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$m,
+        private: [],
+        selections: [
+            {
+                name: 'dataType',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'fieldName',
+                kind: 'Scalar'
+            },
+            {
+                name: 'operator',
+                kind: 'Scalar'
+            },
+            {
+                name: 'value',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$m(existing, incoming) {
+    const existing_dataType = existing.dataType;
+    const incoming_dataType = incoming.dataType;
+    // if at least one of these optionals is defined
+    if (existing_dataType !== undefined || incoming_dataType !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_dataType === undefined || incoming_dataType === undefined) {
+            return false;
+        }
+        if (!(existing_dataType === incoming_dataType)) {
+            return false;
+        }
+    }
+    const existing_fieldName = existing.fieldName;
+    const incoming_fieldName = incoming.fieldName;
+    if (!(existing_fieldName === incoming_fieldName)) {
+        return false;
+    }
+    const existing_operator = existing.operator;
+    const incoming_operator = incoming.operator;
+    if (!(existing_operator === incoming_operator)) {
+        return false;
+    }
+    const existing_value = existing.value;
+    const incoming_value = incoming.value;
+    if (!(existing_value === incoming_value)) {
+        return false;
+    }
+    return true;
+}
+
+function validate$y(obj, path = 'FilterRepresentationList') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_filterList = obj.filterList;
+        const path_filterList = path + '.filterList';
+        if (!ArrayIsArray(obj_filterList)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_filterList + '" (at "' + path_filterList + '")');
+        }
+        for (let i = 0; i < obj_filterList.length; i++) {
+            const obj_filterList_item = obj_filterList[i];
+            const path_filterList_item = path_filterList + '[' + i + ']';
+            const referencepath_filterList_itemValidationError = validate$z(obj_filterList_item, path_filterList_item);
+            if (referencepath_filterList_itemValidationError !== null) {
+                let message = 'Object doesn\'t match FilterRepresentation (at "' + path_filterList_item + '")\n';
+                message += referencepath_filterList_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$x(obj, path = 'OrderByRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_fieldName = obj.fieldName;
+        const path_fieldName = path + '.fieldName';
+        if (typeof obj_fieldName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_fieldName + '" (at "' + path_fieldName + '")');
+        }
+        const obj_nulls = obj.nulls;
+        const path_nulls = path + '.nulls';
+        if (typeof obj_nulls !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_nulls + '" (at "' + path_nulls + '")');
+        }
+        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 + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$w(obj, path = 'OrderByRepresentationList') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_orderByList = obj.orderByList;
+        const path_orderByList = path + '.orderByList';
+        if (!ArrayIsArray(obj_orderByList)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_orderByList + '" (at "' + path_orderByList + '")');
+        }
+        for (let i = 0; i < obj_orderByList.length; i++) {
+            const obj_orderByList_item = obj_orderByList[i];
+            const path_orderByList_item = path_orderByList + '[' + i + ']';
+            const referencepath_orderByList_itemValidationError = validate$x(obj_orderByList_item, path_orderByList_item);
+            if (referencepath_orderByList_itemValidationError !== null) {
+                let message = 'Object doesn\'t match OrderByRepresentation (at "' + path_orderByList_item + '")\n';
+                message += referencepath_orderByList_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$v(obj, path = 'SearchActionableListMemberInputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.after !== undefined) {
+            const obj_after = obj.after;
+            const path_after = path + '.after';
+            if (typeof obj_after !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_after + '" (at "' + path_after + '")');
+            }
+        }
+        if (obj.filters !== undefined) {
+            const obj_filters = obj.filters;
+            const path_filters = path + '.filters';
+            const referencepath_filtersValidationError = validate$y(obj_filters, path_filters);
+            if (referencepath_filtersValidationError !== null) {
+                let message = 'Object doesn\'t match FilterRepresentationList (at "' + path_filters + '")\n';
+                message += referencepath_filtersValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.orderBy !== undefined) {
+            const obj_orderBy = obj.orderBy;
+            const path_orderBy = path + '.orderBy';
+            const referencepath_orderByValidationError = validate$w(obj_orderBy, path_orderBy);
+            if (referencepath_orderByValidationError !== null) {
+                let message = 'Object doesn\'t match OrderByRepresentationList (at "' + path_orderBy + '")\n';
+                message += referencepath_orderByValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.requireHeaders !== undefined) {
+            const obj_requireHeaders = obj.requireHeaders;
+            const path_requireHeaders = path + '.requireHeaders';
+            if (typeof obj_requireHeaders !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_requireHeaders + '" (at "' + path_requireHeaders + '")');
+            }
+        }
+        const obj_scope = obj.scope;
+        const path_scope = path + '.scope';
+        if (typeof obj_scope !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_scope + '" (at "' + path_scope + '")');
+        }
+        if (obj.searchTerm !== undefined) {
+            const obj_searchTerm = obj.searchTerm;
+            const path_searchTerm = path + '.searchTerm';
+            if (typeof obj_searchTerm !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_searchTerm + '" (at "' + path_searchTerm + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+const VERSION$l = "e33654870510a9686b7f2dba827670b4";
+function validate$u(obj, path = 'ActionRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.componentName !== undefined) {
+            const obj_componentName = obj.componentName;
+            const path_componentName = path + '.componentName';
+            if (typeof obj_componentName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_componentName + '" (at "' + path_componentName + '")');
+            }
+        }
+        if (obj.componentType !== undefined) {
+            const obj_componentType = obj.componentType;
+            const path_componentType = path + '.componentType';
+            if (typeof obj_componentType !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_componentType + '" (at "' + path_componentType + '")');
+            }
+        }
+        if (obj.displayLabel !== undefined) {
+            const obj_displayLabel = obj.displayLabel;
+            const path_displayLabel = path + '.displayLabel';
+            if (typeof obj_displayLabel !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_displayLabel + '" (at "' + path_displayLabel + '")');
+            }
+        }
+        if (obj.displayOrder !== undefined) {
+            const obj_displayOrder = obj.displayOrder;
+            const path_displayOrder = path + '.displayOrder';
+            if (typeof obj_displayOrder !== 'number' || (typeof obj_displayOrder === 'number' && Math.floor(obj_displayOrder) !== obj_displayOrder)) {
+                return new TypeError('Expected "integer" but received "' + typeof obj_displayOrder + '" (at "' + path_displayOrder + '")');
+            }
+        }
+        if (obj.isAlmAction !== undefined) {
+            const obj_isAlmAction = obj.isAlmAction;
+            const path_isAlmAction = path + '.isAlmAction';
+            if (typeof obj_isAlmAction !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isAlmAction + '" (at "' + path_isAlmAction + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$w = function ActionRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$l,
+        private: [],
+        selections: [
+            {
+                name: 'componentName',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'componentType',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'displayLabel',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'displayOrder',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'isAlmAction',
+                kind: 'Scalar',
+                required: false
+            }
+        ]
+    };
+};
+function equals$l(existing, incoming) {
+    const existing_isAlmAction = existing.isAlmAction;
+    const incoming_isAlmAction = incoming.isAlmAction;
+    // if at least one of these optionals is defined
+    if (existing_isAlmAction !== undefined || incoming_isAlmAction !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_isAlmAction === undefined || incoming_isAlmAction === undefined) {
+            return false;
+        }
+        if (!(existing_isAlmAction === incoming_isAlmAction)) {
+            return false;
+        }
+    }
+    const existing_displayOrder = existing.displayOrder;
+    const incoming_displayOrder = incoming.displayOrder;
+    // if at least one of these optionals is defined
+    if (existing_displayOrder !== undefined || incoming_displayOrder !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_displayOrder === undefined || incoming_displayOrder === undefined) {
+            return false;
+        }
+        if (!(existing_displayOrder === incoming_displayOrder)) {
+            return false;
+        }
+    }
+    const existing_componentName = existing.componentName;
+    const incoming_componentName = incoming.componentName;
+    // if at least one of these optionals is defined
+    if (existing_componentName !== undefined || incoming_componentName !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_componentName === undefined || incoming_componentName === undefined) {
+            return false;
+        }
+        if (!(existing_componentName === incoming_componentName)) {
+            return false;
+        }
+    }
+    const existing_componentType = existing.componentType;
+    const incoming_componentType = incoming.componentType;
+    // if at least one of these optionals is defined
+    if (existing_componentType !== undefined || incoming_componentType !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_componentType === undefined || incoming_componentType === undefined) {
+            return false;
+        }
+        if (!(existing_componentType === incoming_componentType)) {
+            return false;
+        }
+    }
+    const existing_displayLabel = existing.displayLabel;
+    const incoming_displayLabel = incoming.displayLabel;
+    // if at least one of these optionals is defined
+    if (existing_displayLabel !== undefined || incoming_displayLabel !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_displayLabel === undefined || incoming_displayLabel === undefined) {
+            return false;
+        }
+        if (!(existing_displayLabel === incoming_displayLabel)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const TTL$9 = 300;
+const VERSION$k = "6fe7d0482ad72b83c24e9eee06a9d065";
+function validate$t(obj, path = 'SearchActionableListMemberRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.actions !== undefined) {
+            const obj_actions = obj.actions;
+            const path_actions = path + '.actions';
+            if (!ArrayIsArray(obj_actions)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_actions + '" (at "' + path_actions + '")');
+            }
+            for (let i = 0; i < obj_actions.length; i++) {
+                const obj_actions_item = obj_actions[i];
+                const path_actions_item = path_actions + '[' + i + ']';
+                const referencepath_actions_itemValidationError = validate$u(obj_actions_item, path_actions_item);
+                if (referencepath_actions_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match ActionRepresentation (at "' + path_actions_item + '")\n';
+                    message += referencepath_actions_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+        const obj_fields = obj.fields;
+        const path_fields = path + '.fields';
+        if (!ArrayIsArray(obj_fields)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_fields + '" (at "' + path_fields + '")');
+        }
+        for (let i = 0; i < obj_fields.length; i++) {
+            const obj_fields_item = obj_fields[i];
+            const path_fields_item = path_fields + '[' + i + ']';
+            if (obj_fields_item === undefined) {
+                return new TypeError('Expected "defined" but received "' + typeof obj_fields_item + '" (at "' + path_fields_item + '")');
+            }
+        }
+        if (obj.isColumnsModalVisible !== undefined) {
+            const obj_isColumnsModalVisible = obj.isColumnsModalVisible;
+            const path_isColumnsModalVisible = path + '.isColumnsModalVisible';
+            if (typeof obj_isColumnsModalVisible !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isColumnsModalVisible + '" (at "' + path_isColumnsModalVisible + '")');
+            }
+        }
+        const obj_nextPageToken = obj.nextPageToken;
+        const path_nextPageToken = path + '.nextPageToken';
+        if (typeof obj_nextPageToken !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_nextPageToken + '" (at "' + path_nextPageToken + '")');
+        }
+        if (obj.objectName !== undefined) {
+            const obj_objectName = obj.objectName;
+            const path_objectName = path + '.objectName';
+            if (typeof obj_objectName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_objectName + '" (at "' + path_objectName + '")');
+            }
+        }
+        const obj_records = obj.records;
+        const path_records = path + '.records';
+        if (!ArrayIsArray(obj_records)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_records + '" (at "' + path_records + '")');
+        }
+        for (let i = 0; i < obj_records.length; i++) {
+            const obj_records_item = obj_records[i];
+            const path_records_item = path_records + '[' + i + ']';
+            if (obj_records_item === undefined) {
+                return new TypeError('Expected "defined" but received "' + typeof obj_records_item + '" (at "' + path_records_item + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$9 = 'SearchActionableListMemberRepresentation';
+function keyBuilder$d(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$9 + ':' + config.nextPageToken;
+}
+function keyBuilderFromType$5(luvio, object) {
+    const keyParams = {
+        nextPageToken: object.nextPageToken
+    };
+    return keyBuilder$d(luvio, keyParams);
+}
+function normalize$9(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$v = function SearchActionableListMemberRepresentationSelect() {
+    const { selections: ActionRepresentation__selections, opaque: ActionRepresentation__opaque, } = select$w();
+    return {
+        kind: 'Fragment',
+        version: VERSION$k,
+        private: [],
+        selections: [
+            {
+                name: 'actions',
+                kind: 'Object',
+                plural: true,
+                selections: ActionRepresentation__selections,
+                required: false
+            },
+            {
+                name: 'fields',
+                kind: 'Object',
+                // any
+            },
+            {
+                name: 'isColumnsModalVisible',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'nextPageToken',
+                kind: 'Scalar'
+            },
+            {
+                name: 'objectName',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'records',
+                kind: 'Object',
+                // any
+            }
+        ]
+    };
+};
+function equals$k(existing, incoming) {
+    const existing_isColumnsModalVisible = existing.isColumnsModalVisible;
+    const incoming_isColumnsModalVisible = incoming.isColumnsModalVisible;
+    // if at least one of these optionals is defined
+    if (existing_isColumnsModalVisible !== undefined || incoming_isColumnsModalVisible !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_isColumnsModalVisible === undefined || incoming_isColumnsModalVisible === undefined) {
+            return false;
+        }
+        if (!(existing_isColumnsModalVisible === incoming_isColumnsModalVisible)) {
+            return false;
+        }
+    }
+    const existing_nextPageToken = existing.nextPageToken;
+    const incoming_nextPageToken = incoming.nextPageToken;
+    if (!(existing_nextPageToken === incoming_nextPageToken)) {
+        return false;
+    }
+    const existing_objectName = existing.objectName;
+    const incoming_objectName = incoming.objectName;
+    // if at least one of these optionals is defined
+    if (existing_objectName !== undefined || incoming_objectName !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_objectName === undefined || incoming_objectName === undefined) {
+            return false;
+        }
+        if (!(existing_objectName === incoming_objectName)) {
+            return false;
+        }
+    }
+    const existing_actions = existing.actions;
+    const incoming_actions = incoming.actions;
+    // if at least one of these optionals is defined
+    if (existing_actions !== undefined || incoming_actions !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_actions === undefined || incoming_actions === undefined) {
+            return false;
+        }
+        const equals_actions_items = equalsArray(existing_actions, incoming_actions, (existing_actions_item, incoming_actions_item) => {
+            if (!(equals$l(existing_actions_item, incoming_actions_item))) {
+                return false;
+            }
+        });
+        if (equals_actions_items === false) {
+            return false;
+        }
+    }
+    const existing_fields = existing.fields;
+    const incoming_fields = incoming.fields;
+    const equals_fields_items = equalsArray(existing_fields, incoming_fields, (existing_fields_item, incoming_fields_item) => {
+        if (JSONStringify(incoming_fields_item) !== JSONStringify(existing_fields_item)) {
+            return false;
+        }
+    });
+    if (equals_fields_items === false) {
+        return false;
+    }
+    const existing_records = existing.records;
+    const incoming_records = incoming.records;
+    const equals_records_items = equalsArray(existing_records, incoming_records, (existing_records_item, incoming_records_item) => {
+        if (JSONStringify(incoming_records_item) !== JSONStringify(existing_records_item)) {
+            return false;
+        }
+    });
+    if (equals_records_items === false) {
+        return false;
+    }
+    return true;
+}
+const ingest$9 = function SearchActionableListMemberRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$t(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$5(luvio, input);
+    const ttlToUse = TTL$9;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$9, "sales-excellence", VERSION$k, RepresentationType$9, equals$k);
+    return createLink(key);
+};
+function getTypeCacheKeys$9(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$5(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$9,
+        mergeable: false
+    });
+}
+
+function select$u(luvio, params) {
+    return select$v();
+}
+function getResponseCacheKeys$a(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$9(storeKeyMap, luvio, response);
+}
+function ingestSuccess$a(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$5(luvio, body);
+    luvio.storeIngest(key, ingest$9, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$u(),
+        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$a(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v66.0',
+        basePath: '/connect/sales-excellence/actionable-list-members',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$a = 'actionableListMemberSearch';
+const actionableListMemberSearch_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('actionableListMemberSearchInput', true, 2 /* Body */, 4 /* Unsupported */),
+];
+const actionableListMemberSearch_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$a, actionableListMemberSearch_ConfigPropertyMetadata);
+const createResourceParams$a = /*#__PURE__*/ createResourceParams$b(actionableListMemberSearch_ConfigPropertyMetadata);
+function typeCheckConfig$a(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_actionableListMemberSearchInput = untrustedConfig.actionableListMemberSearchInput;
+    const referenceSearchActionableListMemberInputRepresentationValidationError = validate$v(untrustedConfig_actionableListMemberSearchInput);
+    if (referenceSearchActionableListMemberInputRepresentationValidationError === null) {
+        config.actionableListMemberSearchInput = untrustedConfig_actionableListMemberSearchInput;
+    }
+    return config;
+}
+function validateAdapterConfig$a(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$a(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$a(luvio, config, options) {
+    const resourceParams = createResourceParams$a(config);
+    const request = createResourceRequest$a(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$a(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$a(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const actionableListMemberSearchAdapterFactory = (luvio) => {
+    return function actionableListMemberSearch(untrustedConfig) {
+        const config = validateAdapterConfig$a(untrustedConfig, actionableListMemberSearch_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "actionableListMemberSearch"');
+        }
+        return buildNetworkSnapshot$a(luvio, config);
+    };
+};
+
+function select$t(luvio, params) {
+    return select$v();
+}
+function getResponseCacheKeys$9(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$9(storeKeyMap, luvio, response);
+}
+function ingestSuccess$9(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$5(luvio, body);
+    luvio.storeIngest(key, ingest$9, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$t(),
+        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$9(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v66.0',
+        basePath: '/connect/sales-excellence/actionable-list-members/' + config.urlParams.actionableListId + '',
+        method: 'post',
+        body: config.body,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$9 = 'actionableListMemberSearchById';
+const actionableListMemberSearchById_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('actionableListId', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('actionableListMemberSearchInput', true, 2 /* Body */, 4 /* Unsupported */),
+];
+const actionableListMemberSearchById_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$9, actionableListMemberSearchById_ConfigPropertyMetadata);
+const createResourceParams$9 = /*#__PURE__*/ createResourceParams$b(actionableListMemberSearchById_ConfigPropertyMetadata);
+function typeCheckConfig$9(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$b(untrustedConfig, config, actionableListMemberSearchById_ConfigPropertyMetadata);
+    const untrustedConfig_actionableListMemberSearchInput = untrustedConfig.actionableListMemberSearchInput;
+    const referenceSearchActionableListMemberInputRepresentationValidationError = validate$v(untrustedConfig_actionableListMemberSearchInput);
+    if (referenceSearchActionableListMemberInputRepresentationValidationError === null) {
+        config.actionableListMemberSearchInput = untrustedConfig_actionableListMemberSearchInput;
+    }
+    return config;
+}
+function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$9(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$9(luvio, config, options) {
+    const resourceParams = createResourceParams$9(config);
+    const request = createResourceRequest$9(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$9(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$9(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const actionableListMemberSearchByIdAdapterFactory = (luvio) => {
+    return function actionableListMemberSearchById(untrustedConfig) {
+        const config = validateAdapterConfig$9(untrustedConfig, actionableListMemberSearchById_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "actionableListMemberSearchById"');
+        }
+        return buildNetworkSnapshot$9(luvio, config);
+    };
+};
+
+function validate$s(obj, path = 'ActionableListFieldsInputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.endDate !== undefined) {
+            const obj_endDate = obj.endDate;
+            const path_endDate = path + '.endDate';
+            if (typeof obj_endDate !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_endDate + '" (at "' + path_endDate + '")');
+            }
+        }
+        if (obj.isAutoAssignmentAllowed !== undefined) {
+            const obj_isAutoAssignmentAllowed = obj.isAutoAssignmentAllowed;
+            const path_isAutoAssignmentAllowed = path + '.isAutoAssignmentAllowed';
+            if (typeof obj_isAutoAssignmentAllowed !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isAutoAssignmentAllowed + '" (at "' + path_isAutoAssignmentAllowed + '")');
+            }
+        }
+        if (obj.omniScriptKey !== undefined) {
+            const obj_omniScriptKey = obj.omniScriptKey;
+            const path_omniScriptKey = path + '.omniScriptKey';
+            if (typeof obj_omniScriptKey !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_omniScriptKey + '" (at "' + path_omniScriptKey + '")');
+            }
+        }
+        const obj_priority = obj.priority;
+        const path_priority = path + '.priority';
+        if (typeof obj_priority !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_priority + '" (at "' + path_priority + '")');
+        }
+        if (obj.sortField !== undefined) {
+            const obj_sortField = obj.sortField;
+            const path_sortField = path + '.sortField';
+            if (typeof obj_sortField !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_sortField + '" (at "' + path_sortField + '")');
+            }
+        }
+        if (obj.sortOrder !== undefined) {
+            const obj_sortOrder = obj.sortOrder;
+            const path_sortOrder = path + '.sortOrder';
+            if (typeof obj_sortOrder !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_sortOrder + '" (at "' + path_sortOrder + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$r(obj, path = 'AssigneeInputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_name = obj.name;
+        const path_name = path + '.name';
+        if (typeof obj_name !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
+        }
+        const obj_type = obj.type;
+        const path_type = path + '.type';
+        if (typeof obj_type !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_type + '" (at "' + path_type + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$q(obj, path = 'ActionableListMemberFieldsInputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_assignee = obj.assignee;
+        const path_assignee = path + '.assignee';
+        const referencepath_assigneeValidationError = validate$r(obj_assignee, path_assignee);
+        if (referencepath_assigneeValidationError !== null) {
+            let message = 'Object doesn\'t match AssigneeInputRepresentation (at "' + path_assignee + '")\n';
+            message += referencepath_assigneeValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$p(obj, path = 'AssignActionableListInputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_actionableListFields = obj.actionableListFields;
+        const path_actionableListFields = path + '.actionableListFields';
+        const referencepath_actionableListFieldsValidationError = validate$s(obj_actionableListFields, path_actionableListFields);
+        if (referencepath_actionableListFieldsValidationError !== null) {
+            let message = 'Object doesn\'t match ActionableListFieldsInputRepresentation (at "' + path_actionableListFields + '")\n';
+            message += referencepath_actionableListFieldsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_actionableListMemberFields = obj.actionableListMemberFields;
+        const path_actionableListMemberFields = path + '.actionableListMemberFields';
+        const referencepath_actionableListMemberFieldsValidationError = validate$q(obj_actionableListMemberFields, path_actionableListMemberFields);
+        if (referencepath_actionableListMemberFieldsValidationError !== null) {
+            let message = 'Object doesn\'t match ActionableListMemberFieldsInputRepresentation (at "' + path_actionableListMemberFields + '")\n';
+            message += referencepath_actionableListMemberFieldsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        if (obj.actionableListMemberRecordIds !== undefined) {
+            const obj_actionableListMemberRecordIds = obj.actionableListMemberRecordIds;
+            const path_actionableListMemberRecordIds = path + '.actionableListMemberRecordIds';
+            if (!ArrayIsArray(obj_actionableListMemberRecordIds)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_actionableListMemberRecordIds + '" (at "' + path_actionableListMemberRecordIds + '")');
+            }
+            for (let i = 0; i < obj_actionableListMemberRecordIds.length; i++) {
+                const obj_actionableListMemberRecordIds_item = obj_actionableListMemberRecordIds[i];
+                const path_actionableListMemberRecordIds_item = path_actionableListMemberRecordIds + '[' + i + ']';
+                if (typeof obj_actionableListMemberRecordIds_item !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_actionableListMemberRecordIds_item + '" (at "' + path_actionableListMemberRecordIds_item + '")');
+                }
+            }
+        }
+        if (obj.autoAssignee !== undefined) {
+            const obj_autoAssignee = obj.autoAssignee;
+            const path_autoAssignee = path + '.autoAssignee';
+            if (typeof obj_autoAssignee !== 'object' || ArrayIsArray(obj_autoAssignee) || obj_autoAssignee === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj_autoAssignee + '" (at "' + path_autoAssignee + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+const VERSION$j = "c9b9be79dac59b38a528222283da782d";
+function validate$o(obj, path = 'SalesExcellenceStatusRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_code = obj.code;
+        const path_code = path + '.code';
+        if (typeof obj_code !== 'number' || (typeof obj_code === 'number' && Math.floor(obj_code) !== obj_code)) {
+            return new TypeError('Expected "integer" but received "' + typeof obj_code + '" (at "' + path_code + '")');
+        }
+        const obj_message = obj.message;
+        const path_message = path + '.message';
+        if (typeof obj_message !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_message + '" (at "' + path_message + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$s = function SalesExcellenceStatusRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$j,
+        private: [],
+        selections: [
+            {
+                name: 'code',
+                kind: 'Scalar'
+            },
+            {
+                name: 'message',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$j(existing, incoming) {
+    const existing_code = existing.code;
+    const incoming_code = incoming.code;
+    if (!(existing_code === incoming_code)) {
+        return false;
+    }
+    const existing_message = existing.message;
+    const incoming_message = incoming.message;
+    if (!(existing_message === incoming_message)) {
+        return false;
+    }
+    return true;
+}
+
+const TTL$8 = 300;
+const VERSION$i = "15d1cf786c4441e62012f571d16954c0";
+function validate$n(obj, path = 'AssignActionableListRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_actionableListId = obj.actionableListId;
+        const path_actionableListId = path + '.actionableListId';
+        if (typeof obj_actionableListId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_actionableListId + '" (at "' + path_actionableListId + '")');
+        }
+        const obj_status = obj.status;
+        const path_status = path + '.status';
+        const referencepath_statusValidationError = validate$o(obj_status, path_status);
+        if (referencepath_statusValidationError !== null) {
+            let message = 'Object doesn\'t match SalesExcellenceStatusRepresentation (at "' + path_status + '")\n';
+            message += referencepath_statusValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$8 = 'AssignActionableListRepresentation';
+function keyBuilder$c(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$8 + ':' + config.actionableListId;
+}
+function keyBuilderFromType$4(luvio, object) {
+    const keyParams = {
+        actionableListId: object.actionableListId
+    };
+    return keyBuilder$c(luvio, keyParams);
+}
+function normalize$8(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$r = function AssignActionableListRepresentationSelect() {
+    const { selections: SalesExcellenceStatusRepresentation__selections, opaque: SalesExcellenceStatusRepresentation__opaque, } = select$s();
+    return {
+        kind: 'Fragment',
+        version: VERSION$i,
+        private: [],
+        selections: [
+            {
+                name: 'actionableListId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'status',
+                kind: 'Object',
+                selections: SalesExcellenceStatusRepresentation__selections
+            }
+        ]
+    };
+};
+function equals$i(existing, incoming) {
+    const existing_actionableListId = existing.actionableListId;
+    const incoming_actionableListId = incoming.actionableListId;
+    if (!(existing_actionableListId === incoming_actionableListId)) {
+        return false;
+    }
+    const existing_status = existing.status;
+    const incoming_status = incoming.status;
+    if (!(equals$j(existing_status, incoming_status))) {
+        return false;
+    }
+    return true;
+}
+const ingest$8 = function AssignActionableListRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$n(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$4(luvio, input);
+    const ttlToUse = TTL$8;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$8, "sales-excellence", VERSION$i, RepresentationType$8, equals$i);
+    return createLink(key);
+};
+function getTypeCacheKeys$8(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$4(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$8,
+        mergeable: false
+    });
+}
+
+function select$q(luvio, params) {
+    return select$r();
+}
+function getResponseCacheKeys$8(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$8(storeKeyMap, luvio, response);
+}
+function ingestSuccess$8(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$4(luvio, body);
+    luvio.storeIngest(key, ingest$8, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$q(),
+        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$8(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v66.0',
+        basePath: '/connect/sales-excellence/actionable-list/assignment/' + config.urlParams.actionableListId + '',
+        method: 'post',
+        body: config.body,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$8 = 'actionableListAssignment';
+const actionableListAssignment_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('actionableListId', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('assignActionableList', true, 2 /* Body */, 4 /* Unsupported */),
+];
+const actionableListAssignment_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$8, actionableListAssignment_ConfigPropertyMetadata);
+const createResourceParams$8 = /*#__PURE__*/ createResourceParams$b(actionableListAssignment_ConfigPropertyMetadata);
+function typeCheckConfig$8(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$b(untrustedConfig, config, actionableListAssignment_ConfigPropertyMetadata);
+    const untrustedConfig_assignActionableList = untrustedConfig.assignActionableList;
+    const referenceAssignActionableListInputRepresentationValidationError = validate$p(untrustedConfig_assignActionableList);
+    if (referenceAssignActionableListInputRepresentationValidationError === null) {
+        config.assignActionableList = untrustedConfig_assignActionableList;
+    }
+    return config;
+}
+function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$8(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$8(luvio, config, options) {
+    const resourceParams = createResourceParams$8(config);
+    const request = createResourceRequest$8(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$8(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$8(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const actionableListAssignmentAdapterFactory = (luvio) => {
+    return function actionableListAssignment(untrustedConfig) {
+        const config = validateAdapterConfig$8(untrustedConfig, actionableListAssignment_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "actionableListAssignment"');
+        }
+        return buildNetworkSnapshot$8(luvio, config);
+    };
+};
+
+function validate$m(obj, path = 'ActionableListKPIMappingInputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_actionableListId = obj.actionableListId;
+        const path_actionableListId = path + '.actionableListId';
+        if (typeof obj_actionableListId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_actionableListId + '" (at "' + path_actionableListId + '")');
+        }
+        const obj_selectedKpis = obj.selectedKpis;
+        const path_selectedKpis = path + '.selectedKpis';
+        if (!ArrayIsArray(obj_selectedKpis)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_selectedKpis + '" (at "' + path_selectedKpis + '")');
+        }
+        for (let i = 0; i < obj_selectedKpis.length; i++) {
+            const obj_selectedKpis_item = obj_selectedKpis[i];
+            const path_selectedKpis_item = path_selectedKpis + '[' + i + ']';
+            if (typeof obj_selectedKpis_item !== 'object' || ArrayIsArray(obj_selectedKpis_item) || obj_selectedKpis_item === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj_selectedKpis_item + '" (at "' + path_selectedKpis_item + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+const VERSION$h = "664447b62c7867c12fe645c53773d8cd";
+function validate$l(obj, path = 'StatusResponseRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_code = obj.code;
+        const path_code = path + '.code';
+        if (typeof obj_code !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_code + '" (at "' + path_code + '")');
+        }
+        const obj_message = obj.message;
+        const path_message = path + '.message';
+        if (typeof obj_message !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_message + '" (at "' + path_message + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$p = function StatusResponseRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$h,
+        private: [],
+        selections: [
+            {
+                name: 'code',
+                kind: 'Scalar'
+            },
+            {
+                name: 'message',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$h(existing, incoming) {
+    const existing_code = existing.code;
+    const incoming_code = incoming.code;
+    if (!(existing_code === incoming_code)) {
+        return false;
+    }
+    const existing_message = existing.message;
+    const incoming_message = incoming.message;
+    if (!(existing_message === incoming_message)) {
+        return false;
+    }
+    return true;
+}
+
+const TTL$7 = 1000;
+const VERSION$g = "7e8d28dea9e0cad583080eee5645985c";
+function validate$k(obj, path = 'ActionableListKPIMappingRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_actionableListId = obj.actionableListId;
+        const path_actionableListId = path + '.actionableListId';
+        if (typeof obj_actionableListId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_actionableListId + '" (at "' + path_actionableListId + '")');
+        }
+        const obj_status = obj.status;
+        const path_status = path + '.status';
+        const referencepath_statusValidationError = validate$l(obj_status, path_status);
+        if (referencepath_statusValidationError !== null) {
+            let message = 'Object doesn\'t match StatusResponseRepresentation (at "' + path_status + '")\n';
+            message += referencepath_statusValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$7 = 'ActionableListKPIMappingRepresentation';
+function keyBuilder$b(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$7 + ':' + config.message;
+}
+function keyBuilderFromType$3(luvio, object) {
+    const keyParams = {
+        message: object.status.message
+    };
+    return keyBuilder$b(luvio, keyParams);
+}
+function normalize$7(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$o = function ActionableListKPIMappingRepresentationSelect() {
+    const { selections: StatusResponseRepresentation__selections, opaque: StatusResponseRepresentation__opaque, } = select$p();
+    return {
+        kind: 'Fragment',
+        version: VERSION$g,
+        private: [],
+        selections: [
+            {
+                name: 'actionableListId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'status',
+                kind: 'Object',
+                selections: StatusResponseRepresentation__selections
+            }
+        ]
+    };
+};
+function equals$g(existing, incoming) {
+    const existing_actionableListId = existing.actionableListId;
+    const incoming_actionableListId = incoming.actionableListId;
+    if (!(existing_actionableListId === incoming_actionableListId)) {
+        return false;
+    }
+    const existing_status = existing.status;
+    const incoming_status = incoming.status;
+    if (!(equals$h(existing_status, incoming_status))) {
+        return false;
+    }
+    return true;
+}
+const ingest$7 = function ActionableListKPIMappingRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$k(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$3(luvio, input);
+    const ttlToUse = TTL$7;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$7, "sales-excellence", VERSION$g, RepresentationType$7, equals$g);
+    return createLink(key);
+};
+function getTypeCacheKeys$7(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$3(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$7,
+        mergeable: false
+    });
+}
+
+function select$n(luvio, params) {
+    return select$o();
+}
+function getResponseCacheKeys$7(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$7(storeKeyMap, luvio, response);
+}
+function ingestSuccess$7(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$3(luvio, body);
+    luvio.storeIngest(key, ingest$7, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$n(),
+        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$7(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v66.0',
+        basePath: '/connect/sales-excellence/actionable-list/key-performance-indicators/mappings',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$7 = 'generateActionableListKpiMappingResults';
+const generateActionableListKpiMappingResults_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('generateActionableListKpiMapping', true, 2 /* Body */, 4 /* Unsupported */),
+];
+const generateActionableListKpiMappingResults_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$7, generateActionableListKpiMappingResults_ConfigPropertyMetadata);
+const createResourceParams$7 = /*#__PURE__*/ createResourceParams$b(generateActionableListKpiMappingResults_ConfigPropertyMetadata);
+function typeCheckConfig$7(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_generateActionableListKpiMapping = untrustedConfig.generateActionableListKpiMapping;
+    const referenceActionableListKPIMappingInputRepresentationValidationError = validate$m(untrustedConfig_generateActionableListKpiMapping);
+    if (referenceActionableListKPIMappingInputRepresentationValidationError === null) {
+        config.generateActionableListKpiMapping = untrustedConfig_generateActionableListKpiMapping;
+    }
+    return config;
+}
+function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$7(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$7(luvio, config, options) {
+    const resourceParams = createResourceParams$7(config);
+    const request = createResourceRequest$7(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$7(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$7(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const generateActionableListKpiMappingResultsAdapterFactory = (luvio) => {
+    return function generateActionableListKpiMappingResults(untrustedConfig) {
+        const config = validateAdapterConfig$7(untrustedConfig, generateActionableListKpiMappingResults_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "generateActionableListKpiMappingResults"');
+        }
+        return buildNetworkSnapshot$7(luvio, config);
+    };
+};
+
+function validate$j(obj, path = 'KpiBarInputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_actionableListId = obj.actionableListId;
+        const path_actionableListId = path + '.actionableListId';
+        if (typeof obj_actionableListId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_actionableListId + '" (at "' + path_actionableListId + '")');
+        }
+        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 + ']';
+                const referencepath_filters_itemValidationError = validate$z(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.isFetchAvailableKpis !== undefined) {
+            const obj_isFetchAvailableKpis = obj.isFetchAvailableKpis;
+            const path_isFetchAvailableKpis = path + '.isFetchAvailableKpis';
+            if (typeof obj_isFetchAvailableKpis !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isFetchAvailableKpis + '" (at "' + path_isFetchAvailableKpis + '")');
+            }
+        }
+        if (obj.slotSize !== undefined) {
+            const obj_slotSize = obj.slotSize;
+            const path_slotSize = path + '.slotSize';
+            if (typeof obj_slotSize !== 'number' || (typeof obj_slotSize === 'number' && Math.floor(obj_slotSize) !== obj_slotSize)) {
+                return new TypeError('Expected "integer" but received "' + typeof obj_slotSize + '" (at "' + path_slotSize + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+const VERSION$f = "0f0e85e3b9b83240d295d2754b6d38ef";
+function validate$i(obj, path = 'ActionableListAvailableKpiRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.almsId !== undefined) {
+            const obj_almsId = obj.almsId;
+            const path_almsId = path + '.almsId';
+            let obj_almsId_union0 = null;
+            const obj_almsId_union0_error = (() => {
+                if (typeof obj_almsId !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_almsId + '" (at "' + path_almsId + '")');
+                }
+            })();
+            if (obj_almsId_union0_error != null) {
+                obj_almsId_union0 = obj_almsId_union0_error.message;
+            }
+            let obj_almsId_union1 = null;
+            const obj_almsId_union1_error = (() => {
+                if (obj_almsId !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_almsId + '" (at "' + path_almsId + '")');
+                }
+            })();
+            if (obj_almsId_union1_error != null) {
+                obj_almsId_union1 = obj_almsId_union1_error.message;
+            }
+            if (obj_almsId_union0 && obj_almsId_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_almsId + '")';
+                message += '\n' + obj_almsId_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_almsId_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.description !== undefined) {
+            const obj_description = obj.description;
+            const path_description = path + '.description';
+            let obj_description_union0 = null;
+            const obj_description_union0_error = (() => {
+                if (typeof obj_description !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_description + '" (at "' + path_description + '")');
+                }
+            })();
+            if (obj_description_union0_error != null) {
+                obj_description_union0 = obj_description_union0_error.message;
+            }
+            let obj_description_union1 = null;
+            const obj_description_union1_error = (() => {
+                if (obj_description !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_description + '" (at "' + path_description + '")');
+                }
+            })();
+            if (obj_description_union1_error != null) {
+                obj_description_union1 = obj_description_union1_error.message;
+            }
+            if (obj_description_union0 && obj_description_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_description + '")';
+                message += '\n' + obj_description_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_description_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        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 + '")');
+        }
+        if (obj.metricId !== undefined) {
+            const obj_metricId = obj.metricId;
+            const path_metricId = path + '.metricId';
+            let obj_metricId_union0 = null;
+            const obj_metricId_union0_error = (() => {
+                if (typeof obj_metricId !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_metricId + '" (at "' + path_metricId + '")');
+                }
+            })();
+            if (obj_metricId_union0_error != null) {
+                obj_metricId_union0 = obj_metricId_union0_error.message;
+            }
+            let obj_metricId_union1 = null;
+            const obj_metricId_union1_error = (() => {
+                if (obj_metricId !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_metricId + '" (at "' + path_metricId + '")');
+                }
+            })();
+            if (obj_metricId_union1_error != null) {
+                obj_metricId_union1 = obj_metricId_union1_error.message;
+            }
+            if (obj_metricId_union0 && obj_metricId_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_metricId + '")';
+                message += '\n' + obj_metricId_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_metricId_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$m = function ActionableListAvailableKpiRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$f,
+        private: [],
+        selections: [
+            {
+                name: 'almsId',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'description',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'label',
+                kind: 'Scalar'
+            },
+            {
+                name: 'metricId',
+                kind: 'Scalar',
+                required: false
+            }
+        ]
+    };
+};
+function equals$f(existing, incoming) {
+    const existing_label = existing.label;
+    const incoming_label = incoming.label;
+    if (!(existing_label === incoming_label)) {
+        return false;
+    }
+    const existing_almsId = existing.almsId;
+    const incoming_almsId = incoming.almsId;
+    // if at least one of these optionals is defined
+    if (existing_almsId !== undefined || incoming_almsId !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_almsId === undefined || incoming_almsId === undefined) {
+            return false;
+        }
+        if (!(existing_almsId === incoming_almsId)) {
+            return false;
+        }
+    }
+    const existing_description = existing.description;
+    const incoming_description = incoming.description;
+    // if at least one of these optionals is defined
+    if (existing_description !== undefined || incoming_description !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_description === undefined || incoming_description === undefined) {
+            return false;
+        }
+        if (!(existing_description === incoming_description)) {
+            return false;
+        }
+    }
+    const existing_metricId = existing.metricId;
+    const incoming_metricId = incoming.metricId;
+    // if at least one of these optionals is defined
+    if (existing_metricId !== undefined || incoming_metricId !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_metricId === undefined || incoming_metricId === undefined) {
+            return false;
+        }
+        if (!(existing_metricId === incoming_metricId)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const VERSION$e = "0268ac7fdbd14f2565afaa7e65cae014";
+function validate$h(obj, path = 'KpiBarMetricRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.almsId !== undefined) {
+            const obj_almsId = obj.almsId;
+            const path_almsId = path + '.almsId';
+            let obj_almsId_union0 = null;
+            const obj_almsId_union0_error = (() => {
+                if (typeof obj_almsId !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_almsId + '" (at "' + path_almsId + '")');
+                }
+            })();
+            if (obj_almsId_union0_error != null) {
+                obj_almsId_union0 = obj_almsId_union0_error.message;
+            }
+            let obj_almsId_union1 = null;
+            const obj_almsId_union1_error = (() => {
+                if (obj_almsId !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_almsId + '" (at "' + path_almsId + '")');
+                }
+            })();
+            if (obj_almsId_union1_error != null) {
+                obj_almsId_union1 = obj_almsId_union1_error.message;
+            }
+            if (obj_almsId_union0 && obj_almsId_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_almsId + '")';
+                message += '\n' + obj_almsId_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_almsId_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_dataType = obj.dataType;
+        const path_dataType = path + '.dataType';
+        let obj_dataType_union0 = null;
+        const obj_dataType_union0_error = (() => {
+            if (typeof obj_dataType !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_dataType + '" (at "' + path_dataType + '")');
+            }
+        })();
+        if (obj_dataType_union0_error != null) {
+            obj_dataType_union0 = obj_dataType_union0_error.message;
+        }
+        let obj_dataType_union1 = null;
+        const obj_dataType_union1_error = (() => {
+            if (obj_dataType !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_dataType + '" (at "' + path_dataType + '")');
+            }
+        })();
+        if (obj_dataType_union1_error != null) {
+            obj_dataType_union1 = obj_dataType_union1_error.message;
+        }
+        if (obj_dataType_union0 && obj_dataType_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_dataType + '")';
+            message += '\n' + obj_dataType_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_dataType_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        if (obj.displayOrder !== undefined) {
+            const obj_displayOrder = obj.displayOrder;
+            const path_displayOrder = path + '.displayOrder';
+            if (typeof obj_displayOrder !== 'number' || (typeof obj_displayOrder === 'number' && Math.floor(obj_displayOrder) !== obj_displayOrder)) {
+                return new TypeError('Expected "integer" but received "' + typeof obj_displayOrder + '" (at "' + path_displayOrder + '")');
+            }
+        }
+        const obj_errorMessage = obj.errorMessage;
+        const path_errorMessage = path + '.errorMessage';
+        if (typeof obj_errorMessage !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_errorMessage + '" (at "' + path_errorMessage + '")');
+        }
+        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$z(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);
+            }
+        }
+        const obj_isError = obj.isError;
+        const path_isError = path + '.isError';
+        if (typeof obj_isError !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_isError + '" (at "' + path_isError + '")');
+        }
+        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 + '")');
+        }
+        if (obj.metricId !== undefined) {
+            const obj_metricId = obj.metricId;
+            const path_metricId = path + '.metricId';
+            let obj_metricId_union0 = null;
+            const obj_metricId_union0_error = (() => {
+                if (typeof obj_metricId !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_metricId + '" (at "' + path_metricId + '")');
+                }
+            })();
+            if (obj_metricId_union0_error != null) {
+                obj_metricId_union0 = obj_metricId_union0_error.message;
+            }
+            let obj_metricId_union1 = null;
+            const obj_metricId_union1_error = (() => {
+                if (obj_metricId !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_metricId + '" (at "' + path_metricId + '")');
+                }
+            })();
+            if (obj_metricId_union1_error != null) {
+                obj_metricId_union1 = obj_metricId_union1_error.message;
+            }
+            if (obj_metricId_union0 && obj_metricId_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_metricId + '")';
+                message += '\n' + obj_metricId_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_metricId_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_value = obj.value;
+        const path_value = path + '.value';
+        if (typeof obj_value !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_value + '" (at "' + path_value + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$l = function KpiBarMetricRepresentationSelect() {
+    const { selections: FilterRepresentation__selections, opaque: FilterRepresentation__opaque, } = select$x();
+    return {
+        kind: 'Fragment',
+        version: VERSION$e,
+        private: [],
+        selections: [
+            {
+                name: 'almsId',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'dataType',
+                kind: 'Scalar'
+            },
+            {
+                name: 'displayOrder',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'errorMessage',
+                kind: 'Scalar'
+            },
+            {
+                name: 'filters',
+                kind: 'Object',
+                plural: true,
+                selections: FilterRepresentation__selections
+            },
+            {
+                name: 'isError',
+                kind: 'Scalar'
+            },
+            {
+                name: 'label',
+                kind: 'Scalar'
+            },
+            {
+                name: 'metricId',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'value',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$e(existing, incoming) {
+    const existing_isError = existing.isError;
+    const incoming_isError = incoming.isError;
+    if (!(existing_isError === incoming_isError)) {
+        return false;
+    }
+    const existing_displayOrder = existing.displayOrder;
+    const incoming_displayOrder = incoming.displayOrder;
+    // if at least one of these optionals is defined
+    if (existing_displayOrder !== undefined || incoming_displayOrder !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_displayOrder === undefined || incoming_displayOrder === undefined) {
+            return false;
+        }
+        if (!(existing_displayOrder === incoming_displayOrder)) {
+            return false;
+        }
+    }
+    const existing_errorMessage = existing.errorMessage;
+    const incoming_errorMessage = incoming.errorMessage;
+    if (!(existing_errorMessage === incoming_errorMessage)) {
+        return false;
+    }
+    const existing_label = existing.label;
+    const incoming_label = incoming.label;
+    if (!(existing_label === incoming_label)) {
+        return false;
+    }
+    const existing_value = existing.value;
+    const incoming_value = incoming.value;
+    if (!(existing_value === incoming_value)) {
+        return false;
+    }
+    const existing_almsId = existing.almsId;
+    const incoming_almsId = incoming.almsId;
+    // if at least one of these optionals is defined
+    if (existing_almsId !== undefined || incoming_almsId !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_almsId === undefined || incoming_almsId === undefined) {
+            return false;
+        }
+        if (!(existing_almsId === incoming_almsId)) {
+            return false;
+        }
+    }
+    const existing_dataType = existing.dataType;
+    const incoming_dataType = incoming.dataType;
+    if (!(existing_dataType === incoming_dataType)) {
+        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$m(existing_filters_item, incoming_filters_item))) {
+            return false;
+        }
+    });
+    if (equals_filters_items === false) {
+        return false;
+    }
+    const existing_metricId = existing.metricId;
+    const incoming_metricId = incoming.metricId;
+    // if at least one of these optionals is defined
+    if (existing_metricId !== undefined || incoming_metricId !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_metricId === undefined || incoming_metricId === undefined) {
+            return false;
+        }
+        if (!(existing_metricId === incoming_metricId)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const TTL$6 = 1000;
+const VERSION$d = "18c17c9f4fee641329d32737fa497505";
+function validate$g(obj, path = 'KpiBarOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_availableKpis = obj.availableKpis;
+        const path_availableKpis = path + '.availableKpis';
+        if (!ArrayIsArray(obj_availableKpis)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_availableKpis + '" (at "' + path_availableKpis + '")');
+        }
+        for (let i = 0; i < obj_availableKpis.length; i++) {
+            const obj_availableKpis_item = obj_availableKpis[i];
+            const path_availableKpis_item = path_availableKpis + '[' + i + ']';
+            const referencepath_availableKpis_itemValidationError = validate$i(obj_availableKpis_item, path_availableKpis_item);
+            if (referencepath_availableKpis_itemValidationError !== null) {
+                let message = 'Object doesn\'t match ActionableListAvailableKpiRepresentation (at "' + path_availableKpis_item + '")\n';
+                message += referencepath_availableKpis_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.isKpiConfigureAllowed !== undefined) {
+            const obj_isKpiConfigureAllowed = obj.isKpiConfigureAllowed;
+            const path_isKpiConfigureAllowed = path + '.isKpiConfigureAllowed';
+            let obj_isKpiConfigureAllowed_union0 = null;
+            const obj_isKpiConfigureAllowed_union0_error = (() => {
+                if (typeof obj_isKpiConfigureAllowed !== 'boolean') {
+                    return new TypeError('Expected "boolean" but received "' + typeof obj_isKpiConfigureAllowed + '" (at "' + path_isKpiConfigureAllowed + '")');
+                }
+            })();
+            if (obj_isKpiConfigureAllowed_union0_error != null) {
+                obj_isKpiConfigureAllowed_union0 = obj_isKpiConfigureAllowed_union0_error.message;
+            }
+            let obj_isKpiConfigureAllowed_union1 = null;
+            const obj_isKpiConfigureAllowed_union1_error = (() => {
+                if (obj_isKpiConfigureAllowed !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_isKpiConfigureAllowed + '" (at "' + path_isKpiConfigureAllowed + '")');
+                }
+            })();
+            if (obj_isKpiConfigureAllowed_union1_error != null) {
+                obj_isKpiConfigureAllowed_union1 = obj_isKpiConfigureAllowed_union1_error.message;
+            }
+            if (obj_isKpiConfigureAllowed_union0 && obj_isKpiConfigureAllowed_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_isKpiConfigureAllowed + '")';
+                message += '\n' + obj_isKpiConfigureAllowed_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_isKpiConfigureAllowed_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_kpiMetrics = obj.kpiMetrics;
+        const path_kpiMetrics = path + '.kpiMetrics';
+        if (!ArrayIsArray(obj_kpiMetrics)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_kpiMetrics + '" (at "' + path_kpiMetrics + '")');
+        }
+        for (let i = 0; i < obj_kpiMetrics.length; i++) {
+            const obj_kpiMetrics_item = obj_kpiMetrics[i];
+            const path_kpiMetrics_item = path_kpiMetrics + '[' + i + ']';
+            const referencepath_kpiMetrics_itemValidationError = validate$h(obj_kpiMetrics_item, path_kpiMetrics_item);
+            if (referencepath_kpiMetrics_itemValidationError !== null) {
+                let message = 'Object doesn\'t match KpiBarMetricRepresentation (at "' + path_kpiMetrics_item + '")\n';
+                message += referencepath_kpiMetrics_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_status = obj.status;
+        const path_status = path + '.status';
+        const referencepath_statusValidationError = validate$l(obj_status, path_status);
+        if (referencepath_statusValidationError !== null) {
+            let message = 'Object doesn\'t match StatusResponseRepresentation (at "' + path_status + '")\n';
+            message += referencepath_statusValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$6 = 'KpiBarOutputRepresentation';
+function keyBuilder$a(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$6 + ':' + config.message;
+}
+function keyBuilderFromType$2(luvio, object) {
+    const keyParams = {
+        message: object.status.message
+    };
+    return keyBuilder$a(luvio, keyParams);
+}
+function normalize$6(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$k = function KpiBarOutputRepresentationSelect() {
+    const { selections: ActionableListAvailableKpiRepresentation__selections, opaque: ActionableListAvailableKpiRepresentation__opaque, } = select$m();
+    const { selections: KpiBarMetricRepresentation__selections, opaque: KpiBarMetricRepresentation__opaque, } = select$l();
+    const { selections: StatusResponseRepresentation__selections, opaque: StatusResponseRepresentation__opaque, } = select$p();
+    return {
+        kind: 'Fragment',
+        version: VERSION$d,
+        private: [],
+        selections: [
+            {
+                name: 'availableKpis',
+                kind: 'Object',
+                plural: true,
+                selections: ActionableListAvailableKpiRepresentation__selections
+            },
+            {
+                name: 'isKpiConfigureAllowed',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'kpiMetrics',
+                kind: 'Object',
+                plural: true,
+                selections: KpiBarMetricRepresentation__selections
+            },
+            {
+                name: 'status',
+                kind: 'Object',
+                selections: StatusResponseRepresentation__selections
+            }
+        ]
+    };
+};
+function equals$d(existing, incoming) {
+    const existing_availableKpis = existing.availableKpis;
+    const incoming_availableKpis = incoming.availableKpis;
+    const equals_availableKpis_items = equalsArray(existing_availableKpis, incoming_availableKpis, (existing_availableKpis_item, incoming_availableKpis_item) => {
+        if (!(equals$f(existing_availableKpis_item, incoming_availableKpis_item))) {
+            return false;
+        }
+    });
+    if (equals_availableKpis_items === false) {
+        return false;
+    }
+    const existing_isKpiConfigureAllowed = existing.isKpiConfigureAllowed;
+    const incoming_isKpiConfigureAllowed = incoming.isKpiConfigureAllowed;
+    // if at least one of these optionals is defined
+    if (existing_isKpiConfigureAllowed !== undefined || incoming_isKpiConfigureAllowed !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_isKpiConfigureAllowed === undefined || incoming_isKpiConfigureAllowed === undefined) {
+            return false;
+        }
+        if (!(existing_isKpiConfigureAllowed === incoming_isKpiConfigureAllowed)) {
+            return false;
+        }
+    }
+    const existing_kpiMetrics = existing.kpiMetrics;
+    const incoming_kpiMetrics = incoming.kpiMetrics;
+    const equals_kpiMetrics_items = equalsArray(existing_kpiMetrics, incoming_kpiMetrics, (existing_kpiMetrics_item, incoming_kpiMetrics_item) => {
+        if (!(equals$e(existing_kpiMetrics_item, incoming_kpiMetrics_item))) {
+            return false;
+        }
+    });
+    if (equals_kpiMetrics_items === false) {
+        return false;
+    }
+    const existing_status = existing.status;
+    const incoming_status = incoming.status;
+    if (!(equals$h(existing_status, incoming_status))) {
+        return false;
+    }
+    return true;
+}
+const ingest$6 = function KpiBarOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$g(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$2(luvio, input);
+    const ttlToUse = TTL$6;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$6, "sales-excellence", VERSION$d, RepresentationType$6, equals$d);
+    return createLink(key);
+};
+function getTypeCacheKeys$6(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$2(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$6,
+        mergeable: false
+    });
+}
+
+function select$j(luvio, params) {
+    return select$k();
+}
+function getResponseCacheKeys$6(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$6(storeKeyMap, luvio, response);
+}
+function ingestSuccess$6(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$2(luvio, body);
+    luvio.storeIngest(key, ingest$6, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$j(),
+        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$6(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v66.0',
+        basePath: '/connect/sales-excellence/actionable-list/kpi',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$6 = 'generateActionableListKpiBarResults';
+const generateActionableListKpiBarResults_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('generateActionableListKpiBar', true, 2 /* Body */, 4 /* Unsupported */),
+];
+const generateActionableListKpiBarResults_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$6, generateActionableListKpiBarResults_ConfigPropertyMetadata);
+const createResourceParams$6 = /*#__PURE__*/ createResourceParams$b(generateActionableListKpiBarResults_ConfigPropertyMetadata);
+function typeCheckConfig$6(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_generateActionableListKpiBar = untrustedConfig.generateActionableListKpiBar;
+    const referenceKpiBarInputRepresentationValidationError = validate$j(untrustedConfig_generateActionableListKpiBar);
+    if (referenceKpiBarInputRepresentationValidationError === null) {
+        config.generateActionableListKpiBar = untrustedConfig_generateActionableListKpiBar;
+    }
+    return config;
+}
+function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$6(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$6(luvio, config, options) {
+    const resourceParams = createResourceParams$6(config);
+    const request = createResourceRequest$6(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$6(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$6(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const generateActionableListKpiBarResultsAdapterFactory = (luvio) => {
+    return function generateActionableListKpiBarResults(untrustedConfig) {
+        const config = validateAdapterConfig$6(untrustedConfig, generateActionableListKpiBarResults_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "generateActionableListKpiBarResults"');
+        }
+        return buildNetworkSnapshot$6(luvio, config);
+    };
+};
+
+const VERSION$c = "7c32234c44b8dc4571127a7b122f9de6";
+function validate$f(obj, path = 'AssignedActionableListRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_id = obj.id;
+        const path_id = path + '.id';
+        if (typeof obj_id !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_id + '" (at "' + path_id + '")');
+        }
+        if (obj.memberSortBy !== undefined) {
+            const obj_memberSortBy = obj.memberSortBy;
+            const path_memberSortBy = path + '.memberSortBy';
+            let obj_memberSortBy_union0 = null;
+            const obj_memberSortBy_union0_error = (() => {
+                if (typeof obj_memberSortBy !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_memberSortBy + '" (at "' + path_memberSortBy + '")');
+                }
+            })();
+            if (obj_memberSortBy_union0_error != null) {
+                obj_memberSortBy_union0 = obj_memberSortBy_union0_error.message;
+            }
+            let obj_memberSortBy_union1 = null;
+            const obj_memberSortBy_union1_error = (() => {
+                if (obj_memberSortBy !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_memberSortBy + '" (at "' + path_memberSortBy + '")');
+                }
+            })();
+            if (obj_memberSortBy_union1_error != null) {
+                obj_memberSortBy_union1 = obj_memberSortBy_union1_error.message;
+            }
+            if (obj_memberSortBy_union0 && obj_memberSortBy_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_memberSortBy + '")';
+                message += '\n' + obj_memberSortBy_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_memberSortBy_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.memberSortOrder !== undefined) {
+            const obj_memberSortOrder = obj.memberSortOrder;
+            const path_memberSortOrder = path + '.memberSortOrder';
+            let obj_memberSortOrder_union0 = null;
+            const obj_memberSortOrder_union0_error = (() => {
+                if (typeof obj_memberSortOrder !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_memberSortOrder + '" (at "' + path_memberSortOrder + '")');
+                }
+            })();
+            if (obj_memberSortOrder_union0_error != null) {
+                obj_memberSortOrder_union0 = obj_memberSortOrder_union0_error.message;
+            }
+            let obj_memberSortOrder_union1 = null;
+            const obj_memberSortOrder_union1_error = (() => {
+                if (obj_memberSortOrder !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_memberSortOrder + '" (at "' + path_memberSortOrder + '")');
+                }
+            })();
+            if (obj_memberSortOrder_union1_error != null) {
+                obj_memberSortOrder_union1 = obj_memberSortOrder_union1_error.message;
+            }
+            if (obj_memberSortOrder_union0 && obj_memberSortOrder_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_memberSortOrder + '")';
+                message += '\n' + obj_memberSortOrder_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_memberSortOrder_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.name !== undefined) {
+            const obj_name = obj.name;
+            const path_name = path + '.name';
+            let obj_name_union0 = null;
+            const obj_name_union0_error = (() => {
+                if (typeof obj_name !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
+                }
+            })();
+            if (obj_name_union0_error != null) {
+                obj_name_union0 = obj_name_union0_error.message;
+            }
+            let obj_name_union1 = null;
+            const obj_name_union1_error = (() => {
+                if (obj_name !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_name + '" (at "' + path_name + '")');
+                }
+            })();
+            if (obj_name_union1_error != null) {
+                obj_name_union1 = obj_name_union1_error.message;
+            }
+            if (obj_name_union0 && obj_name_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_name + '")';
+                message += '\n' + obj_name_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_name_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.objectName !== undefined) {
+            const obj_objectName = obj.objectName;
+            const path_objectName = path + '.objectName';
+            let obj_objectName_union0 = null;
+            const obj_objectName_union0_error = (() => {
+                if (typeof obj_objectName !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_objectName + '" (at "' + path_objectName + '")');
+                }
+            })();
+            if (obj_objectName_union0_error != null) {
+                obj_objectName_union0 = obj_objectName_union0_error.message;
+            }
+            let obj_objectName_union1 = null;
+            const obj_objectName_union1_error = (() => {
+                if (obj_objectName !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_objectName + '" (at "' + path_objectName + '")');
+                }
+            })();
+            if (obj_objectName_union1_error != null) {
+                obj_objectName_union1 = obj_objectName_union1_error.message;
+            }
+            if (obj_objectName_union0 && obj_objectName_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_objectName + '")';
+                message += '\n' + obj_objectName_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_objectName_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.priority !== undefined) {
+            const obj_priority = obj.priority;
+            const path_priority = path + '.priority';
+            let obj_priority_union0 = null;
+            const obj_priority_union0_error = (() => {
+                if (typeof obj_priority !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_priority + '" (at "' + path_priority + '")');
+                }
+            })();
+            if (obj_priority_union0_error != null) {
+                obj_priority_union0 = obj_priority_union0_error.message;
+            }
+            let obj_priority_union1 = null;
+            const obj_priority_union1_error = (() => {
+                if (obj_priority !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_priority + '" (at "' + path_priority + '")');
+                }
+            })();
+            if (obj_priority_union1_error != null) {
+                obj_priority_union1 = obj_priority_union1_error.message;
+            }
+            if (obj_priority_union0 && obj_priority_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_priority + '")';
+                message += '\n' + obj_priority_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_priority_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$i = function AssignedActionableListRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$c,
+        private: [],
+        selections: [
+            {
+                name: 'id',
+                kind: 'Scalar'
+            },
+            {
+                name: 'memberSortBy',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'memberSortOrder',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'name',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'objectName',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'priority',
+                kind: 'Scalar',
+                required: false
+            }
+        ]
+    };
+};
+function equals$c(existing, incoming) {
+    const existing_id = existing.id;
+    const incoming_id = incoming.id;
+    if (!(existing_id === incoming_id)) {
+        return false;
+    }
+    const existing_memberSortBy = existing.memberSortBy;
+    const incoming_memberSortBy = incoming.memberSortBy;
+    // if at least one of these optionals is defined
+    if (existing_memberSortBy !== undefined || incoming_memberSortBy !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_memberSortBy === undefined || incoming_memberSortBy === undefined) {
+            return false;
+        }
+        if (!(existing_memberSortBy === incoming_memberSortBy)) {
+            return false;
+        }
+    }
+    const existing_memberSortOrder = existing.memberSortOrder;
+    const incoming_memberSortOrder = incoming.memberSortOrder;
+    // if at least one of these optionals is defined
+    if (existing_memberSortOrder !== undefined || incoming_memberSortOrder !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_memberSortOrder === undefined || incoming_memberSortOrder === undefined) {
+            return false;
+        }
+        if (!(existing_memberSortOrder === incoming_memberSortOrder)) {
+            return false;
+        }
+    }
+    const existing_name = existing.name;
+    const incoming_name = incoming.name;
+    // if at least one of these optionals is defined
+    if (existing_name !== undefined || incoming_name !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_name === undefined || incoming_name === undefined) {
+            return false;
+        }
+        if (!(existing_name === incoming_name)) {
+            return false;
+        }
+    }
+    const existing_objectName = existing.objectName;
+    const incoming_objectName = incoming.objectName;
+    // if at least one of these optionals is defined
+    if (existing_objectName !== undefined || incoming_objectName !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_objectName === undefined || incoming_objectName === undefined) {
+            return false;
+        }
+        if (!(existing_objectName === incoming_objectName)) {
+            return false;
+        }
+    }
+    const existing_priority = existing.priority;
+    const incoming_priority = incoming.priority;
+    // if at least one of these optionals is defined
+    if (existing_priority !== undefined || incoming_priority !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_priority === undefined || incoming_priority === undefined) {
+            return false;
+        }
+        if (!(existing_priority === incoming_priority)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const TTL$5 = 10000;
+const VERSION$b = "66ae54ce61279094c1126ca58d9359c8";
+function validate$e(obj, path = 'AssignedActionableListsRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_actionableLists = obj.actionableLists;
+        const path_actionableLists = path + '.actionableLists';
+        if (!ArrayIsArray(obj_actionableLists)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_actionableLists + '" (at "' + path_actionableLists + '")');
+        }
+        for (let i = 0; i < obj_actionableLists.length; i++) {
+            const obj_actionableLists_item = obj_actionableLists[i];
+            const path_actionableLists_item = path_actionableLists + '[' + i + ']';
+            const referencepath_actionableLists_itemValidationError = validate$f(obj_actionableLists_item, path_actionableLists_item);
+            if (referencepath_actionableLists_itemValidationError !== null) {
+                let message = 'Object doesn\'t match AssignedActionableListRepresentation (at "' + path_actionableLists_item + '")\n';
+                message += referencepath_actionableLists_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$5 = 'AssignedActionableListsRepresentation';
+function normalize$5(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$h = function AssignedActionableListsRepresentationSelect() {
+    const { selections: AssignedActionableListRepresentation__selections, opaque: AssignedActionableListRepresentation__opaque, } = select$i();
+    return {
+        kind: 'Fragment',
+        version: VERSION$b,
+        private: [],
+        selections: [
+            {
+                name: 'actionableLists',
+                kind: 'Object',
+                plural: true,
+                selections: AssignedActionableListRepresentation__selections
+            }
+        ]
+    };
+};
+function equals$b(existing, incoming) {
+    const existing_actionableLists = existing.actionableLists;
+    const incoming_actionableLists = incoming.actionableLists;
+    const equals_actionableLists_items = equalsArray(existing_actionableLists, incoming_actionableLists, (existing_actionableLists_item, incoming_actionableLists_item) => {
+        if (!(equals$c(existing_actionableLists_item, incoming_actionableLists_item))) {
+            return false;
+        }
+    });
+    if (equals_actionableLists_items === false) {
+        return false;
+    }
+    return true;
+}
+const ingest$5 = function AssignedActionableListsRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$e(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = path.fullPath;
+    const ttlToUse = TTL$5;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$5, "sales-excellence", VERSION$b, RepresentationType$5, equals$b);
+    return createLink(key);
+};
+function getTypeCacheKeys$5(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = fullPathFactory();
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$5,
+        mergeable: false
+    });
+}
+
+function select$g(luvio, params) {
+    return select$h();
+}
+function keyBuilder$9(luvio, params) {
+    return keyPrefix + '::AssignedActionableListsRepresentation:(' + ')';
+}
+function getResponseCacheKeys$5(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$5(storeKeyMap, luvio, response, () => keyBuilder$9());
+}
+function ingestSuccess$5(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$9();
+    luvio.storeIngest(key, ingest$5, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$g(),
+        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$3(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$9();
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    const storeMetadataParams = {
+        ttl: TTL$5,
+        namespace: keyPrefix,
+        version: VERSION$b,
+        representationName: RepresentationType$5
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
+function createResourceRequest$5(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v66.0',
+        basePath: '/connect/sales-excellence/actionable-lists',
+        method: 'get',
+        body: null,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$5 = 'getAssignedActionableLists';
+const getAssignedActionableLists_ConfigPropertyMetadata = [];
+const getAssignedActionableLists_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, getAssignedActionableLists_ConfigPropertyMetadata);
+const createResourceParams$5 = /*#__PURE__*/ createResourceParams$b(getAssignedActionableLists_ConfigPropertyMetadata);
+function keyBuilder$8(luvio, config) {
+    createResourceParams$5(config);
+    return keyBuilder$9();
+}
+function typeCheckConfig$5(untrustedConfig) {
+    const config = {};
+    return config;
+}
+function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$5();
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment$3(luvio, config) {
+    createResourceParams$5(config);
+    return select$g();
+}
+function onFetchResponseSuccess$3(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$5(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError$3(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$3(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$5(luvio, config, options) {
+    const resourceParams = createResourceParams$5(config);
+    const request = createResourceRequest$5();
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$3(luvio, config, resourceParams, response), () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$5(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$3(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext, buildNetworkSnapshot$5, undefined, false);
+}
+function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$8(luvio, config),
+        node: adapterFragment$3(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getAssignedActionableListsAdapterFactory = (luvio) => function salesExcellence__getAssignedActionableLists(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$5(untrustedConfig, getAssignedActionableLists_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$3, buildNetworkSnapshotCachePolicy$3);
+};
+
+const VERSION$a = "da1afe98a78064ccd0f6db2ad9fd2593";
+function validate$d(obj, path = 'MetadataDetailRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.column !== undefined) {
+            const obj_column = obj.column;
+            const path_column = path + '.column';
+            if (typeof obj_column !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_column + '" (at "' + path_column + '")');
+            }
+        }
+        if (obj.label !== undefined) {
+            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 + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$f = function MetadataDetailRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$a,
+        private: [],
+        selections: [
+            {
+                name: 'column',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'label',
+                kind: 'Scalar',
+                required: false
+            }
+        ]
+    };
+};
+function equals$a(existing, incoming) {
+    const existing_column = existing.column;
+    const incoming_column = incoming.column;
+    // if at least one of these optionals is defined
+    if (existing_column !== undefined || incoming_column !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_column === undefined || incoming_column === undefined) {
+            return false;
+        }
+        if (!(existing_column === incoming_column)) {
+            return false;
+        }
+    }
+    const existing_label = existing.label;
+    const incoming_label = incoming.label;
+    // if at least one of these optionals is defined
+    if (existing_label !== undefined || incoming_label !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_label === undefined || incoming_label === undefined) {
+            return false;
+        }
+        if (!(existing_label === incoming_label)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const VERSION$9 = "28c3bee7344a89df450537785420f34d";
+function validate$c(obj, path = 'QuickActionsMetadataRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_metadataDetailRepresentation = obj.metadataDetailRepresentation;
+        const path_metadataDetailRepresentation = path + '.metadataDetailRepresentation';
+        if (!ArrayIsArray(obj_metadataDetailRepresentation)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_metadataDetailRepresentation + '" (at "' + path_metadataDetailRepresentation + '")');
+        }
+        for (let i = 0; i < obj_metadataDetailRepresentation.length; i++) {
+            const obj_metadataDetailRepresentation_item = obj_metadataDetailRepresentation[i];
+            const path_metadataDetailRepresentation_item = path_metadataDetailRepresentation + '[' + i + ']';
+            const referencepath_metadataDetailRepresentation_itemValidationError = validate$d(obj_metadataDetailRepresentation_item, path_metadataDetailRepresentation_item);
+            if (referencepath_metadataDetailRepresentation_itemValidationError !== null) {
+                let message = 'Object doesn\'t match MetadataDetailRepresentation (at "' + path_metadataDetailRepresentation_item + '")\n';
+                message += referencepath_metadataDetailRepresentation_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_quickActionType = obj.quickActionType;
+        const path_quickActionType = path + '.quickActionType';
+        if (typeof obj_quickActionType !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_quickActionType + '" (at "' + path_quickActionType + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$e = function QuickActionsMetadataRepresentationSelect() {
+    const { selections: MetadataDetailRepresentation__selections, opaque: MetadataDetailRepresentation__opaque, } = select$f();
+    return {
+        kind: 'Fragment',
+        version: VERSION$9,
+        private: [],
+        selections: [
+            {
+                name: 'metadataDetailRepresentation',
+                kind: 'Object',
+                plural: true,
+                selections: MetadataDetailRepresentation__selections
+            },
+            {
+                name: 'quickActionType',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$9(existing, incoming) {
+    const existing_quickActionType = existing.quickActionType;
+    const incoming_quickActionType = incoming.quickActionType;
+    if (!(existing_quickActionType === incoming_quickActionType)) {
+        return false;
+    }
+    const existing_metadataDetailRepresentation = existing.metadataDetailRepresentation;
+    const incoming_metadataDetailRepresentation = incoming.metadataDetailRepresentation;
+    const equals_metadataDetailRepresentation_items = equalsArray(existing_metadataDetailRepresentation, incoming_metadataDetailRepresentation, (existing_metadataDetailRepresentation_item, incoming_metadataDetailRepresentation_item) => {
+        if (!(equals$a(existing_metadataDetailRepresentation_item, incoming_metadataDetailRepresentation_item))) {
+            return false;
+        }
+    });
+    if (equals_metadataDetailRepresentation_items === false) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$8 = "b8f02d6cfc3f16587ceaaf180b481f2f";
+function validate$b(obj, path = 'ALMStatusCountRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.count !== undefined) {
+            const obj_count = obj.count;
+            const path_count = path + '.count';
+            if (typeof obj_count !== 'number' || (typeof obj_count === 'number' && Math.floor(obj_count) !== obj_count)) {
+                return new TypeError('Expected "integer" but received "' + typeof obj_count + '" (at "' + path_count + '")');
+            }
+        }
+        if (obj.iconName !== undefined) {
+            const obj_iconName = obj.iconName;
+            const path_iconName = path + '.iconName';
+            let obj_iconName_union0 = null;
+            const obj_iconName_union0_error = (() => {
+                if (typeof obj_iconName !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_iconName + '" (at "' + path_iconName + '")');
+                }
+            })();
+            if (obj_iconName_union0_error != null) {
+                obj_iconName_union0 = obj_iconName_union0_error.message;
+            }
+            let obj_iconName_union1 = null;
+            const obj_iconName_union1_error = (() => {
+                if (obj_iconName !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_iconName + '" (at "' + path_iconName + '")');
+                }
+            })();
+            if (obj_iconName_union1_error != null) {
+                obj_iconName_union1 = obj_iconName_union1_error.message;
+            }
+            if (obj_iconName_union0 && obj_iconName_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_iconName + '")';
+                message += '\n' + obj_iconName_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_iconName_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_id = obj.id;
+        const path_id = path + '.id';
+        let obj_id_union0 = null;
+        const obj_id_union0_error = (() => {
+            if (typeof obj_id !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_id + '" (at "' + path_id + '")');
+            }
+        })();
+        if (obj_id_union0_error != null) {
+            obj_id_union0 = obj_id_union0_error.message;
+        }
+        let obj_id_union1 = null;
+        const obj_id_union1_error = (() => {
+            if (obj_id !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_id + '" (at "' + path_id + '")');
+            }
+        })();
+        if (obj_id_union1_error != null) {
+            obj_id_union1 = obj_id_union1_error.message;
+        }
+        if (obj_id_union0 && obj_id_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_id + '")';
+            message += '\n' + obj_id_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_id_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        if (obj.status !== undefined) {
+            const obj_status = obj.status;
+            const path_status = path + '.status';
+            let obj_status_union0 = null;
+            const obj_status_union0_error = (() => {
+                if (typeof obj_status !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_status + '" (at "' + path_status + '")');
+                }
+            })();
+            if (obj_status_union0_error != null) {
+                obj_status_union0 = obj_status_union0_error.message;
+            }
+            let obj_status_union1 = null;
+            const obj_status_union1_error = (() => {
+                if (obj_status !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_status + '" (at "' + path_status + '")');
+                }
+            })();
+            if (obj_status_union1_error != null) {
+                obj_status_union1 = obj_status_union1_error.message;
+            }
+            if (obj_status_union0 && obj_status_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_status + '")';
+                message += '\n' + obj_status_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_status_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$d = function ALMStatusCountRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$8,
+        private: [],
+        selections: [
+            {
+                name: 'count',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'iconName',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'id',
+                kind: 'Scalar'
+            },
+            {
+                name: 'status',
+                kind: 'Scalar',
+                required: false
+            }
+        ]
+    };
+};
+function equals$8(existing, incoming) {
+    const existing_count = existing.count;
+    const incoming_count = incoming.count;
+    // if at least one of these optionals is defined
+    if (existing_count !== undefined || incoming_count !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_count === undefined || incoming_count === undefined) {
+            return false;
+        }
+        if (!(existing_count === incoming_count)) {
+            return false;
+        }
+    }
+    const existing_iconName = existing.iconName;
+    const incoming_iconName = incoming.iconName;
+    // if at least one of these optionals is defined
+    if (existing_iconName !== undefined || incoming_iconName !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_iconName === undefined || incoming_iconName === undefined) {
+            return false;
+        }
+        if (!(existing_iconName === incoming_iconName)) {
+            return false;
+        }
+    }
+    const existing_id = existing.id;
+    const incoming_id = incoming.id;
+    if (!(existing_id === incoming_id)) {
+        return false;
+    }
+    const existing_status = existing.status;
+    const incoming_status = incoming.status;
+    // if at least one of these optionals is defined
+    if (existing_status !== undefined || incoming_status !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_status === undefined || incoming_status === undefined) {
+            return false;
+        }
+        if (!(existing_status === incoming_status)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const TTL$4 = 10000;
+const VERSION$7 = "55a4f9246a13af212e621c7d12a41eb2";
+function validate$a(obj, path = 'ActionableListMetadataRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_quickActionList = obj.quickActionList;
+        const path_quickActionList = path + '.quickActionList';
+        if (!ArrayIsArray(obj_quickActionList)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_quickActionList + '" (at "' + path_quickActionList + '")');
+        }
+        for (let i = 0; i < obj_quickActionList.length; i++) {
+            const obj_quickActionList_item = obj_quickActionList[i];
+            const path_quickActionList_item = path_quickActionList + '[' + i + ']';
+            const referencepath_quickActionList_itemValidationError = validate$c(obj_quickActionList_item, path_quickActionList_item);
+            if (referencepath_quickActionList_itemValidationError !== null) {
+                let message = 'Object doesn\'t match QuickActionsMetadataRepresentation (at "' + path_quickActionList_item + '")\n';
+                message += referencepath_quickActionList_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_statusCountList = obj.statusCountList;
+        const path_statusCountList = path + '.statusCountList';
+        if (!ArrayIsArray(obj_statusCountList)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_statusCountList + '" (at "' + path_statusCountList + '")');
+        }
+        for (let i = 0; i < obj_statusCountList.length; i++) {
+            const obj_statusCountList_item = obj_statusCountList[i];
+            const path_statusCountList_item = path_statusCountList + '[' + i + ']';
+            const referencepath_statusCountList_itemValidationError = validate$b(obj_statusCountList_item, path_statusCountList_item);
+            if (referencepath_statusCountList_itemValidationError !== null) {
+                let message = 'Object doesn\'t match ALMStatusCountRepresentation (at "' + path_statusCountList_item + '")\n';
+                message += referencepath_statusCountList_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$4 = 'ActionableListMetadataRepresentation';
+function normalize$4(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$c = function ActionableListMetadataRepresentationSelect() {
+    const { selections: QuickActionsMetadataRepresentation__selections, opaque: QuickActionsMetadataRepresentation__opaque, } = select$e();
+    const { selections: ALMStatusCountRepresentation__selections, opaque: ALMStatusCountRepresentation__opaque, } = select$d();
+    return {
+        kind: 'Fragment',
+        version: VERSION$7,
+        private: [],
+        selections: [
+            {
+                name: 'quickActionList',
+                kind: 'Object',
+                plural: true,
+                selections: QuickActionsMetadataRepresentation__selections
+            },
+            {
+                name: 'statusCountList',
+                kind: 'Object',
+                plural: true,
+                selections: ALMStatusCountRepresentation__selections
+            }
+        ]
+    };
+};
+function equals$7(existing, incoming) {
+    const existing_quickActionList = existing.quickActionList;
+    const incoming_quickActionList = incoming.quickActionList;
+    const equals_quickActionList_items = equalsArray(existing_quickActionList, incoming_quickActionList, (existing_quickActionList_item, incoming_quickActionList_item) => {
+        if (!(equals$9(existing_quickActionList_item, incoming_quickActionList_item))) {
+            return false;
+        }
+    });
+    if (equals_quickActionList_items === false) {
+        return false;
+    }
+    const existing_statusCountList = existing.statusCountList;
+    const incoming_statusCountList = incoming.statusCountList;
+    const equals_statusCountList_items = equalsArray(existing_statusCountList, incoming_statusCountList, (existing_statusCountList_item, incoming_statusCountList_item) => {
+        if (!(equals$8(existing_statusCountList_item, incoming_statusCountList_item))) {
+            return false;
+        }
+    });
+    if (equals_statusCountList_items === false) {
+        return false;
+    }
+    return true;
+}
+const ingest$4 = function ActionableListMetadataRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$a(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = path.fullPath;
+    const ttlToUse = TTL$4;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$4, "sales-excellence", VERSION$7, RepresentationType$4, equals$7);
+    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
+    });
+}
+
+function select$b(luvio, params) {
+    return select$c();
+}
+function keyBuilder$7(luvio, params) {
+    return keyPrefix + '::ActionableListMetadataRepresentation:(' + 'hasMemberStatus:' + params.queryParams.hasMemberStatus + ',' + 'hasQuickActions:' + params.queryParams.hasQuickActions + ',' + 'searchTerm:' + params.queryParams.searchTerm + ',' + 'actionableListId:' + params.urlParams.actionableListId + ')';
+}
+function getResponseCacheKeys$4(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$4(storeKeyMap, luvio, response, () => keyBuilder$7(luvio, resourceParams));
+}
+function ingestSuccess$4(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$7(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$4, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$b(),
+        variables: {},
+    }, snapshotRefresh);
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
+}
+function ingestError$2(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$7(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    const storeMetadataParams = {
+        ttl: TTL$4,
+        namespace: keyPrefix,
+        version: VERSION$7,
+        representationName: RepresentationType$4
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
+function createResourceRequest$4(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v66.0',
+        basePath: '/connect/sales-excellence/actionable-lists/metadata/' + config.urlParams.actionableListId + '',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: config.queryParams,
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$4 = 'getActionableListMetadata';
+const getActionableListMetadata_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('actionableListId', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('hasMemberStatus', false, 1 /* QueryParameter */, 1 /* Boolean */),
+    generateParamConfigMetadata('hasQuickActions', false, 1 /* QueryParameter */, 1 /* Boolean */),
+    generateParamConfigMetadata('searchTerm', false, 1 /* QueryParameter */, 0 /* String */),
+];
+const getActionableListMetadata_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, getActionableListMetadata_ConfigPropertyMetadata);
+const createResourceParams$4 = /*#__PURE__*/ createResourceParams$b(getActionableListMetadata_ConfigPropertyMetadata);
+function keyBuilder$6(luvio, config) {
+    const resourceParams = createResourceParams$4(config);
+    return keyBuilder$7(luvio, resourceParams);
+}
+function typeCheckConfig$4(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$b(untrustedConfig, config, getActionableListMetadata_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$4(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment$2(luvio, config) {
+    createResourceParams$4(config);
+    return select$b();
+}
+function onFetchResponseSuccess$2(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$4(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError$2(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$2(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$4(luvio, config, options) {
+    const resourceParams = createResourceParams$4(config);
+    const request = createResourceRequest$4(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$2(luvio, config, resourceParams, response), () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$4(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$2(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$2(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext, buildNetworkSnapshot$4, undefined, false);
+}
+function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$6(luvio, config),
+        node: adapterFragment$2(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getActionableListMetadataAdapterFactory = (luvio) => function salesExcellence__getActionableListMetadata(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$4(untrustedConfig, getActionableListMetadata_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$2, buildNetworkSnapshotCachePolicy$2);
+};
+
+const VERSION$6 = "5ee06c03318dcee9ddf5f4f1e0918b9e";
+function validate$9(obj, path = 'ActionableListMemberQueueRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_id = obj.id;
+        const path_id = path + '.id';
+        if (typeof obj_id !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_id + '" (at "' + path_id + '")');
+        }
+        const obj_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$a = function ActionableListMemberQueueRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$6,
+        private: [],
+        selections: [
+            {
+                name: 'id',
+                kind: 'Scalar'
+            },
+            {
+                name: 'name',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$6(existing, incoming) {
+    const existing_id = existing.id;
+    const incoming_id = incoming.id;
+    if (!(existing_id === incoming_id)) {
+        return false;
+    }
+    const existing_name = existing.name;
+    const incoming_name = incoming.name;
+    if (!(existing_name === incoming_name)) {
+        return false;
+    }
+    return true;
+}
+
+const TTL$3 = 10000;
+const VERSION$5 = "a264fdd863285cc900f49a937c8bb486";
+function validate$8(obj, path = 'ActionableListMemberQueuesRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.nextPageCursor !== undefined) {
+            const obj_nextPageCursor = obj.nextPageCursor;
+            const path_nextPageCursor = path + '.nextPageCursor';
+            if (typeof obj_nextPageCursor !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_nextPageCursor + '" (at "' + path_nextPageCursor + '")');
+            }
+        }
+        const obj_queues = obj.queues;
+        const path_queues = path + '.queues';
+        if (!ArrayIsArray(obj_queues)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_queues + '" (at "' + path_queues + '")');
+        }
+        for (let i = 0; i < obj_queues.length; i++) {
+            const obj_queues_item = obj_queues[i];
+            const path_queues_item = path_queues + '[' + i + ']';
+            const referencepath_queues_itemValidationError = validate$9(obj_queues_item, path_queues_item);
+            if (referencepath_queues_itemValidationError !== null) {
+                let message = 'Object doesn\'t match ActionableListMemberQueueRepresentation (at "' + path_queues_item + '")\n';
+                message += referencepath_queues_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$3 = 'ActionableListMemberQueuesRepresentation';
+function normalize$3(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$9 = function ActionableListMemberQueuesRepresentationSelect() {
+    const { selections: ActionableListMemberQueueRepresentation__selections, opaque: ActionableListMemberQueueRepresentation__opaque, } = select$a();
+    return {
+        kind: 'Fragment',
+        version: VERSION$5,
+        private: [],
+        selections: [
+            {
+                name: 'nextPageCursor',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'queues',
+                kind: 'Object',
+                plural: true,
+                selections: ActionableListMemberQueueRepresentation__selections
+            }
+        ]
+    };
+};
+function equals$5(existing, incoming) {
+    const existing_nextPageCursor = existing.nextPageCursor;
+    const incoming_nextPageCursor = incoming.nextPageCursor;
+    // if at least one of these optionals is defined
+    if (existing_nextPageCursor !== undefined || incoming_nextPageCursor !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_nextPageCursor === undefined || incoming_nextPageCursor === undefined) {
+            return false;
+        }
+        if (!(existing_nextPageCursor === incoming_nextPageCursor)) {
+            return false;
+        }
+    }
+    const existing_queues = existing.queues;
+    const incoming_queues = incoming.queues;
+    const equals_queues_items = equalsArray(existing_queues, incoming_queues, (existing_queues_item, incoming_queues_item) => {
+        if (!(equals$6(existing_queues_item, incoming_queues_item))) {
+            return false;
+        }
+    });
+    if (equals_queues_items === false) {
+        return false;
+    }
+    return true;
+}
+const ingest$3 = function ActionableListMemberQueuesRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$8(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = path.fullPath;
+    const ttlToUse = TTL$3;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$3, "sales-excellence", VERSION$5, RepresentationType$3, equals$5);
+    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
+    });
+}
+
+function select$8(luvio, params) {
+    return select$9();
+}
+function keyBuilder$5(luvio, params) {
+    return keyPrefix + '::ActionableListMemberQueuesRepresentation:(' + 'nextPageCursor:' + params.queryParams.nextPageCursor + ',' + 'searchTerm:' + params.queryParams.searchTerm + ')';
+}
+function getResponseCacheKeys$3(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$3(storeKeyMap, luvio, response, () => keyBuilder$5(luvio, resourceParams));
+}
+function ingestSuccess$3(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$5(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$3, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$8(),
+        variables: {},
+    }, snapshotRefresh);
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
+}
+function ingestError$1(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$5(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    const storeMetadataParams = {
+        ttl: TTL$3,
+        namespace: keyPrefix,
+        version: VERSION$5,
+        representationName: RepresentationType$3
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
+function createResourceRequest$3(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v66.0',
+        basePath: '/connect/sales-excellence/actionable-list-member/queues',
+        method: 'get',
+        body: null,
+        urlParams: {},
+        queryParams: config.queryParams,
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$3 = 'getALMQueues';
+const getALMQueues_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('nextPageCursor', false, 1 /* QueryParameter */, 0 /* String */),
+    generateParamConfigMetadata('searchTerm', false, 1 /* QueryParameter */, 0 /* String */),
+];
+const getALMQueues_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, getALMQueues_ConfigPropertyMetadata);
+const createResourceParams$3 = /*#__PURE__*/ createResourceParams$b(getALMQueues_ConfigPropertyMetadata);
+function keyBuilder$4(luvio, config) {
+    const resourceParams = createResourceParams$3(config);
+    return keyBuilder$5(luvio, resourceParams);
+}
+function typeCheckConfig$3(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$b(untrustedConfig, config, getALMQueues_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$3(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment$1(luvio, config) {
+    createResourceParams$3(config);
+    return select$8();
+}
+function onFetchResponseSuccess$1(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$3(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError$1(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$1(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$3(luvio, config, options) {
+    const resourceParams = createResourceParams$3(config);
+    const request = createResourceRequest$3(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$1(luvio, config, resourceParams, response), () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$3(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$1(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext, buildNetworkSnapshot$3, undefined, false);
+}
+function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$4(luvio, config),
+        node: adapterFragment$1(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getALMQueuesAdapterFactory = (luvio) => function salesExcellence__getALMQueues(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$3(untrustedConfig, getALMQueues_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$1, buildNetworkSnapshotCachePolicy$1);
+};
+
+const VERSION$4 = "5045452cc02f9152f2d789e3cf756fc3";
+function validate$7(obj, path = 'SegmentDetailsRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_createdDate = obj.createdDate;
+        const path_createdDate = path + '.createdDate';
+        if (typeof obj_createdDate !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_createdDate + '" (at "' + path_createdDate + '")');
+        }
+        const obj_dataSpaceDevName = obj.dataSpaceDevName;
+        const path_dataSpaceDevName = path + '.dataSpaceDevName';
+        let obj_dataSpaceDevName_union0 = null;
+        const obj_dataSpaceDevName_union0_error = (() => {
+            if (typeof obj_dataSpaceDevName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_dataSpaceDevName + '" (at "' + path_dataSpaceDevName + '")');
+            }
+        })();
+        if (obj_dataSpaceDevName_union0_error != null) {
+            obj_dataSpaceDevName_union0 = obj_dataSpaceDevName_union0_error.message;
+        }
+        let obj_dataSpaceDevName_union1 = null;
+        const obj_dataSpaceDevName_union1_error = (() => {
+            if (obj_dataSpaceDevName !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_dataSpaceDevName + '" (at "' + path_dataSpaceDevName + '")');
+            }
+        })();
+        if (obj_dataSpaceDevName_union1_error != null) {
+            obj_dataSpaceDevName_union1 = obj_dataSpaceDevName_union1_error.message;
+        }
+        if (obj_dataSpaceDevName_union0 && obj_dataSpaceDevName_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_dataSpaceDevName + '")';
+            message += '\n' + obj_dataSpaceDevName_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_dataSpaceDevName_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_dataSpaceName = obj.dataSpaceName;
+        const path_dataSpaceName = path + '.dataSpaceName';
+        let obj_dataSpaceName_union0 = null;
+        const obj_dataSpaceName_union0_error = (() => {
+            if (typeof obj_dataSpaceName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_dataSpaceName + '" (at "' + path_dataSpaceName + '")');
+            }
+        })();
+        if (obj_dataSpaceName_union0_error != null) {
+            obj_dataSpaceName_union0 = obj_dataSpaceName_union0_error.message;
+        }
+        let obj_dataSpaceName_union1 = null;
+        const obj_dataSpaceName_union1_error = (() => {
+            if (obj_dataSpaceName !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_dataSpaceName + '" (at "' + path_dataSpaceName + '")');
+            }
+        })();
+        if (obj_dataSpaceName_union1_error != null) {
+            obj_dataSpaceName_union1 = obj_dataSpaceName_union1_error.message;
+        }
+        if (obj_dataSpaceName_union0 && obj_dataSpaceName_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_dataSpaceName + '")';
+            message += '\n' + obj_dataSpaceName_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_dataSpaceName_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_description = obj.description;
+        const path_description = path + '.description';
+        let obj_description_union0 = null;
+        const obj_description_union0_error = (() => {
+            if (typeof obj_description !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_description + '" (at "' + path_description + '")');
+            }
+        })();
+        if (obj_description_union0_error != null) {
+            obj_description_union0 = obj_description_union0_error.message;
+        }
+        let obj_description_union1 = null;
+        const obj_description_union1_error = (() => {
+            if (obj_description !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_description + '" (at "' + path_description + '")');
+            }
+        })();
+        if (obj_description_union1_error != null) {
+            obj_description_union1 = obj_description_union1_error.message;
+        }
+        if (obj_description_union0 && obj_description_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_description + '")';
+            message += '\n' + obj_description_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_description_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_id = obj.id;
+        const path_id = path + '.id';
+        if (typeof obj_id !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_id + '" (at "' + path_id + '")');
+        }
+        const obj_lastPublishedEndDateTime = obj.lastPublishedEndDateTime;
+        const path_lastPublishedEndDateTime = path + '.lastPublishedEndDateTime';
+        let obj_lastPublishedEndDateTime_union0 = null;
+        const obj_lastPublishedEndDateTime_union0_error = (() => {
+            if (typeof obj_lastPublishedEndDateTime !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_lastPublishedEndDateTime + '" (at "' + path_lastPublishedEndDateTime + '")');
+            }
+        })();
+        if (obj_lastPublishedEndDateTime_union0_error != null) {
+            obj_lastPublishedEndDateTime_union0 = obj_lastPublishedEndDateTime_union0_error.message;
+        }
+        let obj_lastPublishedEndDateTime_union1 = null;
+        const obj_lastPublishedEndDateTime_union1_error = (() => {
+            if (obj_lastPublishedEndDateTime !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_lastPublishedEndDateTime + '" (at "' + path_lastPublishedEndDateTime + '")');
+            }
+        })();
+        if (obj_lastPublishedEndDateTime_union1_error != null) {
+            obj_lastPublishedEndDateTime_union1 = obj_lastPublishedEndDateTime_union1_error.message;
+        }
+        if (obj_lastPublishedEndDateTime_union0 && obj_lastPublishedEndDateTime_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_lastPublishedEndDateTime + '")';
+            message += '\n' + obj_lastPublishedEndDateTime_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_lastPublishedEndDateTime_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_lastSegmentMemberCount = obj.lastSegmentMemberCount;
+        const path_lastSegmentMemberCount = path + '.lastSegmentMemberCount';
+        let obj_lastSegmentMemberCount_union0 = null;
+        const obj_lastSegmentMemberCount_union0_error = (() => {
+            if (typeof obj_lastSegmentMemberCount !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_lastSegmentMemberCount + '" (at "' + path_lastSegmentMemberCount + '")');
+            }
+        })();
+        if (obj_lastSegmentMemberCount_union0_error != null) {
+            obj_lastSegmentMemberCount_union0 = obj_lastSegmentMemberCount_union0_error.message;
+        }
+        let obj_lastSegmentMemberCount_union1 = null;
+        const obj_lastSegmentMemberCount_union1_error = (() => {
+            if (obj_lastSegmentMemberCount !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_lastSegmentMemberCount + '" (at "' + path_lastSegmentMemberCount + '")');
+            }
+        })();
+        if (obj_lastSegmentMemberCount_union1_error != null) {
+            obj_lastSegmentMemberCount_union1 = obj_lastSegmentMemberCount_union1_error.message;
+        }
+        if (obj_lastSegmentMemberCount_union0 && obj_lastSegmentMemberCount_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_lastSegmentMemberCount + '")';
+            message += '\n' + obj_lastSegmentMemberCount_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_lastSegmentMemberCount_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_mktDataModelObjectId = obj.mktDataModelObjectId;
+        const path_mktDataModelObjectId = path + '.mktDataModelObjectId';
+        if (typeof obj_mktDataModelObjectId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_mktDataModelObjectId + '" (at "' + path_mktDataModelObjectId + '")');
+        }
+        const obj_mktDataModelObjectNameSpacePrefix = obj.mktDataModelObjectNameSpacePrefix;
+        const path_mktDataModelObjectNameSpacePrefix = path + '.mktDataModelObjectNameSpacePrefix';
+        let obj_mktDataModelObjectNameSpacePrefix_union0 = null;
+        const obj_mktDataModelObjectNameSpacePrefix_union0_error = (() => {
+            if (typeof obj_mktDataModelObjectNameSpacePrefix !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_mktDataModelObjectNameSpacePrefix + '" (at "' + path_mktDataModelObjectNameSpacePrefix + '")');
+            }
+        })();
+        if (obj_mktDataModelObjectNameSpacePrefix_union0_error != null) {
+            obj_mktDataModelObjectNameSpacePrefix_union0 = obj_mktDataModelObjectNameSpacePrefix_union0_error.message;
+        }
+        let obj_mktDataModelObjectNameSpacePrefix_union1 = null;
+        const obj_mktDataModelObjectNameSpacePrefix_union1_error = (() => {
+            if (obj_mktDataModelObjectNameSpacePrefix !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_mktDataModelObjectNameSpacePrefix + '" (at "' + path_mktDataModelObjectNameSpacePrefix + '")');
+            }
+        })();
+        if (obj_mktDataModelObjectNameSpacePrefix_union1_error != null) {
+            obj_mktDataModelObjectNameSpacePrefix_union1 = obj_mktDataModelObjectNameSpacePrefix_union1_error.message;
+        }
+        if (obj_mktDataModelObjectNameSpacePrefix_union0 && obj_mktDataModelObjectNameSpacePrefix_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_mktDataModelObjectNameSpacePrefix + '")';
+            message += '\n' + obj_mktDataModelObjectNameSpacePrefix_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_mktDataModelObjectNameSpacePrefix_union1.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_publishScheduleInterval = obj.publishScheduleInterval;
+        const path_publishScheduleInterval = path + '.publishScheduleInterval';
+        if (typeof obj_publishScheduleInterval !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_publishScheduleInterval + '" (at "' + path_publishScheduleInterval + '")');
+        }
+        const obj_publishScheduleStartDateTime = obj.publishScheduleStartDateTime;
+        const path_publishScheduleStartDateTime = path + '.publishScheduleStartDateTime';
+        let obj_publishScheduleStartDateTime_union0 = null;
+        const obj_publishScheduleStartDateTime_union0_error = (() => {
+            if (typeof obj_publishScheduleStartDateTime !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_publishScheduleStartDateTime + '" (at "' + path_publishScheduleStartDateTime + '")');
+            }
+        })();
+        if (obj_publishScheduleStartDateTime_union0_error != null) {
+            obj_publishScheduleStartDateTime_union0 = obj_publishScheduleStartDateTime_union0_error.message;
+        }
+        let obj_publishScheduleStartDateTime_union1 = null;
+        const obj_publishScheduleStartDateTime_union1_error = (() => {
+            if (obj_publishScheduleStartDateTime !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_publishScheduleStartDateTime + '" (at "' + path_publishScheduleStartDateTime + '")');
+            }
+        })();
+        if (obj_publishScheduleStartDateTime_union1_error != null) {
+            obj_publishScheduleStartDateTime_union1 = obj_publishScheduleStartDateTime_union1_error.message;
+        }
+        if (obj_publishScheduleStartDateTime_union0 && obj_publishScheduleStartDateTime_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_publishScheduleStartDateTime + '")';
+            message += '\n' + obj_publishScheduleStartDateTime_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_publishScheduleStartDateTime_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_publishStatus = obj.publishStatus;
+        const path_publishStatus = path + '.publishStatus';
+        let obj_publishStatus_union0 = null;
+        const obj_publishStatus_union0_error = (() => {
+            if (typeof obj_publishStatus !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_publishStatus + '" (at "' + path_publishStatus + '")');
+            }
+        })();
+        if (obj_publishStatus_union0_error != null) {
+            obj_publishStatus_union0 = obj_publishStatus_union0_error.message;
+        }
+        let obj_publishStatus_union1 = null;
+        const obj_publishStatus_union1_error = (() => {
+            if (obj_publishStatus !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_publishStatus + '" (at "' + path_publishStatus + '")');
+            }
+        })();
+        if (obj_publishStatus_union1_error != null) {
+            obj_publishStatus_union1 = obj_publishStatus_union1_error.message;
+        }
+        if (obj_publishStatus_union0 && obj_publishStatus_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_publishStatus + '")';
+            message += '\n' + obj_publishStatus_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_publishStatus_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_segmentMembershipTable = obj.segmentMembershipTable;
+        const path_segmentMembershipTable = path + '.segmentMembershipTable';
+        let obj_segmentMembershipTable_union0 = null;
+        const obj_segmentMembershipTable_union0_error = (() => {
+            if (typeof obj_segmentMembershipTable !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_segmentMembershipTable + '" (at "' + path_segmentMembershipTable + '")');
+            }
+        })();
+        if (obj_segmentMembershipTable_union0_error != null) {
+            obj_segmentMembershipTable_union0 = obj_segmentMembershipTable_union0_error.message;
+        }
+        let obj_segmentMembershipTable_union1 = null;
+        const obj_segmentMembershipTable_union1_error = (() => {
+            if (obj_segmentMembershipTable !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_segmentMembershipTable + '" (at "' + path_segmentMembershipTable + '")');
+            }
+        })();
+        if (obj_segmentMembershipTable_union1_error != null) {
+            obj_segmentMembershipTable_union1 = obj_segmentMembershipTable_union1_error.message;
+        }
+        if (obj_segmentMembershipTable_union0 && obj_segmentMembershipTable_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_segmentMembershipTable + '")';
+            message += '\n' + obj_segmentMembershipTable_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_segmentMembershipTable_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_segmentOn = obj.segmentOn;
+        const path_segmentOn = path + '.segmentOn';
+        if (typeof obj_segmentOn !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_segmentOn + '" (at "' + path_segmentOn + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$7 = function SegmentDetailsRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$4,
+        private: [],
+        selections: [
+            {
+                name: 'createdDate',
+                kind: 'Scalar'
+            },
+            {
+                name: 'dataSpaceDevName',
+                kind: 'Scalar'
+            },
+            {
+                name: 'dataSpaceName',
+                kind: 'Scalar'
+            },
+            {
+                name: 'description',
+                kind: 'Scalar'
+            },
+            {
+                name: 'id',
+                kind: 'Scalar'
+            },
+            {
+                name: 'lastPublishedEndDateTime',
+                kind: 'Scalar'
+            },
+            {
+                name: 'lastSegmentMemberCount',
+                kind: 'Scalar'
+            },
+            {
+                name: 'mktDataModelObjectId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'mktDataModelObjectNameSpacePrefix',
+                kind: 'Scalar'
+            },
+            {
+                name: 'name',
+                kind: 'Scalar'
+            },
+            {
+                name: 'publishScheduleInterval',
+                kind: 'Scalar'
+            },
+            {
+                name: 'publishScheduleStartDateTime',
+                kind: 'Scalar'
+            },
+            {
+                name: 'publishStatus',
+                kind: 'Scalar'
+            },
+            {
+                name: 'segmentMembershipTable',
+                kind: 'Scalar'
+            },
+            {
+                name: 'segmentOn',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$4(existing, incoming) {
+    const existing_createdDate = existing.createdDate;
+    const incoming_createdDate = incoming.createdDate;
+    if (!(existing_createdDate === incoming_createdDate)) {
+        return false;
+    }
+    const existing_id = existing.id;
+    const incoming_id = incoming.id;
+    if (!(existing_id === incoming_id)) {
+        return false;
+    }
+    const existing_mktDataModelObjectId = existing.mktDataModelObjectId;
+    const incoming_mktDataModelObjectId = incoming.mktDataModelObjectId;
+    if (!(existing_mktDataModelObjectId === incoming_mktDataModelObjectId)) {
+        return false;
+    }
+    const existing_name = existing.name;
+    const incoming_name = incoming.name;
+    if (!(existing_name === incoming_name)) {
+        return false;
+    }
+    const existing_publishScheduleInterval = existing.publishScheduleInterval;
+    const incoming_publishScheduleInterval = incoming.publishScheduleInterval;
+    if (!(existing_publishScheduleInterval === incoming_publishScheduleInterval)) {
+        return false;
+    }
+    const existing_segmentOn = existing.segmentOn;
+    const incoming_segmentOn = incoming.segmentOn;
+    if (!(existing_segmentOn === incoming_segmentOn)) {
+        return false;
+    }
+    const existing_dataSpaceDevName = existing.dataSpaceDevName;
+    const incoming_dataSpaceDevName = incoming.dataSpaceDevName;
+    if (!(existing_dataSpaceDevName === incoming_dataSpaceDevName)) {
+        return false;
+    }
+    const existing_dataSpaceName = existing.dataSpaceName;
+    const incoming_dataSpaceName = incoming.dataSpaceName;
+    if (!(existing_dataSpaceName === incoming_dataSpaceName)) {
+        return false;
+    }
+    const existing_description = existing.description;
+    const incoming_description = incoming.description;
+    if (!(existing_description === incoming_description)) {
+        return false;
+    }
+    const existing_lastPublishedEndDateTime = existing.lastPublishedEndDateTime;
+    const incoming_lastPublishedEndDateTime = incoming.lastPublishedEndDateTime;
+    if (!(existing_lastPublishedEndDateTime === incoming_lastPublishedEndDateTime)) {
+        return false;
+    }
+    const existing_lastSegmentMemberCount = existing.lastSegmentMemberCount;
+    const incoming_lastSegmentMemberCount = incoming.lastSegmentMemberCount;
+    if (!(existing_lastSegmentMemberCount === incoming_lastSegmentMemberCount)) {
+        return false;
+    }
+    const existing_mktDataModelObjectNameSpacePrefix = existing.mktDataModelObjectNameSpacePrefix;
+    const incoming_mktDataModelObjectNameSpacePrefix = incoming.mktDataModelObjectNameSpacePrefix;
+    if (!(existing_mktDataModelObjectNameSpacePrefix === incoming_mktDataModelObjectNameSpacePrefix)) {
+        return false;
+    }
+    const existing_publishScheduleStartDateTime = existing.publishScheduleStartDateTime;
+    const incoming_publishScheduleStartDateTime = incoming.publishScheduleStartDateTime;
+    if (!(existing_publishScheduleStartDateTime === incoming_publishScheduleStartDateTime)) {
+        return false;
+    }
+    const existing_publishStatus = existing.publishStatus;
+    const incoming_publishStatus = incoming.publishStatus;
+    if (!(existing_publishStatus === incoming_publishStatus)) {
+        return false;
+    }
+    const existing_segmentMembershipTable = existing.segmentMembershipTable;
+    const incoming_segmentMembershipTable = incoming.segmentMembershipTable;
+    if (!(existing_segmentMembershipTable === incoming_segmentMembershipTable)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$3 = "ed92311d86160c94e94404efc98c991a";
+function validate$6(obj, path = 'CdpSalesExcellenceStatusRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_code = obj.code;
+        const path_code = path + '.code';
+        if (typeof obj_code !== 'number' || (typeof obj_code === 'number' && Math.floor(obj_code) !== obj_code)) {
+            return new TypeError('Expected "integer" but received "' + typeof obj_code + '" (at "' + path_code + '")');
+        }
+        const obj_message = obj.message;
+        const path_message = path + '.message';
+        if (typeof obj_message !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_message + '" (at "' + path_message + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$6 = function CdpSalesExcellenceStatusRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$3,
+        private: [],
+        selections: [
+            {
+                name: 'code',
+                kind: 'Scalar'
+            },
+            {
+                name: 'message',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$3(existing, incoming) {
+    const existing_code = existing.code;
+    const incoming_code = incoming.code;
+    if (!(existing_code === incoming_code)) {
+        return false;
+    }
+    const existing_message = existing.message;
+    const incoming_message = incoming.message;
+    if (!(existing_message === incoming_message)) {
+        return false;
+    }
+    return true;
+}
+
+const TTL$2 = 10000;
+const VERSION$2 = "91167712ea078dfdfb085884a9725e71";
+function validate$5(obj, path = 'SegmentDetailsListRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_segmentData = obj.segmentData;
+        const path_segmentData = path + '.segmentData';
+        if (!ArrayIsArray(obj_segmentData)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_segmentData + '" (at "' + path_segmentData + '")');
+        }
+        for (let i = 0; i < obj_segmentData.length; i++) {
+            const obj_segmentData_item = obj_segmentData[i];
+            const path_segmentData_item = path_segmentData + '[' + i + ']';
+            const referencepath_segmentData_itemValidationError = validate$7(obj_segmentData_item, path_segmentData_item);
+            if (referencepath_segmentData_itemValidationError !== null) {
+                let message = 'Object doesn\'t match SegmentDetailsRepresentation (at "' + path_segmentData_item + '")\n';
+                message += referencepath_segmentData_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_status = obj.status;
+        const path_status = path + '.status';
+        const referencepath_statusValidationError = validate$6(obj_status, path_status);
+        if (referencepath_statusValidationError !== null) {
+            let message = 'Object doesn\'t match CdpSalesExcellenceStatusRepresentation (at "' + path_status + '")\n';
+            message += referencepath_statusValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$2 = 'SegmentDetailsListRepresentation';
+function normalize$2(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$5 = function SegmentDetailsListRepresentationSelect() {
+    const { selections: SegmentDetailsRepresentation__selections, opaque: SegmentDetailsRepresentation__opaque, } = select$7();
+    const { selections: CdpSalesExcellenceStatusRepresentation__selections, opaque: CdpSalesExcellenceStatusRepresentation__opaque, } = select$6();
+    return {
+        kind: 'Fragment',
+        version: VERSION$2,
+        private: [],
+        selections: [
+            {
+                name: 'segmentData',
+                kind: 'Object',
+                plural: true,
+                selections: SegmentDetailsRepresentation__selections
+            },
+            {
+                name: 'status',
+                kind: 'Object',
+                selections: CdpSalesExcellenceStatusRepresentation__selections
+            }
+        ]
+    };
+};
+function equals$2(existing, incoming) {
+    const existing_segmentData = existing.segmentData;
+    const incoming_segmentData = incoming.segmentData;
+    const equals_segmentData_items = equalsArray(existing_segmentData, incoming_segmentData, (existing_segmentData_item, incoming_segmentData_item) => {
+        if (!(equals$4(existing_segmentData_item, incoming_segmentData_item))) {
+            return false;
+        }
+    });
+    if (equals_segmentData_items === false) {
+        return false;
+    }
+    const existing_status = existing.status;
+    const incoming_status = incoming.status;
+    if (!(equals$3(existing_status, incoming_status))) {
+        return false;
+    }
+    return true;
+}
+const ingest$2 = function SegmentDetailsListRepresentationIngest(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 = TTL$2;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$2, "sales-excellence", VERSION$2, RepresentationType$2, equals$2);
+    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
+    });
+}
+
+function select$4(luvio, params) {
+    return select$5();
+}
+function keyBuilder$3(luvio, params) {
+    return keyPrefix + '::SegmentDetailsListRepresentation:(' + 'dataSpaceId:' + params.queryParams.dataSpaceId + ',' + 'dataSpacePrefix:' + params.queryParams.dataSpacePrefix + ',' + 'searchTerm:' + params.queryParams.searchTerm + ')';
+}
+function getResponseCacheKeys$2(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$2(storeKeyMap, luvio, response, () => keyBuilder$3(luvio, resourceParams));
+}
+function ingestSuccess$2(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$3(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$2, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$4(),
+        variables: {},
+    }, snapshotRefresh);
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
+}
+function ingestError(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$3(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    const storeMetadataParams = {
+        ttl: TTL$2,
+        namespace: keyPrefix,
+        version: VERSION$2,
+        representationName: RepresentationType$2
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
+function createResourceRequest$2(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v66.0',
+        basePath: '/connect/sales-excellence/cust-data-pfrm/segments',
+        method: 'get',
+        body: null,
+        urlParams: {},
+        queryParams: config.queryParams,
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$2 = 'getSegmentsDetails';
+const getSegmentsDetails_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('dataSpaceId', false, 1 /* QueryParameter */, 0 /* String */),
+    generateParamConfigMetadata('dataSpacePrefix', false, 1 /* QueryParameter */, 0 /* String */),
+    generateParamConfigMetadata('searchTerm', false, 1 /* QueryParameter */, 0 /* String */),
+];
+const getSegmentsDetails_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, getSegmentsDetails_ConfigPropertyMetadata);
+const createResourceParams$2 = /*#__PURE__*/ createResourceParams$b(getSegmentsDetails_ConfigPropertyMetadata);
+function keyBuilder$2(luvio, config) {
+    const resourceParams = createResourceParams$2(config);
+    return keyBuilder$3(luvio, resourceParams);
+}
+function typeCheckConfig$2(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$b(untrustedConfig, config, getSegmentsDetails_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$2(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment(luvio, config) {
+    createResourceParams$2(config);
+    return select$4();
+}
+function onFetchResponseSuccess(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$2(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError(luvio, config, resourceParams, response) {
+    const snapshot = ingestError(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$2(luvio, config, options) {
+    const resourceParams = createResourceParams$2(config);
+    const request = createResourceRequest$2(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess(luvio, config, resourceParams, response), () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$2(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext, buildNetworkSnapshot$2, undefined, false);
+}
+function buildCachedSnapshotCachePolicy(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$2(luvio, config),
+        node: adapterFragment(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getSegmentsDetailsAdapterFactory = (luvio) => function salesExcellence__getSegmentsDetails(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$2(untrustedConfig, getSegmentsDetails_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
+};
+
+function validate$4(obj, path = 'CreateActionableListRecordsInputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.actionableListDataSetColumns !== undefined) {
+            const obj_actionableListDataSetColumns = obj.actionableListDataSetColumns;
+            const path_actionableListDataSetColumns = path + '.actionableListDataSetColumns';
+            if (!ArrayIsArray(obj_actionableListDataSetColumns)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_actionableListDataSetColumns + '" (at "' + path_actionableListDataSetColumns + '")');
+            }
+            for (let i = 0; i < obj_actionableListDataSetColumns.length; i++) {
+                const obj_actionableListDataSetColumns_item = obj_actionableListDataSetColumns[i];
+                const path_actionableListDataSetColumns_item = path_actionableListDataSetColumns + '[' + i + ']';
+                if (typeof obj_actionableListDataSetColumns_item !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_actionableListDataSetColumns_item + '" (at "' + path_actionableListDataSetColumns_item + '")');
+                }
+            }
+        }
+        if (obj.actionableListDescription !== undefined) {
+            const obj_actionableListDescription = obj.actionableListDescription;
+            const path_actionableListDescription = path + '.actionableListDescription';
+            if (typeof obj_actionableListDescription !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_actionableListDescription + '" (at "' + path_actionableListDescription + '")');
+            }
+        }
+        const obj_actionableListMemberStatuses = obj.actionableListMemberStatuses;
+        const path_actionableListMemberStatuses = path + '.actionableListMemberStatuses';
+        if (!ArrayIsArray(obj_actionableListMemberStatuses)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_actionableListMemberStatuses + '" (at "' + path_actionableListMemberStatuses + '")');
+        }
+        for (let i = 0; i < obj_actionableListMemberStatuses.length; i++) {
+            const obj_actionableListMemberStatuses_item = obj_actionableListMemberStatuses[i];
+            const path_actionableListMemberStatuses_item = path_actionableListMemberStatuses + '[' + i + ']';
+            if (typeof obj_actionableListMemberStatuses_item !== 'object' || ArrayIsArray(obj_actionableListMemberStatuses_item) || obj_actionableListMemberStatuses_item === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj_actionableListMemberStatuses_item + '" (at "' + path_actionableListMemberStatuses_item + '")');
+            }
+        }
+        const obj_actionableListName = obj.actionableListName;
+        const path_actionableListName = path + '.actionableListName';
+        if (typeof obj_actionableListName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_actionableListName + '" (at "' + path_actionableListName + '")');
+        }
+        if (obj.additionalContext !== undefined) {
+            const obj_additionalContext = obj.additionalContext;
+            const path_additionalContext = path + '.additionalContext';
+            if (typeof obj_additionalContext !== 'object' || ArrayIsArray(obj_additionalContext) || obj_additionalContext === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj_additionalContext + '" (at "' + path_additionalContext + '")');
+            }
+        }
+        const obj_dataSpaceDevName = obj.dataSpaceDevName;
+        const path_dataSpaceDevName = path + '.dataSpaceDevName';
+        if (typeof obj_dataSpaceDevName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_dataSpaceDevName + '" (at "' + path_dataSpaceDevName + '")');
+        }
+        const obj_mktDataModelObjectName = obj.mktDataModelObjectName;
+        const path_mktDataModelObjectName = path + '.mktDataModelObjectName';
+        if (typeof obj_mktDataModelObjectName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_mktDataModelObjectName + '" (at "' + path_mktDataModelObjectName + '")');
+        }
+        const obj_mktDataModelObjectNameSpacePrefix = obj.mktDataModelObjectNameSpacePrefix;
+        const path_mktDataModelObjectNameSpacePrefix = path + '.mktDataModelObjectNameSpacePrefix';
+        if (typeof obj_mktDataModelObjectNameSpacePrefix !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_mktDataModelObjectNameSpacePrefix + '" (at "' + path_mktDataModelObjectNameSpacePrefix + '")');
+        }
+        const obj_segmentId = obj.segmentId;
+        const path_segmentId = path + '.segmentId';
+        if (typeof obj_segmentId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_segmentId + '" (at "' + path_segmentId + '")');
+        }
+        const obj_segmentOn = obj.segmentOn;
+        const path_segmentOn = path + '.segmentOn';
+        if (typeof obj_segmentOn !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_segmentOn + '" (at "' + path_segmentOn + '")');
+        }
+        const obj_smhTableName = obj.smhTableName;
+        const path_smhTableName = path + '.smhTableName';
+        if (typeof obj_smhTableName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_smhTableName + '" (at "' + path_smhTableName + '")');
+        }
+        const obj_synchronizationAllowed = obj.synchronizationAllowed;
+        const path_synchronizationAllowed = path + '.synchronizationAllowed';
+        if (typeof obj_synchronizationAllowed !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_synchronizationAllowed + '" (at "' + path_synchronizationAllowed + '")');
+        }
+        const obj_timestamp = obj.timestamp;
+        const path_timestamp = path + '.timestamp';
+        if (typeof obj_timestamp !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_timestamp + '" (at "' + path_timestamp + '")');
+        }
+        if (obj.type !== undefined) {
+            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 TTL$1 = 300;
+const VERSION$1 = "cee6e7242fdafbd2299d70fdb93ed60c";
+function validate$3(obj, path = 'CreateActionableListRecordsRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_actionableListId = obj.actionableListId;
+        const path_actionableListId = path + '.actionableListId';
+        let obj_actionableListId_union0 = null;
+        const obj_actionableListId_union0_error = (() => {
+            if (typeof obj_actionableListId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_actionableListId + '" (at "' + path_actionableListId + '")');
+            }
+        })();
+        if (obj_actionableListId_union0_error != null) {
+            obj_actionableListId_union0 = obj_actionableListId_union0_error.message;
+        }
+        let obj_actionableListId_union1 = null;
+        const obj_actionableListId_union1_error = (() => {
+            if (obj_actionableListId !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_actionableListId + '" (at "' + path_actionableListId + '")');
+            }
+        })();
+        if (obj_actionableListId_union1_error != null) {
+            obj_actionableListId_union1 = obj_actionableListId_union1_error.message;
+        }
+        if (obj_actionableListId_union0 && obj_actionableListId_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_actionableListId + '")';
+            message += '\n' + obj_actionableListId_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_actionableListId_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$1 = 'CreateActionableListRecordsRepresentation';
+function keyBuilder$1(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$1 + ':' + (config.actionableListId === null ? '' : config.actionableListId);
+}
+function keyBuilderFromType$1(luvio, object) {
+    const keyParams = {
+        actionableListId: object.actionableListId
+    };
+    return keyBuilder$1(luvio, keyParams);
+}
+function normalize$1(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$3 = function CreateActionableListRecordsRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$1,
+        private: [],
+        opaque: true
+    };
+};
+function equals$1(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
+const ingest$1 = function CreateActionableListRecordsRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$3(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$1(luvio, input);
+    const ttlToUse = TTL$1;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$1, "sales-excellence", VERSION$1, RepresentationType$1, equals$1);
+    return createLink(key);
+};
+function getTypeCacheKeys$1(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$1(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$1,
+        mergeable: false
+    });
+}
+
+function select$2(luvio, params) {
+    return select$3();
+}
+function getResponseCacheKeys$1(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$1(storeKeyMap, luvio, response);
+}
+function ingestSuccess$1(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$1(luvio, body);
+    luvio.storeIngest(key, ingest$1, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$2(),
+        variables: {},
+    });
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
+}
+function createResourceRequest$1(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v66.0',
+        basePath: '/connect/sales-excellence/cust-data-pfrm/create-records',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$1 = 'createActionableListRecords';
+const createActionableListRecords_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('createActionableListRecordsInputRepresentation', true, 2 /* Body */, 4 /* Unsupported */),
+];
+const createActionableListRecords_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, createActionableListRecords_ConfigPropertyMetadata);
+const createResourceParams$1 = /*#__PURE__*/ createResourceParams$b(createActionableListRecords_ConfigPropertyMetadata);
+function typeCheckConfig$1(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_createActionableListRecordsInputRepresentation = untrustedConfig.createActionableListRecordsInputRepresentation;
+    const referenceCreateActionableListRecordsInputRepresentationValidationError = validate$4(untrustedConfig_createActionableListRecordsInputRepresentation);
+    if (referenceCreateActionableListRecordsInputRepresentationValidationError === null) {
+        config.createActionableListRecordsInputRepresentation = untrustedConfig_createActionableListRecordsInputRepresentation;
+    }
+    return config;
+}
+function validateAdapterConfig$1(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$1(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$1(luvio, config, options) {
+    const resourceParams = createResourceParams$1(config);
+    const request = createResourceRequest$1(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$1(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$1(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const createActionableListRecordsAdapterFactory = (luvio) => {
+    return function createActionableListRecords(untrustedConfig) {
+        const config = validateAdapterConfig$1(untrustedConfig, createActionableListRecords_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "createActionableListRecords"');
+        }
+        return buildNetworkSnapshot$1(luvio, config);
+    };
+};
+
+function validate$2(obj, path = 'SegmentPreviewInputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_dataSpaceDevName = obj.dataSpaceDevName;
+        const path_dataSpaceDevName = path + '.dataSpaceDevName';
+        if (typeof obj_dataSpaceDevName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_dataSpaceDevName + '" (at "' + path_dataSpaceDevName + '")');
+        }
+        const obj_mktDataModelObjectId = obj.mktDataModelObjectId;
+        const path_mktDataModelObjectId = path + '.mktDataModelObjectId';
+        if (typeof obj_mktDataModelObjectId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_mktDataModelObjectId + '" (at "' + path_mktDataModelObjectId + '")');
+        }
+        const obj_mktDataModelObjectNameSpacePrefix = obj.mktDataModelObjectNameSpacePrefix;
+        const path_mktDataModelObjectNameSpacePrefix = path + '.mktDataModelObjectNameSpacePrefix';
+        if (typeof obj_mktDataModelObjectNameSpacePrefix !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_mktDataModelObjectNameSpacePrefix + '" (at "' + path_mktDataModelObjectNameSpacePrefix + '")');
+        }
+        const obj_objectName = obj.objectName;
+        const path_objectName = path + '.objectName';
+        if (typeof obj_objectName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_objectName + '" (at "' + path_objectName + '")');
+        }
+        const obj_segmentId = obj.segmentId;
+        const path_segmentId = path + '.segmentId';
+        if (typeof obj_segmentId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_segmentId + '" (at "' + path_segmentId + '")');
+        }
+        const obj_smhTableName = obj.smhTableName;
+        const path_smhTableName = path + '.smhTableName';
+        if (typeof obj_smhTableName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_smhTableName + '" (at "' + path_smhTableName + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$1(obj, path = 'SegmentPreviewRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_objectId = obj.objectId;
+        const path_objectId = path + '.objectId';
+        if (typeof obj_objectId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_objectId + '" (at "' + path_objectId + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+const TTL = 100;
+const VERSION = "3a6ae5777e9613951476cd8c8d8c6230";
+function validate(obj, path = 'SegmentPreviewListRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_mktDataModelObjectName = obj.mktDataModelObjectName;
+        const path_mktDataModelObjectName = path + '.mktDataModelObjectName';
+        if (typeof obj_mktDataModelObjectName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_mktDataModelObjectName + '" (at "' + path_mktDataModelObjectName + '")');
+        }
+        const obj_segmentData = obj.segmentData;
+        const path_segmentData = path + '.segmentData';
+        if (!ArrayIsArray(obj_segmentData)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_segmentData + '" (at "' + path_segmentData + '")');
+        }
+        for (let i = 0; i < obj_segmentData.length; i++) {
+            const obj_segmentData_item = obj_segmentData[i];
+            const path_segmentData_item = path_segmentData + '[' + i + ']';
+            const referencepath_segmentData_itemValidationError = validate$1(obj_segmentData_item, path_segmentData_item);
+            if (referencepath_segmentData_itemValidationError !== null) {
+                let message = 'Object doesn\'t match SegmentPreviewRepresentation (at "' + path_segmentData_item + '")\n';
+                message += referencepath_segmentData_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_segmentLatestTimeStamp = obj.segmentLatestTimeStamp;
+        const path_segmentLatestTimeStamp = path + '.segmentLatestTimeStamp';
+        if (typeof obj_segmentLatestTimeStamp !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_segmentLatestTimeStamp + '" (at "' + path_segmentLatestTimeStamp + '")');
+        }
+        const obj_status = obj.status;
+        const path_status = path + '.status';
+        const referencepath_statusValidationError = validate$6(obj_status, path_status);
+        if (referencepath_statusValidationError !== null) {
+            let message = 'Object doesn\'t match CdpSalesExcellenceStatusRepresentation (at "' + path_status + '")\n';
+            message += referencepath_statusValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType = 'SegmentPreviewListRepresentation';
+function keyBuilder(luvio, config) {
+    return keyPrefix + '::' + RepresentationType + ':' + config.message;
+}
+function keyBuilderFromType(luvio, object) {
+    const keyParams = {
+        message: object.status.message
+    };
+    return keyBuilder(luvio, keyParams);
+}
+function normalize(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$1 = function SegmentPreviewListRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION,
+        private: [],
+        opaque: true
+    };
+};
+function equals(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
+const ingest = function SegmentPreviewListRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType(luvio, input);
+    const ttlToUse = TTL;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize, "sales-excellence", VERSION, RepresentationType, equals);
+    return createLink(key);
+};
+function getTypeCacheKeys(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType,
+        mergeable: false
+    });
+}
+
+function select(luvio, params) {
+    return select$1();
+}
+function getResponseCacheKeys(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys(storeKeyMap, luvio, response);
+}
+function ingestSuccess(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType(luvio, body);
+    luvio.storeIngest(key, ingest, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select(),
+        variables: {},
+    });
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
+}
+function createResourceRequest(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v66.0',
+        basePath: '/connect/sales-excellence/cust-data-pfrm/segment-preview',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName = 'createObjectsDataFromSelectedSegment';
+const createObjectsDataFromSelectedSegment_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('segmentPreviewInput', true, 2 /* Body */, 4 /* Unsupported */),
+];
+const createObjectsDataFromSelectedSegment_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, createObjectsDataFromSelectedSegment_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$b(createObjectsDataFromSelectedSegment_ConfigPropertyMetadata);
+function typeCheckConfig(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_segmentPreviewInput = untrustedConfig.segmentPreviewInput;
+    const referenceSegmentPreviewInputRepresentationValidationError = validate$2(untrustedConfig_segmentPreviewInput);
+    if (referenceSegmentPreviewInputRepresentationValidationError === null) {
+        config.segmentPreviewInput = untrustedConfig_segmentPreviewInput;
+    }
+    return config;
+}
+function validateAdapterConfig(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot(luvio, config, options) {
+    const resourceParams = createResourceParams(config);
+    const request = createResourceRequest(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const createObjectsDataFromSelectedSegmentAdapterFactory = (luvio) => {
+    return function createObjectsDataFromSelectedSegment(untrustedConfig) {
+        const config = validateAdapterConfig(untrustedConfig, createObjectsDataFromSelectedSegment_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "createObjectsDataFromSelectedSegment"');
+        }
+        return buildNetworkSnapshot(luvio, config);
+    };
+};
+
+export { actionableListAssignmentAdapterFactory, actionableListMemberSearchAdapterFactory, actionableListMemberSearchByIdAdapterFactory, createActionableListRecordsAdapterFactory, createObjectsDataFromSelectedSegmentAdapterFactory, generateActionableListKpiBarResultsAdapterFactory, generateActionableListKpiMappingResultsAdapterFactory, getALMQueuesAdapterFactory, getActionableListMetadataAdapterFactory, getAssignedActionableListsAdapterFactory, getSegmentsDetailsAdapterFactory };