@salesforce/lds-adapters-service-serviceemployee 0.1.0-dev1

package/dist/es/es2018/service-serviceemployee.js

@@ -0,0 +1,3622 @@
+/**
+ * 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$7, typeCheckConfig as typeCheckConfig$7, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$3 } 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 = 'Service-employee';
+
+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$j = "7bf71d57246e2ee1d5ba5890c3c2bb88";
+function validate$l(obj, path = 'EmployeeProfileCardFieldValueOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_displayName = obj.displayName;
+        const path_displayName = path + '.displayName';
+        if (typeof obj_displayName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_displayName + '" (at "' + path_displayName + '")');
+        }
+        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_fieldType = obj.fieldType;
+        const path_fieldType = path + '.fieldType';
+        if (typeof obj_fieldType !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_fieldType + '" (at "' + path_fieldType + '")');
+        }
+        const obj_fieldValue = obj.fieldValue;
+        const path_fieldValue = path + '.fieldValue';
+        let obj_fieldValue_union0 = null;
+        const obj_fieldValue_union0_error = (() => {
+            if (typeof obj_fieldValue !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_fieldValue + '" (at "' + path_fieldValue + '")');
+            }
+        })();
+        if (obj_fieldValue_union0_error != null) {
+            obj_fieldValue_union0 = obj_fieldValue_union0_error.message;
+        }
+        let obj_fieldValue_union1 = null;
+        const obj_fieldValue_union1_error = (() => {
+            if (obj_fieldValue !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_fieldValue + '" (at "' + path_fieldValue + '")');
+            }
+        })();
+        if (obj_fieldValue_union1_error != null) {
+            obj_fieldValue_union1 = obj_fieldValue_union1_error.message;
+        }
+        if (obj_fieldValue_union0 && obj_fieldValue_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_fieldValue + '")';
+            message += '\n' + obj_fieldValue_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_fieldValue_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$q = function EmployeeProfileCardFieldValueOutputRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$j,
+        private: [],
+        selections: [
+            {
+                name: 'displayName',
+                kind: 'Scalar'
+            },
+            {
+                name: 'fieldName',
+                kind: 'Scalar'
+            },
+            {
+                name: 'fieldType',
+                kind: 'Scalar'
+            },
+            {
+                name: 'fieldValue',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$j(existing, incoming) {
+    const existing_displayName = existing.displayName;
+    const incoming_displayName = incoming.displayName;
+    if (!(existing_displayName === incoming_displayName)) {
+        return false;
+    }
+    const existing_fieldName = existing.fieldName;
+    const incoming_fieldName = incoming.fieldName;
+    if (!(existing_fieldName === incoming_fieldName)) {
+        return false;
+    }
+    const existing_fieldType = existing.fieldType;
+    const incoming_fieldType = incoming.fieldType;
+    if (!(existing_fieldType === incoming_fieldType)) {
+        return false;
+    }
+    const existing_fieldValue = existing.fieldValue;
+    const incoming_fieldValue = incoming.fieldValue;
+    if (!(existing_fieldValue === incoming_fieldValue)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$i = "63e97aada6f756dcca30661a15f26c87";
+function validate$k(obj, path = 'EmployeeProfileCardOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_entityName = obj.entityName;
+        const path_entityName = path + '.entityName';
+        if (typeof obj_entityName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_entityName + '" (at "' + path_entityName + '")');
+        }
+        const obj_fieldValueData = obj.fieldValueData;
+        const path_fieldValueData = path + '.fieldValueData';
+        if (!ArrayIsArray(obj_fieldValueData)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_fieldValueData + '" (at "' + path_fieldValueData + '")');
+        }
+        for (let i = 0; i < obj_fieldValueData.length; i++) {
+            const obj_fieldValueData_item = obj_fieldValueData[i];
+            const path_fieldValueData_item = path_fieldValueData + '[' + i + ']';
+            const referencepath_fieldValueData_itemValidationError = validate$l(obj_fieldValueData_item, path_fieldValueData_item);
+            if (referencepath_fieldValueData_itemValidationError !== null) {
+                let message = 'Object doesn\'t match EmployeeProfileCardFieldValueOutputRepresentation (at "' + path_fieldValueData_item + '")\n';
+                message += referencepath_fieldValueData_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$p = function EmployeeProfileCardOutputRepresentationSelect() {
+    const { selections: EmployeeProfileCardFieldValueOutputRepresentation__selections, opaque: EmployeeProfileCardFieldValueOutputRepresentation__opaque, } = select$q();
+    return {
+        kind: 'Fragment',
+        version: VERSION$i,
+        private: [],
+        selections: [
+            {
+                name: 'entityName',
+                kind: 'Scalar'
+            },
+            {
+                name: 'fieldValueData',
+                kind: 'Object',
+                plural: true,
+                selections: EmployeeProfileCardFieldValueOutputRepresentation__selections
+            }
+        ]
+    };
+};
+function equals$i(existing, incoming) {
+    const existing_entityName = existing.entityName;
+    const incoming_entityName = incoming.entityName;
+    if (!(existing_entityName === incoming_entityName)) {
+        return false;
+    }
+    const existing_fieldValueData = existing.fieldValueData;
+    const incoming_fieldValueData = incoming.fieldValueData;
+    const equals_fieldValueData_items = equalsArray(existing_fieldValueData, incoming_fieldValueData, (existing_fieldValueData_item, incoming_fieldValueData_item) => {
+        if (!(equals$j(existing_fieldValueData_item, incoming_fieldValueData_item))) {
+            return false;
+        }
+    });
+    if (equals_fieldValueData_items === false) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$h = "b13e8c6518c9147325425600026202eb";
+function validate$j(obj, path = 'EmployeeProfileCardStatusOutputRepresentation') {
+    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$o = function EmployeeProfileCardStatusOutputRepresentationSelect() {
+    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 VERSION$g = "61b48f8b587aa42ecef1315aa0dca4d9";
+function validate$i(obj, path = 'EmployeeProfileCardListOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_fieldValueDataList = obj.fieldValueDataList;
+        const path_fieldValueDataList = path + '.fieldValueDataList';
+        if (!ArrayIsArray(obj_fieldValueDataList)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_fieldValueDataList + '" (at "' + path_fieldValueDataList + '")');
+        }
+        for (let i = 0; i < obj_fieldValueDataList.length; i++) {
+            const obj_fieldValueDataList_item = obj_fieldValueDataList[i];
+            const path_fieldValueDataList_item = path_fieldValueDataList + '[' + i + ']';
+            const referencepath_fieldValueDataList_itemValidationError = validate$k(obj_fieldValueDataList_item, path_fieldValueDataList_item);
+            if (referencepath_fieldValueDataList_itemValidationError !== null) {
+                let message = 'Object doesn\'t match EmployeeProfileCardOutputRepresentation (at "' + path_fieldValueDataList_item + '")\n';
+                message += referencepath_fieldValueDataList_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$j(obj_status, path_status);
+        if (referencepath_statusValidationError !== null) {
+            let message = 'Object doesn\'t match EmployeeProfileCardStatusOutputRepresentation (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 = 'EmployeeProfileCardListOutputRepresentation';
+function keyBuilder$9(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$6 + ':' + config.id;
+}
+function keyBuilderFromType$3(luvio, object) {
+    const keyParams = {
+        id: object.status.message
+    };
+    return keyBuilder$9(luvio, keyParams);
+}
+function normalize$6(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$n = function EmployeeProfileCardListOutputRepresentationSelect() {
+    const { selections: EmployeeProfileCardOutputRepresentation__selections, opaque: EmployeeProfileCardOutputRepresentation__opaque, } = select$p();
+    const { selections: EmployeeProfileCardStatusOutputRepresentation__selections, opaque: EmployeeProfileCardStatusOutputRepresentation__opaque, } = select$o();
+    return {
+        kind: 'Fragment',
+        version: VERSION$g,
+        private: [],
+        selections: [
+            {
+                name: 'fieldValueDataList',
+                kind: 'Object',
+                plural: true,
+                selections: EmployeeProfileCardOutputRepresentation__selections
+            },
+            {
+                name: 'status',
+                kind: 'Object',
+                selections: EmployeeProfileCardStatusOutputRepresentation__selections
+            }
+        ]
+    };
+};
+function equals$g(existing, incoming) {
+    const existing_fieldValueDataList = existing.fieldValueDataList;
+    const incoming_fieldValueDataList = incoming.fieldValueDataList;
+    const equals_fieldValueDataList_items = equalsArray(existing_fieldValueDataList, incoming_fieldValueDataList, (existing_fieldValueDataList_item, incoming_fieldValueDataList_item) => {
+        if (!(equals$i(existing_fieldValueDataList_item, incoming_fieldValueDataList_item))) {
+            return false;
+        }
+    });
+    if (equals_fieldValueDataList_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 EmployeeProfileCardListOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$i(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$3(luvio, input);
+    const ttlToUse = path.ttl !== undefined ? path.ttl : 300;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$6, "Service-employee", VERSION$g, RepresentationType$6, equals$g);
+    return createLink(key);
+};
+function getTypeCacheKeys$6(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$6,
+        mergeable: false
+    });
+}
+
+function select$m(luvio, params) {
+    return select$n();
+}
+function getResponseCacheKeys$6(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$6(storeKeyMap, luvio, response);
+}
+function ingestSuccess$6(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$3(luvio, body);
+    luvio.storeIngest(key, ingest$6, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$m(),
+        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/employee-hub/employee-profile-card/employee-details',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$6 = 'getFieldDetailsFromCompactLayout';
+const getFieldDetailsFromCompactLayout_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('fieldDetails', true, 2 /* Body */, 4 /* Unsupported */, true),
+    generateParamConfigMetadata('objectId', true, 2 /* Body */, 0 /* String */),
+];
+const getFieldDetailsFromCompactLayout_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$6, getFieldDetailsFromCompactLayout_ConfigPropertyMetadata);
+const createResourceParams$6 = /*#__PURE__*/ createResourceParams$7(getFieldDetailsFromCompactLayout_ConfigPropertyMetadata);
+function typeCheckConfig$6(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$7(untrustedConfig, config, getFieldDetailsFromCompactLayout_ConfigPropertyMetadata);
+    const untrustedConfig_fieldDetails = untrustedConfig.fieldDetails;
+    if (ArrayIsArray$1(untrustedConfig_fieldDetails)) {
+        const untrustedConfig_fieldDetails_array = [];
+        for (let i = 0, arrayLength = untrustedConfig_fieldDetails.length; i < arrayLength; i++) {
+            const untrustedConfig_fieldDetails_item = untrustedConfig_fieldDetails[i];
+            untrustedConfig_fieldDetails_array.push(untrustedConfig_fieldDetails_item);
+        }
+        config.fieldDetails = untrustedConfig_fieldDetails_array;
+    }
+    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 getFieldDetailsFromCompactLayoutAdapterFactory = (luvio) => {
+    return function getFieldDetailsFromCompactLayout(untrustedConfig) {
+        const config = validateAdapterConfig$6(untrustedConfig, getFieldDetailsFromCompactLayout_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "getFieldDetailsFromCompactLayout"');
+        }
+        return buildNetworkSnapshot$6(luvio, config);
+    };
+};
+
+const VERSION$f = "ed936bbb66e34f6168f8a0621da9e2fd";
+function validate$h(obj, path = 'UserProfileDetailOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_fieldData = obj.fieldData;
+        const path_fieldData = path + '.fieldData';
+        if (!ArrayIsArray(obj_fieldData)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_fieldData + '" (at "' + path_fieldData + '")');
+        }
+        for (let i = 0; i < obj_fieldData.length; i++) {
+            const obj_fieldData_item = obj_fieldData[i];
+            const path_fieldData_item = path_fieldData + '[' + i + ']';
+            if (obj_fieldData_item === undefined) {
+                return new TypeError('Expected "defined" but received "' + typeof obj_fieldData_item + '" (at "' + path_fieldData_item + '")');
+            }
+        }
+        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 + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$l = function UserProfileDetailOutputRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$f,
+        private: [],
+        selections: [
+            {
+                name: 'fieldData',
+                kind: 'Object',
+                // any
+            },
+            {
+                name: 'objectName',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$f(existing, incoming) {
+    const existing_objectName = existing.objectName;
+    const incoming_objectName = incoming.objectName;
+    if (!(existing_objectName === incoming_objectName)) {
+        return false;
+    }
+    const existing_fieldData = existing.fieldData;
+    const incoming_fieldData = incoming.fieldData;
+    const equals_fieldData_items = equalsArray(existing_fieldData, incoming_fieldData, (existing_fieldData_item, incoming_fieldData_item) => {
+        if (JSONStringify(incoming_fieldData_item) !== JSONStringify(existing_fieldData_item)) {
+            return false;
+        }
+    });
+    if (equals_fieldData_items === false) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$e = "f41210ee161819f019d2183a40b7702a";
+function validate$g(obj, path = 'ServiceEmployeeStatusOutputRepresentation') {
+    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$k = function ServiceEmployeeStatusOutputRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$e,
+        private: [],
+        selections: [
+            {
+                name: 'code',
+                kind: 'Scalar'
+            },
+            {
+                name: 'message',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$e(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 VERSION$d = "9e59517bf5add11ce0b6e2b89f3c6225";
+function validate$f(obj, path = 'UserProfileOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_profileDetails = obj.profileDetails;
+        const path_profileDetails = path + '.profileDetails';
+        if (!ArrayIsArray(obj_profileDetails)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_profileDetails + '" (at "' + path_profileDetails + '")');
+        }
+        for (let i = 0; i < obj_profileDetails.length; i++) {
+            const obj_profileDetails_item = obj_profileDetails[i];
+            const path_profileDetails_item = path_profileDetails + '[' + i + ']';
+            const referencepath_profileDetails_itemValidationError = validate$h(obj_profileDetails_item, path_profileDetails_item);
+            if (referencepath_profileDetails_itemValidationError !== null) {
+                let message = 'Object doesn\'t match UserProfileDetailOutputRepresentation (at "' + path_profileDetails_item + '")\n';
+                message += referencepath_profileDetails_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$g(obj_status, path_status);
+        if (referencepath_statusValidationError !== null) {
+            let message = 'Object doesn\'t match ServiceEmployeeStatusOutputRepresentation (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$5 = 'UserProfileOutputRepresentation';
+function keyBuilder$8(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$5 + ':' + config.id;
+}
+function keyBuilderFromType$2(luvio, object) {
+    const keyParams = {
+        id: object.status.message
+    };
+    return keyBuilder$8(luvio, keyParams);
+}
+function normalize$5(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$j = function UserProfileOutputRepresentationSelect() {
+    const { selections: UserProfileDetailOutputRepresentation__selections, opaque: UserProfileDetailOutputRepresentation__opaque, } = select$l();
+    const { selections: ServiceEmployeeStatusOutputRepresentation__selections, opaque: ServiceEmployeeStatusOutputRepresentation__opaque, } = select$k();
+    return {
+        kind: 'Fragment',
+        version: VERSION$d,
+        private: [],
+        selections: [
+            {
+                name: 'profileDetails',
+                kind: 'Object',
+                plural: true,
+                selections: UserProfileDetailOutputRepresentation__selections
+            },
+            {
+                name: 'status',
+                kind: 'Object',
+                selections: ServiceEmployeeStatusOutputRepresentation__selections
+            }
+        ]
+    };
+};
+function equals$d(existing, incoming) {
+    const existing_profileDetails = existing.profileDetails;
+    const incoming_profileDetails = incoming.profileDetails;
+    const equals_profileDetails_items = equalsArray(existing_profileDetails, incoming_profileDetails, (existing_profileDetails_item, incoming_profileDetails_item) => {
+        if (!(equals$f(existing_profileDetails_item, incoming_profileDetails_item))) {
+            return false;
+        }
+    });
+    if (equals_profileDetails_items === false) {
+        return false;
+    }
+    const existing_status = existing.status;
+    const incoming_status = incoming.status;
+    if (!(equals$e(existing_status, incoming_status))) {
+        return false;
+    }
+    return true;
+}
+const ingest$5 = function UserProfileOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$f(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$2(luvio, input);
+    const ttlToUse = path.ttl !== undefined ? path.ttl : 300;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$5, "Service-employee", VERSION$d, RepresentationType$5, equals$d);
+    return createLink(key);
+};
+function getTypeCacheKeys$5(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$5,
+        mergeable: false
+    });
+}
+
+function select$i(luvio, params) {
+    return select$j();
+}
+function getResponseCacheKeys$5(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$5(storeKeyMap, luvio, response);
+}
+function ingestSuccess$5(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$2(luvio, body);
+    luvio.storeIngest(key, ingest$5, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$i(),
+        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$5(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v66.0',
+        basePath: '/connect/employee-hub/profile/user/' + config.urlParams.userId + '',
+        method: 'post',
+        body: config.body,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$5 = 'getUserProfileDetails';
+const getUserProfileDetails_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('userId', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('userProfileEntity', true, 2 /* Body */, 4 /* Unsupported */, true),
+];
+const getUserProfileDetails_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, getUserProfileDetails_ConfigPropertyMetadata);
+const createResourceParams$5 = /*#__PURE__*/ createResourceParams$7(getUserProfileDetails_ConfigPropertyMetadata);
+function typeCheckConfig$5(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$7(untrustedConfig, config, getUserProfileDetails_ConfigPropertyMetadata);
+    const untrustedConfig_userProfileEntity = untrustedConfig.userProfileEntity;
+    if (ArrayIsArray$1(untrustedConfig_userProfileEntity)) {
+        const untrustedConfig_userProfileEntity_array = [];
+        for (let i = 0, arrayLength = untrustedConfig_userProfileEntity.length; i < arrayLength; i++) {
+            const untrustedConfig_userProfileEntity_item = untrustedConfig_userProfileEntity[i];
+            untrustedConfig_userProfileEntity_array.push(untrustedConfig_userProfileEntity_item);
+        }
+        config.userProfileEntity = untrustedConfig_userProfileEntity_array;
+    }
+    return config;
+}
+function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$5(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$5(luvio, config, options) {
+    const resourceParams = createResourceParams$5(config);
+    const request = createResourceRequest$5(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$5(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$5(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const getUserProfileDetailsAdapterFactory = (luvio) => {
+    return function getUserProfileDetails(untrustedConfig) {
+        const config = validateAdapterConfig$5(untrustedConfig, getUserProfileDetails_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "getUserProfileDetails"');
+        }
+        return buildNetworkSnapshot$5(luvio, config);
+    };
+};
+
+const VERSION$c = "35737cd6e1b361c1180c9e0b05e133bb";
+function validate$e(obj, path = 'ProgramPersonaOutputRepresentation') {
+    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';
+        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);
+        }
+        const obj_persona = obj.persona;
+        const path_persona = path + '.persona';
+        let obj_persona_union0 = null;
+        const obj_persona_union0_error = (() => {
+            if (typeof obj_persona !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_persona + '" (at "' + path_persona + '")');
+            }
+        })();
+        if (obj_persona_union0_error != null) {
+            obj_persona_union0 = obj_persona_union0_error.message;
+        }
+        let obj_persona_union1 = null;
+        const obj_persona_union1_error = (() => {
+            if (obj_persona !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_persona + '" (at "' + path_persona + '")');
+            }
+        })();
+        if (obj_persona_union1_error != null) {
+            obj_persona_union1 = obj_persona_union1_error.message;
+        }
+        if (obj_persona_union0 && obj_persona_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_persona + '")';
+            message += '\n' + obj_persona_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_persona_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_userId = obj.userId;
+        const path_userId = path + '.userId';
+        let obj_userId_union0 = null;
+        const obj_userId_union0_error = (() => {
+            if (typeof obj_userId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_userId + '" (at "' + path_userId + '")');
+            }
+        })();
+        if (obj_userId_union0_error != null) {
+            obj_userId_union0 = obj_userId_union0_error.message;
+        }
+        let obj_userId_union1 = null;
+        const obj_userId_union1_error = (() => {
+            if (obj_userId !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_userId + '" (at "' + path_userId + '")');
+            }
+        })();
+        if (obj_userId_union1_error != null) {
+            obj_userId_union1 = obj_userId_union1_error.message;
+        }
+        if (obj_userId_union0 && obj_userId_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_userId + '")';
+            message += '\n' + obj_userId_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_userId_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$h = function ProgramPersonaOutputRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$c,
+        private: [],
+        selections: [
+            {
+                name: 'name',
+                kind: 'Scalar'
+            },
+            {
+                name: 'persona',
+                kind: 'Scalar'
+            },
+            {
+                name: 'userId',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$c(existing, incoming) {
+    const existing_name = existing.name;
+    const incoming_name = incoming.name;
+    if (!(existing_name === incoming_name)) {
+        return false;
+    }
+    const existing_persona = existing.persona;
+    const incoming_persona = incoming.persona;
+    if (!(existing_persona === incoming_persona)) {
+        return false;
+    }
+    const existing_userId = existing.userId;
+    const incoming_userId = incoming.userId;
+    if (!(existing_userId === incoming_userId)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$b = "8a75f68ee07acfb4ce6ad72e84360b33";
+function validate$d(obj, path = 'EnablementProgramOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_assigneeId = obj.assigneeId;
+        const path_assigneeId = path + '.assigneeId';
+        let obj_assigneeId_union0 = null;
+        const obj_assigneeId_union0_error = (() => {
+            if (typeof obj_assigneeId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_assigneeId + '" (at "' + path_assigneeId + '")');
+            }
+        })();
+        if (obj_assigneeId_union0_error != null) {
+            obj_assigneeId_union0 = obj_assigneeId_union0_error.message;
+        }
+        let obj_assigneeId_union1 = null;
+        const obj_assigneeId_union1_error = (() => {
+            if (obj_assigneeId !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_assigneeId + '" (at "' + path_assigneeId + '")');
+            }
+        })();
+        if (obj_assigneeId_union1_error != null) {
+            obj_assigneeId_union1 = obj_assigneeId_union1_error.message;
+        }
+        if (obj_assigneeId_union0 && obj_assigneeId_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_assigneeId + '")';
+            message += '\n' + obj_assigneeId_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_assigneeId_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_collaboratorPersona = obj.collaboratorPersona;
+        const path_collaboratorPersona = path + '.collaboratorPersona';
+        let obj_collaboratorPersona_union0 = null;
+        const obj_collaboratorPersona_union0_error = (() => {
+            const referencepath_collaboratorPersonaValidationError = validate$e(obj_collaboratorPersona, path_collaboratorPersona);
+            if (referencepath_collaboratorPersonaValidationError !== null) {
+                let message = 'Object doesn\'t match ProgramPersonaOutputRepresentation (at "' + path_collaboratorPersona + '")\n';
+                message += referencepath_collaboratorPersonaValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        })();
+        if (obj_collaboratorPersona_union0_error != null) {
+            obj_collaboratorPersona_union0 = obj_collaboratorPersona_union0_error.message;
+        }
+        let obj_collaboratorPersona_union1 = null;
+        const obj_collaboratorPersona_union1_error = (() => {
+            if (obj_collaboratorPersona !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_collaboratorPersona + '" (at "' + path_collaboratorPersona + '")');
+            }
+        })();
+        if (obj_collaboratorPersona_union1_error != null) {
+            obj_collaboratorPersona_union1 = obj_collaboratorPersona_union1_error.message;
+        }
+        if (obj_collaboratorPersona_union0 && obj_collaboratorPersona_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_collaboratorPersona + '")';
+            message += '\n' + obj_collaboratorPersona_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_collaboratorPersona_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_completedDate = obj.completedDate;
+        const path_completedDate = path + '.completedDate';
+        let obj_completedDate_union0 = null;
+        const obj_completedDate_union0_error = (() => {
+            if (typeof obj_completedDate !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_completedDate + '" (at "' + path_completedDate + '")');
+            }
+        })();
+        if (obj_completedDate_union0_error != null) {
+            obj_completedDate_union0 = obj_completedDate_union0_error.message;
+        }
+        let obj_completedDate_union1 = null;
+        const obj_completedDate_union1_error = (() => {
+            if (obj_completedDate !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_completedDate + '" (at "' + path_completedDate + '")');
+            }
+        })();
+        if (obj_completedDate_union1_error != null) {
+            obj_completedDate_union1 = obj_completedDate_union1_error.message;
+        }
+        if (obj_completedDate_union0 && obj_completedDate_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_completedDate + '")';
+            message += '\n' + obj_completedDate_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_completedDate_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        obj.completedPercent;
+        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_doesAllowSelfEnrollment = obj.doesAllowSelfEnrollment;
+        const path_doesAllowSelfEnrollment = path + '.doesAllowSelfEnrollment';
+        let obj_doesAllowSelfEnrollment_union0 = null;
+        const obj_doesAllowSelfEnrollment_union0_error = (() => {
+            if (typeof obj_doesAllowSelfEnrollment !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_doesAllowSelfEnrollment + '" (at "' + path_doesAllowSelfEnrollment + '")');
+            }
+        })();
+        if (obj_doesAllowSelfEnrollment_union0_error != null) {
+            obj_doesAllowSelfEnrollment_union0 = obj_doesAllowSelfEnrollment_union0_error.message;
+        }
+        let obj_doesAllowSelfEnrollment_union1 = null;
+        const obj_doesAllowSelfEnrollment_union1_error = (() => {
+            if (obj_doesAllowSelfEnrollment !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_doesAllowSelfEnrollment + '" (at "' + path_doesAllowSelfEnrollment + '")');
+            }
+        })();
+        if (obj_doesAllowSelfEnrollment_union1_error != null) {
+            obj_doesAllowSelfEnrollment_union1 = obj_doesAllowSelfEnrollment_union1_error.message;
+        }
+        if (obj_doesAllowSelfEnrollment_union0 && obj_doesAllowSelfEnrollment_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_doesAllowSelfEnrollment + '")';
+            message += '\n' + obj_doesAllowSelfEnrollment_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_doesAllowSelfEnrollment_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_dueDate = obj.dueDate;
+        const path_dueDate = path + '.dueDate';
+        let obj_dueDate_union0 = null;
+        const obj_dueDate_union0_error = (() => {
+            if (typeof obj_dueDate !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_dueDate + '" (at "' + path_dueDate + '")');
+            }
+        })();
+        if (obj_dueDate_union0_error != null) {
+            obj_dueDate_union0 = obj_dueDate_union0_error.message;
+        }
+        let obj_dueDate_union1 = null;
+        const obj_dueDate_union1_error = (() => {
+            if (obj_dueDate !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_dueDate + '" (at "' + path_dueDate + '")');
+            }
+        })();
+        if (obj_dueDate_union1_error != null) {
+            obj_dueDate_union1 = obj_dueDate_union1_error.message;
+        }
+        if (obj_dueDate_union0 && obj_dueDate_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_dueDate + '")';
+            message += '\n' + obj_dueDate_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_dueDate_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_isCompleted = obj.isCompleted;
+        const path_isCompleted = path + '.isCompleted';
+        if (typeof obj_isCompleted !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_isCompleted + '" (at "' + path_isCompleted + '")');
+        }
+        const obj_isOverdue = obj.isOverdue;
+        const path_isOverdue = path + '.isOverdue';
+        if (typeof obj_isOverdue !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_isOverdue + '" (at "' + path_isOverdue + '")');
+        }
+        const obj_items = obj.items;
+        const path_items = path + '.items';
+        if (!ArrayIsArray(obj_items)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_items + '" (at "' + path_items + '")');
+        }
+        for (let i = 0; i < obj_items.length; i++) {
+            const obj_items_item = obj_items[i];
+            const path_items_item = path_items + '[' + i + ']';
+            if (obj_items_item === undefined) {
+                return new TypeError('Expected "defined" but received "' + typeof obj_items_item + '" (at "' + path_items_item + '")');
+            }
+        }
+        const obj_learningItemId = obj.learningItemId;
+        const path_learningItemId = path + '.learningItemId';
+        let obj_learningItemId_union0 = null;
+        const obj_learningItemId_union0_error = (() => {
+            if (typeof obj_learningItemId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_learningItemId + '" (at "' + path_learningItemId + '")');
+            }
+        })();
+        if (obj_learningItemId_union0_error != null) {
+            obj_learningItemId_union0 = obj_learningItemId_union0_error.message;
+        }
+        let obj_learningItemId_union1 = null;
+        const obj_learningItemId_union1_error = (() => {
+            if (obj_learningItemId !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_learningItemId + '" (at "' + path_learningItemId + '")');
+            }
+        })();
+        if (obj_learningItemId_union1_error != null) {
+            obj_learningItemId_union1 = obj_learningItemId_union1_error.message;
+        }
+        if (obj_learningItemId_union0 && obj_learningItemId_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_learningItemId + '")';
+            message += '\n' + obj_learningItemId_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_learningItemId_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_networkId = obj.networkId;
+        const path_networkId = path + '.networkId';
+        let obj_networkId_union0 = null;
+        const obj_networkId_union0_error = (() => {
+            if (typeof obj_networkId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_networkId + '" (at "' + path_networkId + '")');
+            }
+        })();
+        if (obj_networkId_union0_error != null) {
+            obj_networkId_union0 = obj_networkId_union0_error.message;
+        }
+        let obj_networkId_union1 = null;
+        const obj_networkId_union1_error = (() => {
+            if (obj_networkId !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_networkId + '" (at "' + path_networkId + '")');
+            }
+        })();
+        if (obj_networkId_union1_error != null) {
+            obj_networkId_union1 = obj_networkId_union1_error.message;
+        }
+        if (obj_networkId_union0 && obj_networkId_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_networkId + '")';
+            message += '\n' + obj_networkId_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_networkId_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_programEnrollmentType = obj.programEnrollmentType;
+        const path_programEnrollmentType = path + '.programEnrollmentType';
+        let obj_programEnrollmentType_union0 = null;
+        const obj_programEnrollmentType_union0_error = (() => {
+            if (typeof obj_programEnrollmentType !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_programEnrollmentType + '" (at "' + path_programEnrollmentType + '")');
+            }
+        })();
+        if (obj_programEnrollmentType_union0_error != null) {
+            obj_programEnrollmentType_union0 = obj_programEnrollmentType_union0_error.message;
+        }
+        let obj_programEnrollmentType_union1 = null;
+        const obj_programEnrollmentType_union1_error = (() => {
+            if (obj_programEnrollmentType !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_programEnrollmentType + '" (at "' + path_programEnrollmentType + '")');
+            }
+        })();
+        if (obj_programEnrollmentType_union1_error != null) {
+            obj_programEnrollmentType_union1 = obj_programEnrollmentType_union1_error.message;
+        }
+        if (obj_programEnrollmentType_union0 && obj_programEnrollmentType_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_programEnrollmentType + '")';
+            message += '\n' + obj_programEnrollmentType_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_programEnrollmentType_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_programOverAllStatus = obj.programOverAllStatus;
+        const path_programOverAllStatus = path + '.programOverAllStatus';
+        let obj_programOverAllStatus_union0 = null;
+        const obj_programOverAllStatus_union0_error = (() => {
+            if (typeof obj_programOverAllStatus !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_programOverAllStatus + '" (at "' + path_programOverAllStatus + '")');
+            }
+        })();
+        if (obj_programOverAllStatus_union0_error != null) {
+            obj_programOverAllStatus_union0 = obj_programOverAllStatus_union0_error.message;
+        }
+        let obj_programOverAllStatus_union1 = null;
+        const obj_programOverAllStatus_union1_error = (() => {
+            if (obj_programOverAllStatus !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_programOverAllStatus + '" (at "' + path_programOverAllStatus + '")');
+            }
+        })();
+        if (obj_programOverAllStatus_union1_error != null) {
+            obj_programOverAllStatus_union1 = obj_programOverAllStatus_union1_error.message;
+        }
+        if (obj_programOverAllStatus_union0 && obj_programOverAllStatus_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_programOverAllStatus + '")';
+            message += '\n' + obj_programOverAllStatus_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_programOverAllStatus_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_programType = obj.programType;
+        const path_programType = path + '.programType';
+        if (typeof obj_programType !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_programType + '" (at "' + path_programType + '")');
+        }
+        const obj_status = obj.status;
+        const path_status = path + '.status';
+        if (typeof obj_status !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_status + '" (at "' + path_status + '")');
+        }
+        const obj_systemModstamp = obj.systemModstamp;
+        const path_systemModstamp = path + '.systemModstamp';
+        let obj_systemModstamp_union0 = null;
+        const obj_systemModstamp_union0_error = (() => {
+            if (typeof obj_systemModstamp !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_systemModstamp + '" (at "' + path_systemModstamp + '")');
+            }
+        })();
+        if (obj_systemModstamp_union0_error != null) {
+            obj_systemModstamp_union0 = obj_systemModstamp_union0_error.message;
+        }
+        let obj_systemModstamp_union1 = null;
+        const obj_systemModstamp_union1_error = (() => {
+            if (obj_systemModstamp !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_systemModstamp + '" (at "' + path_systemModstamp + '")');
+            }
+        })();
+        if (obj_systemModstamp_union1_error != null) {
+            obj_systemModstamp_union1 = obj_systemModstamp_union1_error.message;
+        }
+        if (obj_systemModstamp_union0 && obj_systemModstamp_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_systemModstamp + '")';
+            message += '\n' + obj_systemModstamp_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_systemModstamp_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_title = obj.title;
+        const path_title = path + '.title';
+        let obj_title_union0 = null;
+        const obj_title_union0_error = (() => {
+            if (typeof obj_title !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_title + '" (at "' + path_title + '")');
+            }
+        })();
+        if (obj_title_union0_error != null) {
+            obj_title_union0 = obj_title_union0_error.message;
+        }
+        let obj_title_union1 = null;
+        const obj_title_union1_error = (() => {
+            if (obj_title !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_title + '" (at "' + path_title + '")');
+            }
+        })();
+        if (obj_title_union1_error != null) {
+            obj_title_union1 = obj_title_union1_error.message;
+        }
+        if (obj_title_union0 && obj_title_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_title + '")';
+            message += '\n' + obj_title_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_title_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$g = function EnablementProgramOutputRepresentationSelect() {
+    const { selections: ProgramPersonaOutputRepresentation__selections, opaque: ProgramPersonaOutputRepresentation__opaque, } = select$h();
+    return {
+        kind: 'Fragment',
+        version: VERSION$b,
+        private: [],
+        selections: [
+            {
+                name: 'assigneeId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'collaboratorPersona',
+                kind: 'Object',
+                nullable: true,
+                selections: ProgramPersonaOutputRepresentation__selections
+            },
+            {
+                name: 'completedDate',
+                kind: 'Scalar'
+            },
+            {
+                name: 'completedPercent',
+                kind: 'Scalar'
+            },
+            {
+                name: 'description',
+                kind: 'Scalar'
+            },
+            {
+                name: 'doesAllowSelfEnrollment',
+                kind: 'Scalar'
+            },
+            {
+                name: 'dueDate',
+                kind: 'Scalar'
+            },
+            {
+                name: 'id',
+                kind: 'Scalar'
+            },
+            {
+                name: 'isCompleted',
+                kind: 'Scalar'
+            },
+            {
+                name: 'isOverdue',
+                kind: 'Scalar'
+            },
+            {
+                name: 'items',
+                kind: 'Object',
+                // any
+            },
+            {
+                name: 'learningItemId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'networkId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'programEnrollmentType',
+                kind: 'Scalar'
+            },
+            {
+                name: 'programOverAllStatus',
+                kind: 'Scalar'
+            },
+            {
+                name: 'programType',
+                kind: 'Scalar'
+            },
+            {
+                name: 'status',
+                kind: 'Scalar'
+            },
+            {
+                name: 'systemModstamp',
+                kind: 'Scalar'
+            },
+            {
+                name: 'title',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$b(existing, incoming) {
+    const existing_isCompleted = existing.isCompleted;
+    const incoming_isCompleted = incoming.isCompleted;
+    if (!(existing_isCompleted === incoming_isCompleted)) {
+        return false;
+    }
+    const existing_isOverdue = existing.isOverdue;
+    const incoming_isOverdue = incoming.isOverdue;
+    if (!(existing_isOverdue === incoming_isOverdue)) {
+        return false;
+    }
+    const existing_id = existing.id;
+    const incoming_id = incoming.id;
+    if (!(existing_id === incoming_id)) {
+        return false;
+    }
+    const existing_programType = existing.programType;
+    const incoming_programType = incoming.programType;
+    if (!(existing_programType === incoming_programType)) {
+        return false;
+    }
+    const existing_status = existing.status;
+    const incoming_status = incoming.status;
+    if (!(existing_status === incoming_status)) {
+        return false;
+    }
+    const existing_completedPercent = existing.completedPercent;
+    const incoming_completedPercent = incoming.completedPercent;
+    if (!(existing_completedPercent === incoming_completedPercent)) {
+        return false;
+    }
+    const existing_assigneeId = existing.assigneeId;
+    const incoming_assigneeId = incoming.assigneeId;
+    if (!(existing_assigneeId === incoming_assigneeId)) {
+        return false;
+    }
+    const existing_collaboratorPersona = existing.collaboratorPersona;
+    const incoming_collaboratorPersona = incoming.collaboratorPersona;
+    if (!(existing_collaboratorPersona === incoming_collaboratorPersona
+        || (existing_collaboratorPersona != null &&
+            incoming_collaboratorPersona != null &&
+            equals$c(existing_collaboratorPersona, incoming_collaboratorPersona)))) {
+        return false;
+    }
+    const existing_completedDate = existing.completedDate;
+    const incoming_completedDate = incoming.completedDate;
+    if (!(existing_completedDate === incoming_completedDate)) {
+        return false;
+    }
+    const existing_description = existing.description;
+    const incoming_description = incoming.description;
+    if (!(existing_description === incoming_description)) {
+        return false;
+    }
+    const existing_doesAllowSelfEnrollment = existing.doesAllowSelfEnrollment;
+    const incoming_doesAllowSelfEnrollment = incoming.doesAllowSelfEnrollment;
+    if (!(existing_doesAllowSelfEnrollment === incoming_doesAllowSelfEnrollment)) {
+        return false;
+    }
+    const existing_dueDate = existing.dueDate;
+    const incoming_dueDate = incoming.dueDate;
+    if (!(existing_dueDate === incoming_dueDate)) {
+        return false;
+    }
+    const existing_items = existing.items;
+    const incoming_items = incoming.items;
+    const equals_items_items = equalsArray(existing_items, incoming_items, (existing_items_item, incoming_items_item) => {
+        if (JSONStringify(incoming_items_item) !== JSONStringify(existing_items_item)) {
+            return false;
+        }
+    });
+    if (equals_items_items === false) {
+        return false;
+    }
+    const existing_learningItemId = existing.learningItemId;
+    const incoming_learningItemId = incoming.learningItemId;
+    if (!(existing_learningItemId === incoming_learningItemId)) {
+        return false;
+    }
+    const existing_networkId = existing.networkId;
+    const incoming_networkId = incoming.networkId;
+    if (!(existing_networkId === incoming_networkId)) {
+        return false;
+    }
+    const existing_programEnrollmentType = existing.programEnrollmentType;
+    const incoming_programEnrollmentType = incoming.programEnrollmentType;
+    if (!(existing_programEnrollmentType === incoming_programEnrollmentType)) {
+        return false;
+    }
+    const existing_programOverAllStatus = existing.programOverAllStatus;
+    const incoming_programOverAllStatus = incoming.programOverAllStatus;
+    if (!(existing_programOverAllStatus === incoming_programOverAllStatus)) {
+        return false;
+    }
+    const existing_systemModstamp = existing.systemModstamp;
+    const incoming_systemModstamp = incoming.systemModstamp;
+    if (!(existing_systemModstamp === incoming_systemModstamp)) {
+        return false;
+    }
+    const existing_title = existing.title;
+    const incoming_title = incoming.title;
+    if (!(existing_title === incoming_title)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$a = "3bb00d251238ad9e80923d31769684e6";
+function validate$c(obj, path = 'EnablementProgramListStatusOutputRepresentation') {
+    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$f = function EnablementProgramListStatusOutputRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$a,
+        private: [],
+        selections: [
+            {
+                name: 'code',
+                kind: 'Scalar'
+            },
+            {
+                name: 'message',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$a(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 = 15000;
+const VERSION$9 = "b0d173b5c36156153eab225104b4ee90";
+function validate$b(obj, path = 'EnablementProgramListOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_hasMore = obj.hasMore;
+        const path_hasMore = path + '.hasMore';
+        if (typeof obj_hasMore !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_hasMore + '" (at "' + path_hasMore + '")');
+        }
+        const obj_programSummaryList = obj.programSummaryList;
+        const path_programSummaryList = path + '.programSummaryList';
+        if (!ArrayIsArray(obj_programSummaryList)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_programSummaryList + '" (at "' + path_programSummaryList + '")');
+        }
+        for (let i = 0; i < obj_programSummaryList.length; i++) {
+            const obj_programSummaryList_item = obj_programSummaryList[i];
+            const path_programSummaryList_item = path_programSummaryList + '[' + i + ']';
+            const referencepath_programSummaryList_itemValidationError = validate$d(obj_programSummaryList_item, path_programSummaryList_item);
+            if (referencepath_programSummaryList_itemValidationError !== null) {
+                let message = 'Object doesn\'t match EnablementProgramOutputRepresentation (at "' + path_programSummaryList_item + '")\n';
+                message += referencepath_programSummaryList_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$c(obj_status, path_status);
+        if (referencepath_statusValidationError !== null) {
+            let message = 'Object doesn\'t match EnablementProgramListStatusOutputRepresentation (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$4 = 'EnablementProgramListOutputRepresentation';
+function normalize$4(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$e = function EnablementProgramListOutputRepresentationSelect() {
+    const { selections: EnablementProgramOutputRepresentation__selections, opaque: EnablementProgramOutputRepresentation__opaque, } = select$g();
+    const { selections: EnablementProgramListStatusOutputRepresentation__selections, opaque: EnablementProgramListStatusOutputRepresentation__opaque, } = select$f();
+    return {
+        kind: 'Fragment',
+        version: VERSION$9,
+        private: [],
+        selections: [
+            {
+                name: 'hasMore',
+                kind: 'Scalar'
+            },
+            {
+                name: 'programSummaryList',
+                kind: 'Object',
+                plural: true,
+                selections: EnablementProgramOutputRepresentation__selections
+            },
+            {
+                name: 'status',
+                kind: 'Object',
+                selections: EnablementProgramListStatusOutputRepresentation__selections
+            }
+        ]
+    };
+};
+function equals$9(existing, incoming) {
+    const existing_hasMore = existing.hasMore;
+    const incoming_hasMore = incoming.hasMore;
+    if (!(existing_hasMore === incoming_hasMore)) {
+        return false;
+    }
+    const existing_programSummaryList = existing.programSummaryList;
+    const incoming_programSummaryList = incoming.programSummaryList;
+    const equals_programSummaryList_items = equalsArray(existing_programSummaryList, incoming_programSummaryList, (existing_programSummaryList_item, incoming_programSummaryList_item) => {
+        if (!(equals$b(existing_programSummaryList_item, incoming_programSummaryList_item))) {
+            return false;
+        }
+    });
+    if (equals_programSummaryList_items === false) {
+        return false;
+    }
+    const existing_status = existing.status;
+    const incoming_status = incoming.status;
+    if (!(equals$a(existing_status, incoming_status))) {
+        return false;
+    }
+    return true;
+}
+const ingest$4 = function EnablementProgramListOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$b(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = path.fullPath;
+    const ttlToUse = TTL;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$4, "Service-employee", VERSION$9, RepresentationType$4, equals$9);
+    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$d(luvio, params) {
+    return select$e();
+}
+function keyBuilder$7(luvio, params) {
+    return keyPrefix + '::EnablementProgramListOutputRepresentation:(' + 'limit:' + params.queryParams.limit + ',' + 'offset:' + params.queryParams.offset + ',' + 'statusFilter:' + params.queryParams.statusFilter + ',' + 'userIds:' + params.queryParams.userIds + ')';
+}
+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$d(),
+        variables: {},
+    }, snapshotRefresh);
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    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,
+        namespace: keyPrefix,
+        version: VERSION$9,
+        representationName: RepresentationType$4
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
+function createResourceRequest$4(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v66.0',
+        basePath: '/connect/employee/enablement/programs',
+        method: 'get',
+        body: null,
+        urlParams: {},
+        queryParams: config.queryParams,
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$4 = 'getEmpEnablementPrograms';
+const getEmpEnablementPrograms_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('limit', false, 1 /* QueryParameter */, 3 /* Integer */),
+    generateParamConfigMetadata('offset', false, 1 /* QueryParameter */, 3 /* Integer */),
+    generateParamConfigMetadata('statusFilter', false, 1 /* QueryParameter */, 0 /* String */, true),
+    generateParamConfigMetadata('userIds', false, 1 /* QueryParameter */, 0 /* String */, true),
+];
+const getEmpEnablementPrograms_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, getEmpEnablementPrograms_ConfigPropertyMetadata);
+const createResourceParams$4 = /*#__PURE__*/ createResourceParams$7(getEmpEnablementPrograms_ConfigPropertyMetadata);
+function keyBuilder$6(luvio, config) {
+    const resourceParams = createResourceParams$4(config);
+    return keyBuilder$7(luvio, resourceParams);
+}
+function typeCheckConfig$4(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$7(untrustedConfig, config, getEmpEnablementPrograms_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$d();
+}
+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$3(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 getEmpEnablementProgramsAdapterFactory = (luvio) => function serviceEmployee__getEmpEnablementPrograms(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$4(untrustedConfig, getEmpEnablementPrograms_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$2, buildNetworkSnapshotCachePolicy$2);
+};
+
+const VERSION$8 = "3baf9ed6d8cb5f2e9028e80971b68fae";
+function validate$a(obj, path = 'EmployeeUserProvisioningJobOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_provisioningJobId = obj.provisioningJobId;
+        const path_provisioningJobId = path + '.provisioningJobId';
+        if (typeof obj_provisioningJobId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_provisioningJobId + '" (at "' + path_provisioningJobId + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$3 = 'EmployeeUserProvisioningJobOutputRepresentation';
+function keyBuilder$5(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$3 + ':' + config.provisioningJobId;
+}
+function keyBuilderFromType$1(luvio, object) {
+    const keyParams = {
+        provisioningJobId: object.provisioningJobId
+    };
+    return keyBuilder$5(luvio, keyParams);
+}
+function normalize$3(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$c = function EmployeeUserProvisioningJobOutputRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$8,
+        private: [],
+        selections: [
+            {
+                name: 'provisioningJobId',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$8(existing, incoming) {
+    const existing_provisioningJobId = existing.provisioningJobId;
+    const incoming_provisioningJobId = incoming.provisioningJobId;
+    if (!(existing_provisioningJobId === incoming_provisioningJobId)) {
+        return false;
+    }
+    return true;
+}
+const ingest$3 = function EmployeeUserProvisioningJobOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$a(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$1(luvio, input);
+    const ttlToUse = path.ttl !== undefined ? path.ttl : 300;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$3, "Service-employee", VERSION$8, RepresentationType$3, equals$8);
+    return createLink(key);
+};
+function getTypeCacheKeys$3(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$3,
+        mergeable: false
+    });
+}
+
+function select$b(luvio, params) {
+    return select$c();
+}
+function getResponseCacheKeys$3(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$3(storeKeyMap, luvio, response);
+}
+function ingestSuccess$3(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$1(luvio, body);
+    luvio.storeIngest(key, ingest$3, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$b(),
+        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$3(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v66.0',
+        basePath: '/connect/service-employee/employee-user-provisioning',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$3 = 'postEmployeeUserProvisioningJob';
+const postEmployeeUserProvisioningJob_ConfigPropertyMetadata = [];
+const postEmployeeUserProvisioningJob_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, postEmployeeUserProvisioningJob_ConfigPropertyMetadata);
+const createResourceParams$3 = /*#__PURE__*/ createResourceParams$7(postEmployeeUserProvisioningJob_ConfigPropertyMetadata);
+function typeCheckConfig$3(untrustedConfig) {
+    const config = {};
+    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();
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$3(luvio, config, options) {
+    const resourceParams = createResourceParams$3(config);
+    const request = createResourceRequest$3(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$3(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$3(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const postEmployeeUserProvisioningJobAdapterFactory = (luvio) => {
+    return function postEmployeeUserProvisioningJob(untrustedConfig) {
+        const config = validateAdapterConfig$3(untrustedConfig, postEmployeeUserProvisioningJob_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "postEmployeeUserProvisioningJob"');
+        }
+        return buildNetworkSnapshot$3(luvio, config);
+    };
+};
+
+const VERSION$7 = "03d457ffd4267a71784b30031263ff9e";
+function validate$9(obj, path = 'GenericResultRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_statusCode = obj.statusCode;
+        const path_statusCode = path + '.statusCode';
+        let obj_statusCode_union0 = null;
+        const obj_statusCode_union0_error = (() => {
+            if (typeof obj_statusCode !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_statusCode + '" (at "' + path_statusCode + '")');
+            }
+        })();
+        if (obj_statusCode_union0_error != null) {
+            obj_statusCode_union0 = obj_statusCode_union0_error.message;
+        }
+        let obj_statusCode_union1 = null;
+        const obj_statusCode_union1_error = (() => {
+            if (obj_statusCode !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_statusCode + '" (at "' + path_statusCode + '")');
+            }
+        })();
+        if (obj_statusCode_union1_error != null) {
+            obj_statusCode_union1 = obj_statusCode_union1_error.message;
+        }
+        if (obj_statusCode_union0 && obj_statusCode_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_statusCode + '")';
+            message += '\n' + obj_statusCode_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_statusCode_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_statusMessage = obj.statusMessage;
+        const path_statusMessage = path + '.statusMessage';
+        let obj_statusMessage_union0 = null;
+        const obj_statusMessage_union0_error = (() => {
+            if (typeof obj_statusMessage !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_statusMessage + '" (at "' + path_statusMessage + '")');
+            }
+        })();
+        if (obj_statusMessage_union0_error != null) {
+            obj_statusMessage_union0 = obj_statusMessage_union0_error.message;
+        }
+        let obj_statusMessage_union1 = null;
+        const obj_statusMessage_union1_error = (() => {
+            if (obj_statusMessage !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_statusMessage + '" (at "' + path_statusMessage + '")');
+            }
+        })();
+        if (obj_statusMessage_union1_error != null) {
+            obj_statusMessage_union1 = obj_statusMessage_union1_error.message;
+        }
+        if (obj_statusMessage_union0 && obj_statusMessage_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_statusMessage + '")';
+            message += '\n' + obj_statusMessage_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_statusMessage_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$2 = 'GenericResultRepresentation';
+function keyBuilder$4(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$2 + ':' + (config.statusCode === null ? '' : config.statusCode);
+}
+function keyBuilderFromType(luvio, object) {
+    const keyParams = {
+        statusCode: object.statusCode
+    };
+    return keyBuilder$4(luvio, keyParams);
+}
+function normalize$2(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$a = function GenericResultRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$7,
+        private: [],
+        selections: [
+            {
+                name: 'statusCode',
+                kind: 'Scalar'
+            },
+            {
+                name: 'statusMessage',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$7(existing, incoming) {
+    const existing_statusCode = existing.statusCode;
+    const incoming_statusCode = incoming.statusCode;
+    if (!(existing_statusCode === incoming_statusCode)) {
+        return false;
+    }
+    const existing_statusMessage = existing.statusMessage;
+    const incoming_statusMessage = incoming.statusMessage;
+    if (!(existing_statusMessage === incoming_statusMessage)) {
+        return false;
+    }
+    return true;
+}
+const ingest$2 = function GenericResultRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$9(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType(luvio, input);
+    const ttlToUse = path.ttl !== undefined ? path.ttl : 300;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$2, "Service-employee", VERSION$7, RepresentationType$2, equals$7);
+    return createLink(key);
+};
+function getTypeCacheKeys$2(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$2,
+        mergeable: false
+    });
+}
+
+function select$9(luvio, params) {
+    return select$a();
+}
+function getResponseCacheKeys$2(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$2(storeKeyMap, luvio, response);
+}
+function ingestSuccess$2(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType(luvio, body);
+    luvio.storeIngest(key, ingest$2, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$9(),
+        variables: {},
+    });
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
+}
+function createResourceRequest$2(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v66.0',
+        basePath: '/connect/service-employee/user-settings',
+        method: 'patch',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$2 = 'updateUserSettings';
+const updateUserSettings_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('autoCreateFlag', false, 2 /* Body */, 1 /* Boolean */),
+    generateParamConfigMetadata('autoDeactivateFlag', false, 2 /* Body */, 1 /* Boolean */),
+    generateParamConfigMetadata('domain', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('emailEncoding', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('permissionId', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('profileId', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('syncEmployee2Users', false, 2 /* Body */, 1 /* Boolean */),
+    generateParamConfigMetadata('employeeStatus', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('sourceOfInvocation', false, 2 /* Body */, 0 /* String */),
+];
+const updateUserSettings_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, updateUserSettings_ConfigPropertyMetadata);
+const createResourceParams$2 = /*#__PURE__*/ createResourceParams$7(updateUserSettings_ConfigPropertyMetadata);
+function typeCheckConfig$2(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$7(untrustedConfig, config, updateUserSettings_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 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(() => {
+            const snapshot = ingestSuccess$2(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$2(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const updateUserSettingsAdapterFactory = (luvio) => {
+    return function updateUserSettings(untrustedConfig) {
+        const config = validateAdapterConfig$2(untrustedConfig, updateUserSettings_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "updateUserSettings"');
+        }
+        return buildNetworkSnapshot$2(luvio, config);
+    };
+};
+
+const VERSION$6 = "1c67fc20b7f29ba31201342adfd39241";
+function validate$8(obj, path = 'PermissionDetailsRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.description !== undefined) {
+            const obj_description = obj.description;
+            const path_description = path + '.description';
+            if (typeof obj_description !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_description + '" (at "' + path_description + '")');
+            }
+        }
+        if (obj.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 + '")');
+            }
+        }
+        if (obj.permissionId !== undefined) {
+            const obj_permissionId = obj.permissionId;
+            const path_permissionId = path + '.permissionId';
+            if (typeof obj_permissionId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_permissionId + '" (at "' + path_permissionId + '")');
+            }
+        }
+        if (obj.permissionName !== undefined) {
+            const obj_permissionName = obj.permissionName;
+            const path_permissionName = path + '.permissionName';
+            if (typeof obj_permissionName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_permissionName + '" (at "' + path_permissionName + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$8 = function PermissionDetailsRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$6,
+        private: [],
+        selections: [
+            {
+                name: 'description',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'label',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'permissionId',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'permissionName',
+                kind: 'Scalar',
+                required: false
+            }
+        ]
+    };
+};
+function equals$6(existing, incoming) {
+    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_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;
+        }
+    }
+    const existing_permissionId = existing.permissionId;
+    const incoming_permissionId = incoming.permissionId;
+    // if at least one of these optionals is defined
+    if (existing_permissionId !== undefined || incoming_permissionId !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_permissionId === undefined || incoming_permissionId === undefined) {
+            return false;
+        }
+        if (!(existing_permissionId === incoming_permissionId)) {
+            return false;
+        }
+    }
+    const existing_permissionName = existing.permissionName;
+    const incoming_permissionName = incoming.permissionName;
+    // if at least one of these optionals is defined
+    if (existing_permissionName !== undefined || incoming_permissionName !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_permissionName === undefined || incoming_permissionName === undefined) {
+            return false;
+        }
+        if (!(existing_permissionName === incoming_permissionName)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const VERSION$5 = "2ec510f8b59acca487c03411f66bdee0";
+function validate$7(obj, path = 'ProfileDetailsRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.licenseId !== undefined) {
+            const obj_licenseId = obj.licenseId;
+            const path_licenseId = path + '.licenseId';
+            let obj_licenseId_union0 = null;
+            const obj_licenseId_union0_error = (() => {
+                if (typeof obj_licenseId !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_licenseId + '" (at "' + path_licenseId + '")');
+                }
+            })();
+            if (obj_licenseId_union0_error != null) {
+                obj_licenseId_union0 = obj_licenseId_union0_error.message;
+            }
+            let obj_licenseId_union1 = null;
+            const obj_licenseId_union1_error = (() => {
+                if (obj_licenseId !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_licenseId + '" (at "' + path_licenseId + '")');
+                }
+            })();
+            if (obj_licenseId_union1_error != null) {
+                obj_licenseId_union1 = obj_licenseId_union1_error.message;
+            }
+            if (obj_licenseId_union0 && obj_licenseId_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_licenseId + '")';
+                message += '\n' + obj_licenseId_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_licenseId_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.licenseName !== undefined) {
+            const obj_licenseName = obj.licenseName;
+            const path_licenseName = path + '.licenseName';
+            let obj_licenseName_union0 = null;
+            const obj_licenseName_union0_error = (() => {
+                if (typeof obj_licenseName !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_licenseName + '" (at "' + path_licenseName + '")');
+                }
+            })();
+            if (obj_licenseName_union0_error != null) {
+                obj_licenseName_union0 = obj_licenseName_union0_error.message;
+            }
+            let obj_licenseName_union1 = null;
+            const obj_licenseName_union1_error = (() => {
+                if (obj_licenseName !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_licenseName + '" (at "' + path_licenseName + '")');
+                }
+            })();
+            if (obj_licenseName_union1_error != null) {
+                obj_licenseName_union1 = obj_licenseName_union1_error.message;
+            }
+            if (obj_licenseName_union0 && obj_licenseName_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_licenseName + '")';
+                message += '\n' + obj_licenseName_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_licenseName_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.profileId !== undefined) {
+            const obj_profileId = obj.profileId;
+            const path_profileId = path + '.profileId';
+            let obj_profileId_union0 = null;
+            const obj_profileId_union0_error = (() => {
+                if (typeof obj_profileId !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_profileId + '" (at "' + path_profileId + '")');
+                }
+            })();
+            if (obj_profileId_union0_error != null) {
+                obj_profileId_union0 = obj_profileId_union0_error.message;
+            }
+            let obj_profileId_union1 = null;
+            const obj_profileId_union1_error = (() => {
+                if (obj_profileId !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_profileId + '" (at "' + path_profileId + '")');
+                }
+            })();
+            if (obj_profileId_union1_error != null) {
+                obj_profileId_union1 = obj_profileId_union1_error.message;
+            }
+            if (obj_profileId_union0 && obj_profileId_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_profileId + '")';
+                message += '\n' + obj_profileId_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_profileId_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.profileName !== undefined) {
+            const obj_profileName = obj.profileName;
+            const path_profileName = path + '.profileName';
+            let obj_profileName_union0 = null;
+            const obj_profileName_union0_error = (() => {
+                if (typeof obj_profileName !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_profileName + '" (at "' + path_profileName + '")');
+                }
+            })();
+            if (obj_profileName_union0_error != null) {
+                obj_profileName_union0 = obj_profileName_union0_error.message;
+            }
+            let obj_profileName_union1 = null;
+            const obj_profileName_union1_error = (() => {
+                if (obj_profileName !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_profileName + '" (at "' + path_profileName + '")');
+                }
+            })();
+            if (obj_profileName_union1_error != null) {
+                obj_profileName_union1 = obj_profileName_union1_error.message;
+            }
+            if (obj_profileName_union0 && obj_profileName_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_profileName + '")';
+                message += '\n' + obj_profileName_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_profileName_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$7 = function ProfileDetailsRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$5,
+        private: [],
+        selections: [
+            {
+                name: 'licenseId',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'licenseName',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'profileId',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'profileName',
+                kind: 'Scalar',
+                required: false
+            }
+        ]
+    };
+};
+function equals$5(existing, incoming) {
+    const existing_licenseId = existing.licenseId;
+    const incoming_licenseId = incoming.licenseId;
+    // if at least one of these optionals is defined
+    if (existing_licenseId !== undefined || incoming_licenseId !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_licenseId === undefined || incoming_licenseId === undefined) {
+            return false;
+        }
+        if (!(existing_licenseId === incoming_licenseId)) {
+            return false;
+        }
+    }
+    const existing_licenseName = existing.licenseName;
+    const incoming_licenseName = incoming.licenseName;
+    // if at least one of these optionals is defined
+    if (existing_licenseName !== undefined || incoming_licenseName !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_licenseName === undefined || incoming_licenseName === undefined) {
+            return false;
+        }
+        if (!(existing_licenseName === incoming_licenseName)) {
+            return false;
+        }
+    }
+    const existing_profileId = existing.profileId;
+    const incoming_profileId = incoming.profileId;
+    // if at least one of these optionals is defined
+    if (existing_profileId !== undefined || incoming_profileId !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_profileId === undefined || incoming_profileId === undefined) {
+            return false;
+        }
+        if (!(existing_profileId === incoming_profileId)) {
+            return false;
+        }
+    }
+    const existing_profileName = existing.profileName;
+    const incoming_profileName = incoming.profileName;
+    // if at least one of these optionals is defined
+    if (existing_profileName !== undefined || incoming_profileName !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_profileName === undefined || incoming_profileName === undefined) {
+            return false;
+        }
+        if (!(existing_profileName === incoming_profileName)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const VERSION$4 = "1374eb7105fe217c4f04a7b83af4438f";
+function validate$6(obj, path = 'UserSettingsOutputRepresentations') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.autoCreateFlag !== undefined) {
+            const obj_autoCreateFlag = obj.autoCreateFlag;
+            const path_autoCreateFlag = path + '.autoCreateFlag';
+            if (typeof obj_autoCreateFlag !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_autoCreateFlag + '" (at "' + path_autoCreateFlag + '")');
+            }
+        }
+        if (obj.autoDeactivateFlag !== undefined) {
+            const obj_autoDeactivateFlag = obj.autoDeactivateFlag;
+            const path_autoDeactivateFlag = path + '.autoDeactivateFlag';
+            if (typeof obj_autoDeactivateFlag !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_autoDeactivateFlag + '" (at "' + path_autoDeactivateFlag + '")');
+            }
+        }
+        if (obj.domain !== undefined) {
+            const obj_domain = obj.domain;
+            const path_domain = path + '.domain';
+            let obj_domain_union0 = null;
+            const obj_domain_union0_error = (() => {
+                if (typeof obj_domain !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_domain + '" (at "' + path_domain + '")');
+                }
+            })();
+            if (obj_domain_union0_error != null) {
+                obj_domain_union0 = obj_domain_union0_error.message;
+            }
+            let obj_domain_union1 = null;
+            const obj_domain_union1_error = (() => {
+                if (obj_domain !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_domain + '" (at "' + path_domain + '")');
+                }
+            })();
+            if (obj_domain_union1_error != null) {
+                obj_domain_union1 = obj_domain_union1_error.message;
+            }
+            if (obj_domain_union0 && obj_domain_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_domain + '")';
+                message += '\n' + obj_domain_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_domain_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.emailEncoding !== undefined) {
+            const obj_emailEncoding = obj.emailEncoding;
+            const path_emailEncoding = path + '.emailEncoding';
+            if (typeof obj_emailEncoding !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_emailEncoding + '" (at "' + path_emailEncoding + '")');
+            }
+        }
+        if (obj.employeeStatus !== undefined) {
+            const obj_employeeStatus = obj.employeeStatus;
+            const path_employeeStatus = path + '.employeeStatus';
+            let obj_employeeStatus_union0 = null;
+            const obj_employeeStatus_union0_error = (() => {
+                if (typeof obj_employeeStatus !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_employeeStatus + '" (at "' + path_employeeStatus + '")');
+                }
+            })();
+            if (obj_employeeStatus_union0_error != null) {
+                obj_employeeStatus_union0 = obj_employeeStatus_union0_error.message;
+            }
+            let obj_employeeStatus_union1 = null;
+            const obj_employeeStatus_union1_error = (() => {
+                if (obj_employeeStatus !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_employeeStatus + '" (at "' + path_employeeStatus + '")');
+                }
+            })();
+            if (obj_employeeStatus_union1_error != null) {
+                obj_employeeStatus_union1 = obj_employeeStatus_union1_error.message;
+            }
+            if (obj_employeeStatus_union0 && obj_employeeStatus_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_employeeStatus + '")';
+                message += '\n' + obj_employeeStatus_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_employeeStatus_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.permissionSetDetailsRepresentation !== undefined) {
+            const obj_permissionSetDetailsRepresentation = obj.permissionSetDetailsRepresentation;
+            const path_permissionSetDetailsRepresentation = path + '.permissionSetDetailsRepresentation';
+            let obj_permissionSetDetailsRepresentation_union0 = null;
+            const obj_permissionSetDetailsRepresentation_union0_error = (() => {
+                const referencepath_permissionSetDetailsRepresentationValidationError = validate$8(obj_permissionSetDetailsRepresentation, path_permissionSetDetailsRepresentation);
+                if (referencepath_permissionSetDetailsRepresentationValidationError !== null) {
+                    let message = 'Object doesn\'t match PermissionDetailsRepresentation (at "' + path_permissionSetDetailsRepresentation + '")\n';
+                    message += referencepath_permissionSetDetailsRepresentationValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            })();
+            if (obj_permissionSetDetailsRepresentation_union0_error != null) {
+                obj_permissionSetDetailsRepresentation_union0 = obj_permissionSetDetailsRepresentation_union0_error.message;
+            }
+            let obj_permissionSetDetailsRepresentation_union1 = null;
+            const obj_permissionSetDetailsRepresentation_union1_error = (() => {
+                if (obj_permissionSetDetailsRepresentation !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_permissionSetDetailsRepresentation + '" (at "' + path_permissionSetDetailsRepresentation + '")');
+                }
+            })();
+            if (obj_permissionSetDetailsRepresentation_union1_error != null) {
+                obj_permissionSetDetailsRepresentation_union1 = obj_permissionSetDetailsRepresentation_union1_error.message;
+            }
+            if (obj_permissionSetDetailsRepresentation_union0 && obj_permissionSetDetailsRepresentation_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_permissionSetDetailsRepresentation + '")';
+                message += '\n' + obj_permissionSetDetailsRepresentation_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_permissionSetDetailsRepresentation_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.profileDetailsRepresentation !== undefined) {
+            const obj_profileDetailsRepresentation = obj.profileDetailsRepresentation;
+            const path_profileDetailsRepresentation = path + '.profileDetailsRepresentation';
+            let obj_profileDetailsRepresentation_union0 = null;
+            const obj_profileDetailsRepresentation_union0_error = (() => {
+                const referencepath_profileDetailsRepresentationValidationError = validate$7(obj_profileDetailsRepresentation, path_profileDetailsRepresentation);
+                if (referencepath_profileDetailsRepresentationValidationError !== null) {
+                    let message = 'Object doesn\'t match ProfileDetailsRepresentation (at "' + path_profileDetailsRepresentation + '")\n';
+                    message += referencepath_profileDetailsRepresentationValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            })();
+            if (obj_profileDetailsRepresentation_union0_error != null) {
+                obj_profileDetailsRepresentation_union0 = obj_profileDetailsRepresentation_union0_error.message;
+            }
+            let obj_profileDetailsRepresentation_union1 = null;
+            const obj_profileDetailsRepresentation_union1_error = (() => {
+                if (obj_profileDetailsRepresentation !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_profileDetailsRepresentation + '" (at "' + path_profileDetailsRepresentation + '")');
+                }
+            })();
+            if (obj_profileDetailsRepresentation_union1_error != null) {
+                obj_profileDetailsRepresentation_union1 = obj_profileDetailsRepresentation_union1_error.message;
+            }
+            if (obj_profileDetailsRepresentation_union0 && obj_profileDetailsRepresentation_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_profileDetailsRepresentation + '")';
+                message += '\n' + obj_profileDetailsRepresentation_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_profileDetailsRepresentation_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_syncEmployee2Users = obj.syncEmployee2Users;
+        const path_syncEmployee2Users = path + '.syncEmployee2Users';
+        if (typeof obj_syncEmployee2Users !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_syncEmployee2Users + '" (at "' + path_syncEmployee2Users + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$1 = 'UserSettingsOutputRepresentations';
+function normalize$1(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$6 = function UserSettingsOutputRepresentationsSelect() {
+    const { selections: PermissionDetailsRepresentation__selections, opaque: PermissionDetailsRepresentation__opaque, } = select$8();
+    const { selections: ProfileDetailsRepresentation__selections, opaque: ProfileDetailsRepresentation__opaque, } = select$7();
+    return {
+        kind: 'Fragment',
+        version: VERSION$4,
+        private: [],
+        selections: [
+            {
+                name: 'autoCreateFlag',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'autoDeactivateFlag',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'domain',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'emailEncoding',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'employeeStatus',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'permissionSetDetailsRepresentation',
+                kind: 'Object',
+                nullable: true,
+                selections: PermissionDetailsRepresentation__selections,
+                required: false
+            },
+            {
+                name: 'profileDetailsRepresentation',
+                kind: 'Object',
+                nullable: true,
+                selections: ProfileDetailsRepresentation__selections,
+                required: false
+            },
+            {
+                name: 'syncEmployee2Users',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$4(existing, incoming) {
+    const existing_autoCreateFlag = existing.autoCreateFlag;
+    const incoming_autoCreateFlag = incoming.autoCreateFlag;
+    // if at least one of these optionals is defined
+    if (existing_autoCreateFlag !== undefined || incoming_autoCreateFlag !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_autoCreateFlag === undefined || incoming_autoCreateFlag === undefined) {
+            return false;
+        }
+        if (!(existing_autoCreateFlag === incoming_autoCreateFlag)) {
+            return false;
+        }
+    }
+    const existing_autoDeactivateFlag = existing.autoDeactivateFlag;
+    const incoming_autoDeactivateFlag = incoming.autoDeactivateFlag;
+    // if at least one of these optionals is defined
+    if (existing_autoDeactivateFlag !== undefined || incoming_autoDeactivateFlag !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_autoDeactivateFlag === undefined || incoming_autoDeactivateFlag === undefined) {
+            return false;
+        }
+        if (!(existing_autoDeactivateFlag === incoming_autoDeactivateFlag)) {
+            return false;
+        }
+    }
+    const existing_syncEmployee2Users = existing.syncEmployee2Users;
+    const incoming_syncEmployee2Users = incoming.syncEmployee2Users;
+    if (!(existing_syncEmployee2Users === incoming_syncEmployee2Users)) {
+        return false;
+    }
+    const existing_emailEncoding = existing.emailEncoding;
+    const incoming_emailEncoding = incoming.emailEncoding;
+    // if at least one of these optionals is defined
+    if (existing_emailEncoding !== undefined || incoming_emailEncoding !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_emailEncoding === undefined || incoming_emailEncoding === undefined) {
+            return false;
+        }
+        if (!(existing_emailEncoding === incoming_emailEncoding)) {
+            return false;
+        }
+    }
+    const existing_domain = existing.domain;
+    const incoming_domain = incoming.domain;
+    // if at least one of these optionals is defined
+    if (existing_domain !== undefined || incoming_domain !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_domain === undefined || incoming_domain === undefined) {
+            return false;
+        }
+        if (!(existing_domain === incoming_domain)) {
+            return false;
+        }
+    }
+    const existing_employeeStatus = existing.employeeStatus;
+    const incoming_employeeStatus = incoming.employeeStatus;
+    // if at least one of these optionals is defined
+    if (existing_employeeStatus !== undefined || incoming_employeeStatus !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_employeeStatus === undefined || incoming_employeeStatus === undefined) {
+            return false;
+        }
+        if (!(existing_employeeStatus === incoming_employeeStatus)) {
+            return false;
+        }
+    }
+    const existing_permissionSetDetailsRepresentation = existing.permissionSetDetailsRepresentation;
+    const incoming_permissionSetDetailsRepresentation = incoming.permissionSetDetailsRepresentation;
+    // if at least one of these optionals is defined
+    if (existing_permissionSetDetailsRepresentation !== undefined || incoming_permissionSetDetailsRepresentation !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_permissionSetDetailsRepresentation === undefined || incoming_permissionSetDetailsRepresentation === undefined) {
+            return false;
+        }
+        if (!(existing_permissionSetDetailsRepresentation === incoming_permissionSetDetailsRepresentation
+            || (existing_permissionSetDetailsRepresentation != null &&
+                incoming_permissionSetDetailsRepresentation != null &&
+                equals$6(existing_permissionSetDetailsRepresentation, incoming_permissionSetDetailsRepresentation)))) {
+            return false;
+        }
+    }
+    const existing_profileDetailsRepresentation = existing.profileDetailsRepresentation;
+    const incoming_profileDetailsRepresentation = incoming.profileDetailsRepresentation;
+    // if at least one of these optionals is defined
+    if (existing_profileDetailsRepresentation !== undefined || incoming_profileDetailsRepresentation !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_profileDetailsRepresentation === undefined || incoming_profileDetailsRepresentation === undefined) {
+            return false;
+        }
+        if (!(existing_profileDetailsRepresentation === incoming_profileDetailsRepresentation
+            || (existing_profileDetailsRepresentation != null &&
+                incoming_profileDetailsRepresentation != null &&
+                equals$5(existing_profileDetailsRepresentation, incoming_profileDetailsRepresentation)))) {
+            return false;
+        }
+    }
+    return true;
+}
+const ingest$1 = function UserSettingsOutputRepresentationsIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$6(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = path.fullPath;
+    const ttlToUse = path.ttl !== undefined ? path.ttl : 300;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$1, "Service-employee", VERSION$4, RepresentationType$1, equals$4);
+    return createLink(key);
+};
+function getTypeCacheKeys$1(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = fullPathFactory();
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$1,
+        mergeable: false
+    });
+}
+
+function select$5(luvio, params) {
+    return select$6();
+}
+function keyBuilder$3(luvio, params) {
+    return keyPrefix + '::UserSettingsOutputRepresentations:(' + 'sourceOfInvocation:' + params.queryParams.sourceOfInvocation + ')';
+}
+function getResponseCacheKeys$1(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$1(storeKeyMap, luvio, response, () => keyBuilder$3(luvio, resourceParams));
+}
+function ingestSuccess$1(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$3(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$1, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$5(),
+        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$3(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    luvio.storeIngestError(key, errorSnapshot);
+    return errorSnapshot;
+}
+function createResourceRequest$1(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v66.0',
+        basePath: '/connect/service-employee/user-settings/details',
+        method: 'get',
+        body: null,
+        urlParams: {},
+        queryParams: config.queryParams,
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$1 = 'getUserSettings';
+const getUserSettings_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('sourceOfInvocation', false, 1 /* QueryParameter */, 0 /* String */),
+];
+const getUserSettings_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, getUserSettings_ConfigPropertyMetadata);
+const createResourceParams$1 = /*#__PURE__*/ createResourceParams$7(getUserSettings_ConfigPropertyMetadata);
+function keyBuilder$2(luvio, config) {
+    const resourceParams = createResourceParams$1(config);
+    return keyBuilder$3(luvio, resourceParams);
+}
+function typeCheckConfig$1(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$7(untrustedConfig, config, getUserSettings_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig$1(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$1(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment$1(luvio, config) {
+    createResourceParams$1(config);
+    return select$5();
+}
+function onFetchResponseSuccess$1(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$1(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError$1(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$1(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$1(luvio, config, options) {
+    const resourceParams = createResourceParams$1(config);
+    const request = createResourceRequest$1(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$1(luvio, config, resourceParams, response), () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$1(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$1(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext, buildNetworkSnapshot$1, undefined, false);
+}
+function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$2(luvio, config),
+        node: adapterFragment$1(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getUserSettingsAdapterFactory = (luvio) => function serviceEmployee__getUserSettings(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$1(untrustedConfig, getUserSettings_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$1, buildNetworkSnapshotCachePolicy$1);
+};
+
+function validate$5(obj, path = 'PermissionSetsInputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_licenses = obj.licenses;
+        const path_licenses = path + '.licenses';
+        if (!ArrayIsArray(obj_licenses)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_licenses + '" (at "' + path_licenses + '")');
+        }
+        for (let i = 0; i < obj_licenses.length; i++) {
+            const obj_licenses_item = obj_licenses[i];
+            const path_licenses_item = path_licenses + '[' + i + ']';
+            if (typeof obj_licenses_item !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_licenses_item + '" (at "' + path_licenses_item + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$4(obj, path = 'LicenseDetailsInputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_licenses = obj.licenses;
+        const path_licenses = path + '.licenses';
+        if (!ArrayIsArray(obj_licenses)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_licenses + '" (at "' + path_licenses + '")');
+        }
+        for (let i = 0; i < obj_licenses.length; i++) {
+            const obj_licenses_item = obj_licenses[i];
+            const path_licenses_item = path_licenses + '[' + i + ']';
+            if (typeof obj_licenses_item !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_licenses_item + '" (at "' + path_licenses_item + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+const VERSION$3 = "4d8f51e66bfbe4fc76183de7516d01bf";
+function validate$3(obj, path = 'EmailEncodingDetailsRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_label = obj.label;
+        const path_label = path + '.label';
+        if (typeof obj_label !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_label + '" (at "' + path_label + '")');
+        }
+        const obj_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$4 = function EmailEncodingDetailsRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$3,
+        private: [],
+        selections: [
+            {
+                name: 'label',
+                kind: 'Scalar'
+            },
+            {
+                name: 'value',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$3(existing, incoming) {
+    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;
+    }
+    return true;
+}
+
+const VERSION$2 = "6c76c268c6383b710a0feadee62e3f30";
+function validate$2(obj, path = 'PermissionSetGroupsDetailsRepresentation') {
+    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_label = obj.label;
+        const path_label = path + '.label';
+        if (typeof obj_label !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_label + '" (at "' + path_label + '")');
+        }
+        const obj_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$3 = function PermissionSetGroupsDetailsRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$2,
+        private: [],
+        selections: [
+            {
+                name: 'id',
+                kind: 'Scalar'
+            },
+            {
+                name: 'label',
+                kind: 'Scalar'
+            },
+            {
+                name: 'name',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$2(existing, incoming) {
+    const existing_id = existing.id;
+    const incoming_id = incoming.id;
+    if (!(existing_id === incoming_id)) {
+        return false;
+    }
+    const existing_label = existing.label;
+    const incoming_label = incoming.label;
+    if (!(existing_label === incoming_label)) {
+        return false;
+    }
+    const existing_name = existing.name;
+    const incoming_name = incoming.name;
+    if (!(existing_name === incoming_name)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$1 = "b5f28188b1ec90d88bbd9670b482323d";
+function validate$1(obj, path = 'PermissionSetsDetailsRepresentation') {
+    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_label = obj.label;
+        const path_label = path + '.label';
+        if (typeof obj_label !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_label + '" (at "' + path_label + '")');
+        }
+        const obj_licenseId = obj.licenseId;
+        const path_licenseId = path + '.licenseId';
+        if (typeof obj_licenseId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_licenseId + '" (at "' + path_licenseId + '")');
+        }
+        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_profileId = obj.profileId;
+        const path_profileId = path + '.profileId';
+        if (typeof obj_profileId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_profileId + '" (at "' + path_profileId + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$2 = function PermissionSetsDetailsRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$1,
+        private: [],
+        selections: [
+            {
+                name: 'id',
+                kind: 'Scalar'
+            },
+            {
+                name: 'label',
+                kind: 'Scalar'
+            },
+            {
+                name: 'licenseId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'name',
+                kind: 'Scalar'
+            },
+            {
+                name: 'profileId',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$1(existing, incoming) {
+    const existing_id = existing.id;
+    const incoming_id = incoming.id;
+    if (!(existing_id === incoming_id)) {
+        return false;
+    }
+    const existing_label = existing.label;
+    const incoming_label = incoming.label;
+    if (!(existing_label === incoming_label)) {
+        return false;
+    }
+    const existing_licenseId = existing.licenseId;
+    const incoming_licenseId = incoming.licenseId;
+    if (!(existing_licenseId === incoming_licenseId)) {
+        return false;
+    }
+    const existing_name = existing.name;
+    const incoming_name = incoming.name;
+    if (!(existing_name === incoming_name)) {
+        return false;
+    }
+    const existing_profileId = existing.profileId;
+    const incoming_profileId = incoming.profileId;
+    if (!(existing_profileId === incoming_profileId)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION = "9f5cd2dc8964436292fb9585399fc8d7";
+function validate(obj, path = 'AvailableUserOptionsOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_emailEncodings = obj.emailEncodings;
+        const path_emailEncodings = path + '.emailEncodings';
+        if (!ArrayIsArray(obj_emailEncodings)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_emailEncodings + '" (at "' + path_emailEncodings + '")');
+        }
+        for (let i = 0; i < obj_emailEncodings.length; i++) {
+            const obj_emailEncodings_item = obj_emailEncodings[i];
+            const path_emailEncodings_item = path_emailEncodings + '[' + i + ']';
+            const referencepath_emailEncodings_itemValidationError = validate$3(obj_emailEncodings_item, path_emailEncodings_item);
+            if (referencepath_emailEncodings_itemValidationError !== null) {
+                let message = 'Object doesn\'t match EmailEncodingDetailsRepresentation (at "' + path_emailEncodings_item + '")\n';
+                message += referencepath_emailEncodings_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_employeeStatuses = obj.employeeStatuses;
+        const path_employeeStatuses = path + '.employeeStatuses';
+        if (!ArrayIsArray(obj_employeeStatuses)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_employeeStatuses + '" (at "' + path_employeeStatuses + '")');
+        }
+        for (let i = 0; i < obj_employeeStatuses.length; i++) {
+            const obj_employeeStatuses_item = obj_employeeStatuses[i];
+            const path_employeeStatuses_item = path_employeeStatuses + '[' + i + ']';
+            if (typeof obj_employeeStatuses_item !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_employeeStatuses_item + '" (at "' + path_employeeStatuses_item + '")');
+            }
+        }
+        if (obj.permissionSetGroups !== undefined) {
+            const obj_permissionSetGroups = obj.permissionSetGroups;
+            const path_permissionSetGroups = path + '.permissionSetGroups';
+            if (!ArrayIsArray(obj_permissionSetGroups)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_permissionSetGroups + '" (at "' + path_permissionSetGroups + '")');
+            }
+            for (let i = 0; i < obj_permissionSetGroups.length; i++) {
+                const obj_permissionSetGroups_item = obj_permissionSetGroups[i];
+                const path_permissionSetGroups_item = path_permissionSetGroups + '[' + i + ']';
+                const referencepath_permissionSetGroups_itemValidationError = validate$2(obj_permissionSetGroups_item, path_permissionSetGroups_item);
+                if (referencepath_permissionSetGroups_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match PermissionSetGroupsDetailsRepresentation (at "' + path_permissionSetGroups_item + '")\n';
+                    message += referencepath_permissionSetGroups_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+        if (obj.permissionSets !== undefined) {
+            const obj_permissionSets = obj.permissionSets;
+            const path_permissionSets = path + '.permissionSets';
+            if (!ArrayIsArray(obj_permissionSets)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_permissionSets + '" (at "' + path_permissionSets + '")');
+            }
+            for (let i = 0; i < obj_permissionSets.length; i++) {
+                const obj_permissionSets_item = obj_permissionSets[i];
+                const path_permissionSets_item = path_permissionSets + '[' + i + ']';
+                const referencepath_permissionSets_itemValidationError = validate$1(obj_permissionSets_item, path_permissionSets_item);
+                if (referencepath_permissionSets_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match PermissionSetsDetailsRepresentation (at "' + path_permissionSets_item + '")\n';
+                    message += referencepath_permissionSets_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+        const obj_profiles = obj.profiles;
+        const path_profiles = path + '.profiles';
+        if (!ArrayIsArray(obj_profiles)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_profiles + '" (at "' + path_profiles + '")');
+        }
+        for (let i = 0; i < obj_profiles.length; i++) {
+            const obj_profiles_item = obj_profiles[i];
+            const path_profiles_item = path_profiles + '[' + i + ']';
+            const referencepath_profiles_itemValidationError = validate$7(obj_profiles_item, path_profiles_item);
+            if (referencepath_profiles_itemValidationError !== null) {
+                let message = 'Object doesn\'t match ProfileDetailsRepresentation (at "' + path_profiles_item + '")\n';
+                message += referencepath_profiles_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType = 'AvailableUserOptionsOutputRepresentation';
+function normalize(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$1 = function AvailableUserOptionsOutputRepresentationSelect() {
+    const { selections: EmailEncodingDetailsRepresentation__selections, opaque: EmailEncodingDetailsRepresentation__opaque, } = select$4();
+    const { selections: PermissionSetGroupsDetailsRepresentation__selections, opaque: PermissionSetGroupsDetailsRepresentation__opaque, } = select$3();
+    const { selections: PermissionSetsDetailsRepresentation__selections, opaque: PermissionSetsDetailsRepresentation__opaque, } = select$2();
+    const { selections: ProfileDetailsRepresentation__selections, opaque: ProfileDetailsRepresentation__opaque, } = select$7();
+    return {
+        kind: 'Fragment',
+        version: VERSION,
+        private: [],
+        selections: [
+            {
+                name: 'emailEncodings',
+                kind: 'Object',
+                plural: true,
+                selections: EmailEncodingDetailsRepresentation__selections
+            },
+            {
+                name: 'employeeStatuses',
+                kind: 'Scalar',
+                plural: true
+            },
+            {
+                name: 'permissionSetGroups',
+                kind: 'Object',
+                plural: true,
+                selections: PermissionSetGroupsDetailsRepresentation__selections,
+                required: false
+            },
+            {
+                name: 'permissionSets',
+                kind: 'Object',
+                plural: true,
+                selections: PermissionSetsDetailsRepresentation__selections,
+                required: false
+            },
+            {
+                name: 'profiles',
+                kind: 'Object',
+                plural: true,
+                selections: ProfileDetailsRepresentation__selections
+            }
+        ]
+    };
+};
+function equals(existing, incoming) {
+    const existing_emailEncodings = existing.emailEncodings;
+    const incoming_emailEncodings = incoming.emailEncodings;
+    const equals_emailEncodings_items = equalsArray(existing_emailEncodings, incoming_emailEncodings, (existing_emailEncodings_item, incoming_emailEncodings_item) => {
+        if (!(equals$3(existing_emailEncodings_item, incoming_emailEncodings_item))) {
+            return false;
+        }
+    });
+    if (equals_emailEncodings_items === false) {
+        return false;
+    }
+    const existing_employeeStatuses = existing.employeeStatuses;
+    const incoming_employeeStatuses = incoming.employeeStatuses;
+    const equals_employeeStatuses_items = equalsArray(existing_employeeStatuses, incoming_employeeStatuses, (existing_employeeStatuses_item, incoming_employeeStatuses_item) => {
+        if (!(existing_employeeStatuses_item === incoming_employeeStatuses_item)) {
+            return false;
+        }
+    });
+    if (equals_employeeStatuses_items === false) {
+        return false;
+    }
+    const existing_permissionSetGroups = existing.permissionSetGroups;
+    const incoming_permissionSetGroups = incoming.permissionSetGroups;
+    // if at least one of these optionals is defined
+    if (existing_permissionSetGroups !== undefined || incoming_permissionSetGroups !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_permissionSetGroups === undefined || incoming_permissionSetGroups === undefined) {
+            return false;
+        }
+        const equals_permissionSetGroups_items = equalsArray(existing_permissionSetGroups, incoming_permissionSetGroups, (existing_permissionSetGroups_item, incoming_permissionSetGroups_item) => {
+            if (!(equals$2(existing_permissionSetGroups_item, incoming_permissionSetGroups_item))) {
+                return false;
+            }
+        });
+        if (equals_permissionSetGroups_items === false) {
+            return false;
+        }
+    }
+    const existing_permissionSets = existing.permissionSets;
+    const incoming_permissionSets = incoming.permissionSets;
+    // if at least one of these optionals is defined
+    if (existing_permissionSets !== undefined || incoming_permissionSets !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_permissionSets === undefined || incoming_permissionSets === undefined) {
+            return false;
+        }
+        const equals_permissionSets_items = equalsArray(existing_permissionSets, incoming_permissionSets, (existing_permissionSets_item, incoming_permissionSets_item) => {
+            if (!(equals$1(existing_permissionSets_item, incoming_permissionSets_item))) {
+                return false;
+            }
+        });
+        if (equals_permissionSets_items === false) {
+            return false;
+        }
+    }
+    const existing_profiles = existing.profiles;
+    const incoming_profiles = incoming.profiles;
+    const equals_profiles_items = equalsArray(existing_profiles, incoming_profiles, (existing_profiles_item, incoming_profiles_item) => {
+        if (!(equals$5(existing_profiles_item, incoming_profiles_item))) {
+            return false;
+        }
+    });
+    if (equals_profiles_items === false) {
+        return false;
+    }
+    return true;
+}
+const ingest = function AvailableUserOptionsOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = path.fullPath;
+    const ttlToUse = path.ttl !== undefined ? path.ttl : 300;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize, "Service-employee", VERSION, RepresentationType, equals);
+    return createLink(key);
+};
+function getTypeCacheKeys(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = fullPathFactory();
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType,
+        mergeable: false
+    });
+}
+
+function select(luvio, params) {
+    return select$1();
+}
+function keyBuilder$1(luvio, params) {
+    var _a, _b, _c, _d;
+    return keyPrefix + '::AvailableUserOptionsOutputRepresentation:(' + (((_a = params.body.permissionSets) === null || _a === void 0 ? void 0 : _a.licenses) === undefined ? 'permissionSets.licenses' : 'permissionSets.licenses:' + ((_b = params.body.permissionSets) === null || _b === void 0 ? void 0 : _b.licenses)) + '::' + (((_c = params.body.profiles) === null || _c === void 0 ? void 0 : _c.licenses) === undefined ? 'profiles.licenses' : 'profiles.licenses:' + ((_d = params.body.profiles) === null || _d === void 0 ? void 0 : _d.licenses)) + ')';
+}
+function getResponseCacheKeys(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys(storeKeyMap, luvio, response, () => keyBuilder$1(luvio, resourceParams));
+}
+function ingestSuccess(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$1(luvio, resourceParams);
+    luvio.storeIngest(key, ingest, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select(),
+        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$1(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    luvio.storeIngestError(key, errorSnapshot);
+    return errorSnapshot;
+}
+function createResourceRequest(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v66.0',
+        basePath: '/connect/serviceEmployee/availableUserOptions',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName = 'availableUserOptions';
+const availableUserOptions_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('permissionSets', false, 2 /* Body */, 4 /* Unsupported */),
+    generateParamConfigMetadata('profiles', false, 2 /* Body */, 4 /* Unsupported */),
+];
+const availableUserOptions_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, availableUserOptions_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$7(availableUserOptions_ConfigPropertyMetadata);
+function keyBuilder(luvio, config) {
+    const resourceParams = createResourceParams(config);
+    return keyBuilder$1(luvio, resourceParams);
+}
+function typeCheckConfig(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_permissionSets = untrustedConfig.permissionSets;
+    const referencePermissionSetsInputRepresentationValidationError = validate$5(untrustedConfig_permissionSets);
+    if (referencePermissionSetsInputRepresentationValidationError === null) {
+        config.permissionSets = untrustedConfig_permissionSets;
+    }
+    const untrustedConfig_profiles = untrustedConfig.profiles;
+    const referenceLicenseDetailsInputRepresentationValidationError = validate$4(untrustedConfig_profiles);
+    if (referenceLicenseDetailsInputRepresentationValidationError === null) {
+        config.profiles = untrustedConfig_profiles;
+    }
+    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 adapterFragment(luvio, config) {
+    createResourceParams(config);
+    return select();
+}
+function onFetchResponseSuccess(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError(luvio, config, resourceParams, response) {
+    const snapshot = ingestError(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot(luvio, config, options) {
+    const resourceParams = createResourceParams(config);
+    const request = createResourceRequest(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess(luvio, config, resourceParams, response), () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext, buildNetworkSnapshot, 'get', false);
+}
+function buildCachedSnapshotCachePolicy(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder(luvio, config),
+        node: adapterFragment(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const availableUserOptionsAdapterFactory = (luvio) => function serviceEmployee__availableUserOptions(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig(untrustedConfig, availableUserOptions_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
+};
+
+export { availableUserOptionsAdapterFactory, getEmpEnablementProgramsAdapterFactory, getFieldDetailsFromCompactLayoutAdapterFactory, getUserProfileDetailsAdapterFactory, getUserSettingsAdapterFactory, postEmployeeUserProvisioningJobAdapterFactory, updateUserSettingsAdapterFactory };