@salesforce/lds-adapters-industries-omnianalytics 0.1.0-dev1

package/sfdc/index.js

@@ -0,0 +1,1927 @@
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/*
+ *  ATTENTION!
+ *  THIS IS A GENERATED FILE FROM https://github.com/salesforce-experience-platform-emu/lds-lightning-platform
+ *  If you would like to contribute to LDS, please follow the steps outlined in the git repo.
+ *  Any changes made to this file in p4 will be automatically overwritten.
+ *  *******************************************************************************************
+ */
+/* proxy-compat-disable */
+import { createInstrumentedAdapter, createLDSAdapter, createWireAdapterConstructor, createImperativeAdapter } from 'force/ldsBindings';
+import { withDefaultLuvio } from 'force/ldsEngine';
+import { serializeStructuredKey, ingestShape, deepFreeze, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$2, typeCheckConfig as typeCheckConfig$3, StoreKeyMap, createResourceParams as createResourceParams$3 } from 'force/luvioEngine';
+
+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 = 'omnianalytics';
+
+const { isArray: ArrayIsArray } = Array;
+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$8 = "71b26da062a33b1206d5b4a578dba540";
+function validate$8(obj, path = 'OmniAnalyticsLogDetailRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_applicationLogDate = obj.applicationLogDate;
+        const path_applicationLogDate = path + '.applicationLogDate';
+        if (typeof obj_applicationLogDate !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_applicationLogDate + '" (at "' + path_applicationLogDate + '")');
+        }
+        const obj_applicationName = obj.applicationName;
+        const path_applicationName = path + '.applicationName';
+        if (typeof obj_applicationName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_applicationName + '" (at "' + path_applicationName + '")');
+        }
+        const obj_componentId = obj.componentId;
+        const path_componentId = path + '.componentId';
+        if (typeof obj_componentId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_componentId + '" (at "' + path_componentId + '")');
+        }
+        const obj_componentType = obj.componentType;
+        const path_componentType = path + '.componentType';
+        if (typeof obj_componentType !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_componentType + '" (at "' + path_componentType + '")');
+        }
+        const obj_eventType = obj.eventType;
+        const path_eventType = path + '.eventType';
+        if (typeof obj_eventType !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_eventType + '" (at "' + path_eventType + '")');
+        }
+        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_omniAnalyticsLog = obj.omniAnalyticsLog;
+        const path_omniAnalyticsLog = path + '.omniAnalyticsLog';
+        if (typeof obj_omniAnalyticsLog !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_omniAnalyticsLog + '" (at "' + path_omniAnalyticsLog + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$b = function OmniAnalyticsLogDetailRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$8,
+        private: [],
+        selections: [
+            {
+                name: 'applicationLogDate',
+                kind: 'Scalar'
+            },
+            {
+                name: 'applicationName',
+                kind: 'Scalar'
+            },
+            {
+                name: 'componentId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'componentType',
+                kind: 'Scalar'
+            },
+            {
+                name: 'eventType',
+                kind: 'Scalar'
+            },
+            {
+                name: 'name',
+                kind: 'Scalar'
+            },
+            {
+                name: 'omniAnalyticsLog',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$8(existing, incoming) {
+    const existing_applicationLogDate = existing.applicationLogDate;
+    const incoming_applicationLogDate = incoming.applicationLogDate;
+    if (!(existing_applicationLogDate === incoming_applicationLogDate)) {
+        return false;
+    }
+    const existing_applicationName = existing.applicationName;
+    const incoming_applicationName = incoming.applicationName;
+    if (!(existing_applicationName === incoming_applicationName)) {
+        return false;
+    }
+    const existing_componentId = existing.componentId;
+    const incoming_componentId = incoming.componentId;
+    if (!(existing_componentId === incoming_componentId)) {
+        return false;
+    }
+    const existing_componentType = existing.componentType;
+    const incoming_componentType = incoming.componentType;
+    if (!(existing_componentType === incoming_componentType)) {
+        return false;
+    }
+    const existing_eventType = existing.eventType;
+    const incoming_eventType = incoming.eventType;
+    if (!(existing_eventType === incoming_eventType)) {
+        return false;
+    }
+    const existing_name = existing.name;
+    const incoming_name = incoming.name;
+    if (!(existing_name === incoming_name)) {
+        return false;
+    }
+    const existing_omniAnalyticsLog = existing.omniAnalyticsLog;
+    const incoming_omniAnalyticsLog = incoming.omniAnalyticsLog;
+    if (!(existing_omniAnalyticsLog === incoming_omniAnalyticsLog)) {
+        return false;
+    }
+    return true;
+}
+
+const TTL$2 = 10000;
+const VERSION$7 = "4c7a5f813fcd05ae649158a68a2194f4";
+function validate$7(obj, path = 'OmniAnalyticsLogsRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_actionLogs = obj.actionLogs;
+        const path_actionLogs = path + '.actionLogs';
+        if (!ArrayIsArray(obj_actionLogs)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_actionLogs + '" (at "' + path_actionLogs + '")');
+        }
+        for (let i = 0; i < obj_actionLogs.length; i++) {
+            const obj_actionLogs_item = obj_actionLogs[i];
+            const path_actionLogs_item = path_actionLogs + '[' + i + ']';
+            const referencepath_actionLogs_itemValidationError = validate$8(obj_actionLogs_item, path_actionLogs_item);
+            if (referencepath_actionLogs_itemValidationError !== null) {
+                let message = 'Object doesn\'t match OmniAnalyticsLogDetailRepresentation (at "' + path_actionLogs_item + '")\n';
+                message += referencepath_actionLogs_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.queryMore !== undefined) {
+            const obj_queryMore = obj.queryMore;
+            const path_queryMore = path + '.queryMore';
+            if (typeof obj_queryMore !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_queryMore + '" (at "' + path_queryMore + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$2 = 'OmniAnalyticsLogsRepresentation';
+function normalize$2(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$a = function OmniAnalyticsLogsRepresentationSelect() {
+    const { selections: OmniAnalyticsLogDetailRepresentation__selections, opaque: OmniAnalyticsLogDetailRepresentation__opaque, } = select$b();
+    return {
+        kind: 'Fragment',
+        version: VERSION$7,
+        private: [],
+        selections: [
+            {
+                name: 'actionLogs',
+                kind: 'Object',
+                plural: true,
+                selections: OmniAnalyticsLogDetailRepresentation__selections
+            },
+            {
+                name: 'queryMore',
+                kind: 'Scalar',
+                required: false
+            }
+        ]
+    };
+};
+function equals$7(existing, incoming) {
+    const existing_queryMore = existing.queryMore;
+    const incoming_queryMore = incoming.queryMore;
+    // if at least one of these optionals is defined
+    if (existing_queryMore !== undefined || incoming_queryMore !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_queryMore === undefined || incoming_queryMore === undefined) {
+            return false;
+        }
+        if (!(existing_queryMore === incoming_queryMore)) {
+            return false;
+        }
+    }
+    const existing_actionLogs = existing.actionLogs;
+    const incoming_actionLogs = incoming.actionLogs;
+    const equals_actionLogs_items = equalsArray(existing_actionLogs, incoming_actionLogs, (existing_actionLogs_item, incoming_actionLogs_item) => {
+        if (!(equals$8(existing_actionLogs_item, incoming_actionLogs_item))) {
+            return false;
+        }
+    });
+    if (equals_actionLogs_items === false) {
+        return false;
+    }
+    return true;
+}
+const ingest$2 = function OmniAnalyticsLogsRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$7(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = path.fullPath;
+    const ttlToUse = TTL$2;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$2, "omnianalytics", 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 = fullPathFactory();
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$2,
+        mergeable: false
+    });
+}
+
+function select$9(luvio, params) {
+    return select$a();
+}
+function keyBuilder$4(luvio, params) {
+    return keyPrefix + '::OmniAnalyticsLogsRepresentation:(' + 'applicationName:' + params.queryParams.applicationName + ',' + 'componentId:' + params.queryParams.componentId + ',' + 'componentType:' + params.queryParams.componentType + ',' + 'createdAfter:' + params.queryParams.createdAfter + ',' + 'createdBefore:' + params.queryParams.createdBefore + ',' + 'eventType:' + params.queryParams.eventType + ',' + 'pagesize:' + params.queryParams.pagesize + ',' + 'queryMore:' + params.queryParams.queryMore + ')';
+}
+function getResponseCacheKeys$2(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$2(storeKeyMap, luvio, response, () => keyBuilder$4(luvio, resourceParams));
+}
+function ingestSuccess$2(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$4(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$2, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$9(),
+        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$4(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    const storeMetadataParams = {
+        ttl: TTL$2,
+        namespace: keyPrefix,
+        version: VERSION$7,
+        representationName: RepresentationType$2
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
+function createResourceRequest$2(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v66.0',
+        basePath: '/connect/omni-analytics/get-analytics-logs',
+        method: 'get',
+        body: null,
+        urlParams: {},
+        queryParams: config.queryParams,
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$2 = 'fetchOmniAnalyticsLogs';
+const fetchOmniAnalyticsLogs_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('applicationName', false, 1 /* QueryParameter */, 0 /* String */),
+    generateParamConfigMetadata('componentId', false, 1 /* QueryParameter */, 0 /* String */),
+    generateParamConfigMetadata('componentType', false, 1 /* QueryParameter */, 0 /* String */),
+    generateParamConfigMetadata('createdAfter', false, 1 /* QueryParameter */, 0 /* String */),
+    generateParamConfigMetadata('createdBefore', false, 1 /* QueryParameter */, 0 /* String */),
+    generateParamConfigMetadata('eventType', false, 1 /* QueryParameter */, 0 /* String */),
+    generateParamConfigMetadata('pagesize', false, 1 /* QueryParameter */, 3 /* Integer */),
+    generateParamConfigMetadata('queryMore', false, 1 /* QueryParameter */, 0 /* String */),
+];
+const fetchOmniAnalyticsLogs_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, fetchOmniAnalyticsLogs_ConfigPropertyMetadata);
+const createResourceParams$2 = /*#__PURE__*/ createResourceParams$3(fetchOmniAnalyticsLogs_ConfigPropertyMetadata);
+function keyBuilder$3(luvio, config) {
+    const resourceParams = createResourceParams$2(config);
+    return keyBuilder$4(luvio, resourceParams);
+}
+function typeCheckConfig$2(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$3(untrustedConfig, config, fetchOmniAnalyticsLogs_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$2(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment$1(luvio, config) {
+    createResourceParams$2(config);
+    return select$9();
+}
+function onFetchResponseSuccess$1(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$2(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError$1(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$1(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$2(luvio, config, options) {
+    const resourceParams = createResourceParams$2(config);
+    const request = createResourceRequest$2(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$1(luvio, config, resourceParams, response), () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$2(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$1(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$2(context, coercedAdapterRequestContext, buildNetworkSnapshot$2, undefined, false);
+}
+function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$3(luvio, config),
+        node: adapterFragment$1(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const fetchOmniAnalyticsLogsAdapterFactory = (luvio) => function omnianalytics__fetchOmniAnalyticsLogs(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$2(untrustedConfig, fetchOmniAnalyticsLogs_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$1, buildNetworkSnapshotCachePolicy$1);
+};
+
+const VERSION$6 = "0a621a407c2ed4e5cfb104db53f4a29c";
+function validate$6(obj, path = 'OmniAnalyticsSettingRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_name = obj.name;
+        const path_name = path + '.name';
+        if (typeof obj_name !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
+        }
+        if (obj.value !== undefined) {
+            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$8 = function OmniAnalyticsSettingRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$6,
+        private: [],
+        selections: [
+            {
+                name: 'name',
+                kind: 'Scalar'
+            },
+            {
+                name: 'value',
+                kind: 'Scalar',
+                required: false
+            }
+        ]
+    };
+};
+function equals$6(existing, incoming) {
+    const existing_name = existing.name;
+    const incoming_name = incoming.name;
+    if (!(existing_name === incoming_name)) {
+        return false;
+    }
+    const existing_value = existing.value;
+    const incoming_value = incoming.value;
+    // if at least one of these optionals is defined
+    if (existing_value !== undefined || incoming_value !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_value === undefined || incoming_value === undefined) {
+            return false;
+        }
+        if (!(existing_value === incoming_value)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const VERSION$5 = "123d2efc846c30a861e29585f92e2b69";
+function validate$5(obj, path = 'OmniAnalyticsTrackingComponentRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_componentIdentifier = obj.componentIdentifier;
+        const path_componentIdentifier = path + '.componentIdentifier';
+        if (typeof obj_componentIdentifier !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_componentIdentifier + '" (at "' + path_componentIdentifier + '")');
+        }
+        if (obj.componentType !== undefined) {
+            const obj_componentType = obj.componentType;
+            const path_componentType = path + '.componentType';
+            if (typeof obj_componentType !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_componentType + '" (at "' + path_componentType + '")');
+            }
+        }
+        const obj_componentVersion = obj.componentVersion;
+        const path_componentVersion = path + '.componentVersion';
+        if (typeof obj_componentVersion !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_componentVersion + '" (at "' + path_componentVersion + '")');
+        }
+        const obj_identifier = obj.identifier;
+        const path_identifier = path + '.identifier';
+        if (typeof obj_identifier !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_identifier + '" (at "' + path_identifier + '")');
+        }
+        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 + '")');
+        }
+        if (obj.omniTrackingCompGroupId !== undefined) {
+            const obj_omniTrackingCompGroupId = obj.omniTrackingCompGroupId;
+            const path_omniTrackingCompGroupId = path + '.omniTrackingCompGroupId';
+            if (typeof obj_omniTrackingCompGroupId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_omniTrackingCompGroupId + '" (at "' + path_omniTrackingCompGroupId + '")');
+            }
+        }
+        if (obj.omniTrackingComponentDefKey !== undefined) {
+            const obj_omniTrackingComponentDefKey = obj.omniTrackingComponentDefKey;
+            const path_omniTrackingComponentDefKey = path + '.omniTrackingComponentDefKey';
+            if (typeof obj_omniTrackingComponentDefKey !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_omniTrackingComponentDefKey + '" (at "' + path_omniTrackingComponentDefKey + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$7 = function OmniAnalyticsTrackingComponentRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$5,
+        private: [],
+        selections: [
+            {
+                name: 'componentIdentifier',
+                kind: 'Scalar'
+            },
+            {
+                name: 'componentType',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'componentVersion',
+                kind: 'Scalar'
+            },
+            {
+                name: 'identifier',
+                kind: 'Scalar'
+            },
+            {
+                name: 'name',
+                kind: 'Scalar'
+            },
+            {
+                name: 'omniTrackingCompGroupId',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'omniTrackingComponentDefKey',
+                kind: 'Scalar',
+                required: false
+            }
+        ]
+    };
+};
+function equals$5(existing, incoming) {
+    const existing_componentIdentifier = existing.componentIdentifier;
+    const incoming_componentIdentifier = incoming.componentIdentifier;
+    if (!(existing_componentIdentifier === incoming_componentIdentifier)) {
+        return false;
+    }
+    const existing_componentType = existing.componentType;
+    const incoming_componentType = incoming.componentType;
+    // if at least one of these optionals is defined
+    if (existing_componentType !== undefined || incoming_componentType !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_componentType === undefined || incoming_componentType === undefined) {
+            return false;
+        }
+        if (!(existing_componentType === incoming_componentType)) {
+            return false;
+        }
+    }
+    const existing_componentVersion = existing.componentVersion;
+    const incoming_componentVersion = incoming.componentVersion;
+    if (!(existing_componentVersion === incoming_componentVersion)) {
+        return false;
+    }
+    const existing_identifier = existing.identifier;
+    const incoming_identifier = incoming.identifier;
+    if (!(existing_identifier === incoming_identifier)) {
+        return false;
+    }
+    const existing_name = existing.name;
+    const incoming_name = incoming.name;
+    if (!(existing_name === incoming_name)) {
+        return false;
+    }
+    const existing_omniTrackingCompGroupId = existing.omniTrackingCompGroupId;
+    const incoming_omniTrackingCompGroupId = incoming.omniTrackingCompGroupId;
+    // if at least one of these optionals is defined
+    if (existing_omniTrackingCompGroupId !== undefined || incoming_omniTrackingCompGroupId !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_omniTrackingCompGroupId === undefined || incoming_omniTrackingCompGroupId === undefined) {
+            return false;
+        }
+        if (!(existing_omniTrackingCompGroupId === incoming_omniTrackingCompGroupId)) {
+            return false;
+        }
+    }
+    const existing_omniTrackingComponentDefKey = existing.omniTrackingComponentDefKey;
+    const incoming_omniTrackingComponentDefKey = incoming.omniTrackingComponentDefKey;
+    // if at least one of these optionals is defined
+    if (existing_omniTrackingComponentDefKey !== undefined || incoming_omniTrackingComponentDefKey !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_omniTrackingComponentDefKey === undefined || incoming_omniTrackingComponentDefKey === undefined) {
+            return false;
+        }
+        if (!(existing_omniTrackingComponentDefKey === incoming_omniTrackingComponentDefKey)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const VERSION$4 = "c51c45397ac9228be417844ecc8f870f";
+function validate$4(obj, path = 'OmniAnalyticsTrackingExternalDefRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        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 + '")');
+        }
+        const obj_identifier = obj.identifier;
+        const path_identifier = path + '.identifier';
+        if (typeof obj_identifier !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_identifier + '" (at "' + path_identifier + '")');
+        }
+        if (obj.isActive !== undefined) {
+            const obj_isActive = obj.isActive;
+            const path_isActive = path + '.isActive';
+            if (typeof obj_isActive !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_isActive + '" (at "' + path_isActive + '")');
+            }
+        }
+        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_omniExtTrackingDefKey = obj.omniExtTrackingDefKey;
+        const path_omniExtTrackingDefKey = path + '.omniExtTrackingDefKey';
+        if (typeof obj_omniExtTrackingDefKey !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_omniExtTrackingDefKey + '" (at "' + path_omniExtTrackingDefKey + '")');
+        }
+        if (obj.trackingFrameworkInformation !== undefined) {
+            const obj_trackingFrameworkInformation = obj.trackingFrameworkInformation;
+            const path_trackingFrameworkInformation = path + '.trackingFrameworkInformation';
+            if (typeof obj_trackingFrameworkInformation !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_trackingFrameworkInformation + '" (at "' + path_trackingFrameworkInformation + '")');
+            }
+        }
+        if (obj.trackingServiceProvider !== undefined) {
+            const obj_trackingServiceProvider = obj.trackingServiceProvider;
+            const path_trackingServiceProvider = path + '.trackingServiceProvider';
+            if (typeof obj_trackingServiceProvider !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_trackingServiceProvider + '" (at "' + path_trackingServiceProvider + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$6 = function OmniAnalyticsTrackingExternalDefRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$4,
+        private: [],
+        selections: [
+            {
+                name: 'description',
+                kind: 'Scalar'
+            },
+            {
+                name: 'identifier',
+                kind: 'Scalar'
+            },
+            {
+                name: 'isActive',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'name',
+                kind: 'Scalar'
+            },
+            {
+                name: 'omniExtTrackingDefKey',
+                kind: 'Scalar'
+            },
+            {
+                name: 'trackingFrameworkInformation',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'trackingServiceProvider',
+                kind: 'Scalar',
+                required: false
+            }
+        ]
+    };
+};
+function equals$4(existing, incoming) {
+    const existing_description = existing.description;
+    const incoming_description = incoming.description;
+    if (!(existing_description === incoming_description)) {
+        return false;
+    }
+    const existing_identifier = existing.identifier;
+    const incoming_identifier = incoming.identifier;
+    if (!(existing_identifier === incoming_identifier)) {
+        return false;
+    }
+    const existing_isActive = existing.isActive;
+    const incoming_isActive = incoming.isActive;
+    // if at least one of these optionals is defined
+    if (existing_isActive !== undefined || incoming_isActive !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_isActive === undefined || incoming_isActive === undefined) {
+            return false;
+        }
+        if (!(existing_isActive === incoming_isActive)) {
+            return false;
+        }
+    }
+    const existing_name = existing.name;
+    const incoming_name = incoming.name;
+    if (!(existing_name === incoming_name)) {
+        return false;
+    }
+    const existing_omniExtTrackingDefKey = existing.omniExtTrackingDefKey;
+    const incoming_omniExtTrackingDefKey = incoming.omniExtTrackingDefKey;
+    if (!(existing_omniExtTrackingDefKey === incoming_omniExtTrackingDefKey)) {
+        return false;
+    }
+    const existing_trackingFrameworkInformation = existing.trackingFrameworkInformation;
+    const incoming_trackingFrameworkInformation = incoming.trackingFrameworkInformation;
+    // if at least one of these optionals is defined
+    if (existing_trackingFrameworkInformation !== undefined || incoming_trackingFrameworkInformation !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_trackingFrameworkInformation === undefined || incoming_trackingFrameworkInformation === undefined) {
+            return false;
+        }
+        if (!(existing_trackingFrameworkInformation === incoming_trackingFrameworkInformation)) {
+            return false;
+        }
+    }
+    const existing_trackingServiceProvider = existing.trackingServiceProvider;
+    const incoming_trackingServiceProvider = incoming.trackingServiceProvider;
+    // if at least one of these optionals is defined
+    if (existing_trackingServiceProvider !== undefined || incoming_trackingServiceProvider !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_trackingServiceProvider === undefined || incoming_trackingServiceProvider === undefined) {
+            return false;
+        }
+        if (!(existing_trackingServiceProvider === incoming_trackingServiceProvider)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const VERSION$3 = "1c4d8ed71bfcb107dd8015a6c5a862fb";
+function validate$3(obj, path = 'OmniAnalyticsTrackingExternalEventDefRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.componentType !== undefined) {
+            const obj_componentType = obj.componentType;
+            const path_componentType = path + '.componentType';
+            if (typeof obj_componentType !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_componentType + '" (at "' + path_componentType + '")');
+            }
+        }
+        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 + '")');
+        }
+        const obj_identifier = obj.identifier;
+        const path_identifier = path + '.identifier';
+        if (typeof obj_identifier !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_identifier + '" (at "' + path_identifier + '")');
+        }
+        const obj_inclusionRule = obj.inclusionRule;
+        const path_inclusionRule = path + '.inclusionRule';
+        if (typeof obj_inclusionRule !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_inclusionRule + '" (at "' + path_inclusionRule + '")');
+        }
+        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 + '")');
+        }
+        if (obj.omniExtTrackingDefId !== undefined) {
+            const obj_omniExtTrackingDefId = obj.omniExtTrackingDefId;
+            const path_omniExtTrackingDefId = path + '.omniExtTrackingDefId';
+            if (typeof obj_omniExtTrackingDefId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_omniExtTrackingDefId + '" (at "' + path_omniExtTrackingDefId + '")');
+            }
+        }
+        if (obj.omniExtTrackingEventDefKey !== undefined) {
+            const obj_omniExtTrackingEventDefKey = obj.omniExtTrackingEventDefKey;
+            const path_omniExtTrackingEventDefKey = path + '.omniExtTrackingEventDefKey';
+            if (typeof obj_omniExtTrackingEventDefKey !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_omniExtTrackingEventDefKey + '" (at "' + path_omniExtTrackingEventDefKey + '")');
+            }
+        }
+        if (obj.payloadTemplate !== undefined) {
+            const obj_payloadTemplate = obj.payloadTemplate;
+            const path_payloadTemplate = path + '.payloadTemplate';
+            if (typeof obj_payloadTemplate !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_payloadTemplate + '" (at "' + path_payloadTemplate + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$5 = function OmniAnalyticsTrackingExternalEventDefRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$3,
+        private: [],
+        selections: [
+            {
+                name: 'componentType',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'description',
+                kind: 'Scalar'
+            },
+            {
+                name: 'identifier',
+                kind: 'Scalar'
+            },
+            {
+                name: 'inclusionRule',
+                kind: 'Scalar'
+            },
+            {
+                name: 'name',
+                kind: 'Scalar'
+            },
+            {
+                name: 'omniExtTrackingDefId',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'omniExtTrackingEventDefKey',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'payloadTemplate',
+                kind: 'Scalar',
+                required: false
+            }
+        ]
+    };
+};
+function equals$3(existing, incoming) {
+    const existing_componentType = existing.componentType;
+    const incoming_componentType = incoming.componentType;
+    // if at least one of these optionals is defined
+    if (existing_componentType !== undefined || incoming_componentType !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_componentType === undefined || incoming_componentType === undefined) {
+            return false;
+        }
+        if (!(existing_componentType === incoming_componentType)) {
+            return false;
+        }
+    }
+    const existing_description = existing.description;
+    const incoming_description = incoming.description;
+    if (!(existing_description === incoming_description)) {
+        return false;
+    }
+    const existing_identifier = existing.identifier;
+    const incoming_identifier = incoming.identifier;
+    if (!(existing_identifier === incoming_identifier)) {
+        return false;
+    }
+    const existing_inclusionRule = existing.inclusionRule;
+    const incoming_inclusionRule = incoming.inclusionRule;
+    if (!(existing_inclusionRule === incoming_inclusionRule)) {
+        return false;
+    }
+    const existing_name = existing.name;
+    const incoming_name = incoming.name;
+    if (!(existing_name === incoming_name)) {
+        return false;
+    }
+    const existing_omniExtTrackingDefId = existing.omniExtTrackingDefId;
+    const incoming_omniExtTrackingDefId = incoming.omniExtTrackingDefId;
+    // if at least one of these optionals is defined
+    if (existing_omniExtTrackingDefId !== undefined || incoming_omniExtTrackingDefId !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_omniExtTrackingDefId === undefined || incoming_omniExtTrackingDefId === undefined) {
+            return false;
+        }
+        if (!(existing_omniExtTrackingDefId === incoming_omniExtTrackingDefId)) {
+            return false;
+        }
+    }
+    const existing_omniExtTrackingEventDefKey = existing.omniExtTrackingEventDefKey;
+    const incoming_omniExtTrackingEventDefKey = incoming.omniExtTrackingEventDefKey;
+    // if at least one of these optionals is defined
+    if (existing_omniExtTrackingEventDefKey !== undefined || incoming_omniExtTrackingEventDefKey !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_omniExtTrackingEventDefKey === undefined || incoming_omniExtTrackingEventDefKey === undefined) {
+            return false;
+        }
+        if (!(existing_omniExtTrackingEventDefKey === incoming_omniExtTrackingEventDefKey)) {
+            return false;
+        }
+    }
+    const existing_payloadTemplate = existing.payloadTemplate;
+    const incoming_payloadTemplate = incoming.payloadTemplate;
+    // if at least one of these optionals is defined
+    if (existing_payloadTemplate !== undefined || incoming_payloadTemplate !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_payloadTemplate === undefined || incoming_payloadTemplate === undefined) {
+            return false;
+        }
+        if (!(existing_payloadTemplate === incoming_payloadTemplate)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const VERSION$2 = "0ea01ba368d55ea9d81e0fcd069dbdeb";
+function validate$2(obj, path = 'OmniAnalyticsTrackingGroupRepresentation') {
+    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.endDate !== undefined) {
+            const obj_endDate = obj.endDate;
+            const path_endDate = path + '.endDate';
+            if (typeof obj_endDate !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_endDate + '" (at "' + path_endDate + '")');
+            }
+        }
+        const obj_groupType = obj.groupType;
+        const path_groupType = path + '.groupType';
+        if (typeof obj_groupType !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_groupType + '" (at "' + path_groupType + '")');
+        }
+        const obj_identifier = obj.identifier;
+        const path_identifier = path + '.identifier';
+        if (typeof obj_identifier !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_identifier + '" (at "' + path_identifier + '")');
+        }
+        const obj_isActive = obj.isActive;
+        const path_isActive = path + '.isActive';
+        if (typeof obj_isActive !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_isActive + '" (at "' + path_isActive + '")');
+        }
+        if (obj.maxAgeInDays !== undefined) {
+            const obj_maxAgeInDays = obj.maxAgeInDays;
+            const path_maxAgeInDays = path + '.maxAgeInDays';
+            if (typeof obj_maxAgeInDays !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_maxAgeInDays + '" (at "' + path_maxAgeInDays + '")');
+            }
+        }
+        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 + '")');
+        }
+        if (obj.omniExtTrackingDefId !== undefined) {
+            const obj_omniExtTrackingDefId = obj.omniExtTrackingDefId;
+            const path_omniExtTrackingDefId = path + '.omniExtTrackingDefId';
+            if (typeof obj_omniExtTrackingDefId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_omniExtTrackingDefId + '" (at "' + path_omniExtTrackingDefId + '")');
+            }
+        }
+        const obj_omniTrackingGroupKey = obj.omniTrackingGroupKey;
+        const path_omniTrackingGroupKey = path + '.omniTrackingGroupKey';
+        if (typeof obj_omniTrackingGroupKey !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_omniTrackingGroupKey + '" (at "' + path_omniTrackingGroupKey + '")');
+        }
+        if (obj.startDate !== undefined) {
+            const obj_startDate = obj.startDate;
+            const path_startDate = path + '.startDate';
+            if (typeof obj_startDate !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_startDate + '" (at "' + path_startDate + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$4 = function OmniAnalyticsTrackingGroupRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$2,
+        private: [],
+        selections: [
+            {
+                name: 'description',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'endDate',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'groupType',
+                kind: 'Scalar'
+            },
+            {
+                name: 'identifier',
+                kind: 'Scalar'
+            },
+            {
+                name: 'isActive',
+                kind: 'Scalar'
+            },
+            {
+                name: 'maxAgeInDays',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'name',
+                kind: 'Scalar'
+            },
+            {
+                name: 'omniExtTrackingDefId',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'omniTrackingGroupKey',
+                kind: 'Scalar'
+            },
+            {
+                name: 'startDate',
+                kind: 'Scalar',
+                required: false
+            }
+        ]
+    };
+};
+function equals$2(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_endDate = existing.endDate;
+    const incoming_endDate = incoming.endDate;
+    // if at least one of these optionals is defined
+    if (existing_endDate !== undefined || incoming_endDate !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_endDate === undefined || incoming_endDate === undefined) {
+            return false;
+        }
+        if (!(existing_endDate === incoming_endDate)) {
+            return false;
+        }
+    }
+    const existing_groupType = existing.groupType;
+    const incoming_groupType = incoming.groupType;
+    if (!(existing_groupType === incoming_groupType)) {
+        return false;
+    }
+    const existing_identifier = existing.identifier;
+    const incoming_identifier = incoming.identifier;
+    if (!(existing_identifier === incoming_identifier)) {
+        return false;
+    }
+    const existing_isActive = existing.isActive;
+    const incoming_isActive = incoming.isActive;
+    if (!(existing_isActive === incoming_isActive)) {
+        return false;
+    }
+    const existing_maxAgeInDays = existing.maxAgeInDays;
+    const incoming_maxAgeInDays = incoming.maxAgeInDays;
+    // if at least one of these optionals is defined
+    if (existing_maxAgeInDays !== undefined || incoming_maxAgeInDays !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_maxAgeInDays === undefined || incoming_maxAgeInDays === undefined) {
+            return false;
+        }
+        if (!(existing_maxAgeInDays === incoming_maxAgeInDays)) {
+            return false;
+        }
+    }
+    const existing_name = existing.name;
+    const incoming_name = incoming.name;
+    if (!(existing_name === incoming_name)) {
+        return false;
+    }
+    const existing_omniExtTrackingDefId = existing.omniExtTrackingDefId;
+    const incoming_omniExtTrackingDefId = incoming.omniExtTrackingDefId;
+    // if at least one of these optionals is defined
+    if (existing_omniExtTrackingDefId !== undefined || incoming_omniExtTrackingDefId !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_omniExtTrackingDefId === undefined || incoming_omniExtTrackingDefId === undefined) {
+            return false;
+        }
+        if (!(existing_omniExtTrackingDefId === incoming_omniExtTrackingDefId)) {
+            return false;
+        }
+    }
+    const existing_omniTrackingGroupKey = existing.omniTrackingGroupKey;
+    const incoming_omniTrackingGroupKey = incoming.omniTrackingGroupKey;
+    if (!(existing_omniTrackingGroupKey === incoming_omniTrackingGroupKey)) {
+        return false;
+    }
+    const existing_startDate = existing.startDate;
+    const incoming_startDate = incoming.startDate;
+    // if at least one of these optionals is defined
+    if (existing_startDate !== undefined || incoming_startDate !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_startDate === undefined || incoming_startDate === undefined) {
+            return false;
+        }
+        if (!(existing_startDate === incoming_startDate)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const TTL$1 = 60000;
+const VERSION$1 = "36cccddb5d7c08dae651feb75fa8c461";
+function validate$1(obj, path = 'OmniAnalyticsMetadataRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.omniAnalyticsSettings !== undefined) {
+            const obj_omniAnalyticsSettings = obj.omniAnalyticsSettings;
+            const path_omniAnalyticsSettings = path + '.omniAnalyticsSettings';
+            if (!ArrayIsArray(obj_omniAnalyticsSettings)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_omniAnalyticsSettings + '" (at "' + path_omniAnalyticsSettings + '")');
+            }
+            for (let i = 0; i < obj_omniAnalyticsSettings.length; i++) {
+                const obj_omniAnalyticsSettings_item = obj_omniAnalyticsSettings[i];
+                const path_omniAnalyticsSettings_item = path_omniAnalyticsSettings + '[' + i + ']';
+                const referencepath_omniAnalyticsSettings_itemValidationError = validate$6(obj_omniAnalyticsSettings_item, path_omniAnalyticsSettings_item);
+                if (referencepath_omniAnalyticsSettings_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match OmniAnalyticsSettingRepresentation (at "' + path_omniAnalyticsSettings_item + '")\n';
+                    message += referencepath_omniAnalyticsSettings_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+        if (obj.trackingComponents !== undefined) {
+            const obj_trackingComponents = obj.trackingComponents;
+            const path_trackingComponents = path + '.trackingComponents';
+            if (!ArrayIsArray(obj_trackingComponents)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_trackingComponents + '" (at "' + path_trackingComponents + '")');
+            }
+            for (let i = 0; i < obj_trackingComponents.length; i++) {
+                const obj_trackingComponents_item = obj_trackingComponents[i];
+                const path_trackingComponents_item = path_trackingComponents + '[' + i + ']';
+                const referencepath_trackingComponents_itemValidationError = validate$5(obj_trackingComponents_item, path_trackingComponents_item);
+                if (referencepath_trackingComponents_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match OmniAnalyticsTrackingComponentRepresentation (at "' + path_trackingComponents_item + '")\n';
+                    message += referencepath_trackingComponents_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+        if (obj.trackingExternalDefintions !== undefined) {
+            const obj_trackingExternalDefintions = obj.trackingExternalDefintions;
+            const path_trackingExternalDefintions = path + '.trackingExternalDefintions';
+            if (!ArrayIsArray(obj_trackingExternalDefintions)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_trackingExternalDefintions + '" (at "' + path_trackingExternalDefintions + '")');
+            }
+            for (let i = 0; i < obj_trackingExternalDefintions.length; i++) {
+                const obj_trackingExternalDefintions_item = obj_trackingExternalDefintions[i];
+                const path_trackingExternalDefintions_item = path_trackingExternalDefintions + '[' + i + ']';
+                const referencepath_trackingExternalDefintions_itemValidationError = validate$4(obj_trackingExternalDefintions_item, path_trackingExternalDefintions_item);
+                if (referencepath_trackingExternalDefintions_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match OmniAnalyticsTrackingExternalDefRepresentation (at "' + path_trackingExternalDefintions_item + '")\n';
+                    message += referencepath_trackingExternalDefintions_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+        if (obj.trackingExternalEventDefintions !== undefined) {
+            const obj_trackingExternalEventDefintions = obj.trackingExternalEventDefintions;
+            const path_trackingExternalEventDefintions = path + '.trackingExternalEventDefintions';
+            if (!ArrayIsArray(obj_trackingExternalEventDefintions)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_trackingExternalEventDefintions + '" (at "' + path_trackingExternalEventDefintions + '")');
+            }
+            for (let i = 0; i < obj_trackingExternalEventDefintions.length; i++) {
+                const obj_trackingExternalEventDefintions_item = obj_trackingExternalEventDefintions[i];
+                const path_trackingExternalEventDefintions_item = path_trackingExternalEventDefintions + '[' + i + ']';
+                const referencepath_trackingExternalEventDefintions_itemValidationError = validate$3(obj_trackingExternalEventDefintions_item, path_trackingExternalEventDefintions_item);
+                if (referencepath_trackingExternalEventDefintions_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match OmniAnalyticsTrackingExternalEventDefRepresentation (at "' + path_trackingExternalEventDefintions_item + '")\n';
+                    message += referencepath_trackingExternalEventDefintions_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+        if (obj.trackingGroups !== undefined) {
+            const obj_trackingGroups = obj.trackingGroups;
+            const path_trackingGroups = path + '.trackingGroups';
+            if (!ArrayIsArray(obj_trackingGroups)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_trackingGroups + '" (at "' + path_trackingGroups + '")');
+            }
+            for (let i = 0; i < obj_trackingGroups.length; i++) {
+                const obj_trackingGroups_item = obj_trackingGroups[i];
+                const path_trackingGroups_item = path_trackingGroups + '[' + i + ']';
+                const referencepath_trackingGroups_itemValidationError = validate$2(obj_trackingGroups_item, path_trackingGroups_item);
+                if (referencepath_trackingGroups_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match OmniAnalyticsTrackingGroupRepresentation (at "' + path_trackingGroups_item + '")\n';
+                    message += referencepath_trackingGroups_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$1 = 'OmniAnalyticsMetadataRepresentation';
+function normalize$1(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$3 = function OmniAnalyticsMetadataRepresentationSelect() {
+    const { selections: OmniAnalyticsSettingRepresentation__selections, opaque: OmniAnalyticsSettingRepresentation__opaque, } = select$8();
+    const { selections: OmniAnalyticsTrackingComponentRepresentation__selections, opaque: OmniAnalyticsTrackingComponentRepresentation__opaque, } = select$7();
+    const { selections: OmniAnalyticsTrackingExternalDefRepresentation__selections, opaque: OmniAnalyticsTrackingExternalDefRepresentation__opaque, } = select$6();
+    const { selections: OmniAnalyticsTrackingExternalEventDefRepresentation__selections, opaque: OmniAnalyticsTrackingExternalEventDefRepresentation__opaque, } = select$5();
+    const { selections: OmniAnalyticsTrackingGroupRepresentation__selections, opaque: OmniAnalyticsTrackingGroupRepresentation__opaque, } = select$4();
+    return {
+        kind: 'Fragment',
+        version: VERSION$1,
+        private: [],
+        selections: [
+            {
+                name: 'omniAnalyticsSettings',
+                kind: 'Object',
+                plural: true,
+                selections: OmniAnalyticsSettingRepresentation__selections,
+                required: false
+            },
+            {
+                name: 'trackingComponents',
+                kind: 'Object',
+                plural: true,
+                selections: OmniAnalyticsTrackingComponentRepresentation__selections,
+                required: false
+            },
+            {
+                name: 'trackingExternalDefintions',
+                kind: 'Object',
+                plural: true,
+                selections: OmniAnalyticsTrackingExternalDefRepresentation__selections,
+                required: false
+            },
+            {
+                name: 'trackingExternalEventDefintions',
+                kind: 'Object',
+                plural: true,
+                selections: OmniAnalyticsTrackingExternalEventDefRepresentation__selections,
+                required: false
+            },
+            {
+                name: 'trackingGroups',
+                kind: 'Object',
+                plural: true,
+                selections: OmniAnalyticsTrackingGroupRepresentation__selections,
+                required: false
+            }
+        ]
+    };
+};
+function equals$1(existing, incoming) {
+    const existing_omniAnalyticsSettings = existing.omniAnalyticsSettings;
+    const incoming_omniAnalyticsSettings = incoming.omniAnalyticsSettings;
+    // if at least one of these optionals is defined
+    if (existing_omniAnalyticsSettings !== undefined || incoming_omniAnalyticsSettings !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_omniAnalyticsSettings === undefined || incoming_omniAnalyticsSettings === undefined) {
+            return false;
+        }
+        const equals_omniAnalyticsSettings_items = equalsArray(existing_omniAnalyticsSettings, incoming_omniAnalyticsSettings, (existing_omniAnalyticsSettings_item, incoming_omniAnalyticsSettings_item) => {
+            if (!(equals$6(existing_omniAnalyticsSettings_item, incoming_omniAnalyticsSettings_item))) {
+                return false;
+            }
+        });
+        if (equals_omniAnalyticsSettings_items === false) {
+            return false;
+        }
+    }
+    const existing_trackingComponents = existing.trackingComponents;
+    const incoming_trackingComponents = incoming.trackingComponents;
+    // if at least one of these optionals is defined
+    if (existing_trackingComponents !== undefined || incoming_trackingComponents !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_trackingComponents === undefined || incoming_trackingComponents === undefined) {
+            return false;
+        }
+        const equals_trackingComponents_items = equalsArray(existing_trackingComponents, incoming_trackingComponents, (existing_trackingComponents_item, incoming_trackingComponents_item) => {
+            if (!(equals$5(existing_trackingComponents_item, incoming_trackingComponents_item))) {
+                return false;
+            }
+        });
+        if (equals_trackingComponents_items === false) {
+            return false;
+        }
+    }
+    const existing_trackingExternalDefintions = existing.trackingExternalDefintions;
+    const incoming_trackingExternalDefintions = incoming.trackingExternalDefintions;
+    // if at least one of these optionals is defined
+    if (existing_trackingExternalDefintions !== undefined || incoming_trackingExternalDefintions !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_trackingExternalDefintions === undefined || incoming_trackingExternalDefintions === undefined) {
+            return false;
+        }
+        const equals_trackingExternalDefintions_items = equalsArray(existing_trackingExternalDefintions, incoming_trackingExternalDefintions, (existing_trackingExternalDefintions_item, incoming_trackingExternalDefintions_item) => {
+            if (!(equals$4(existing_trackingExternalDefintions_item, incoming_trackingExternalDefintions_item))) {
+                return false;
+            }
+        });
+        if (equals_trackingExternalDefintions_items === false) {
+            return false;
+        }
+    }
+    const existing_trackingExternalEventDefintions = existing.trackingExternalEventDefintions;
+    const incoming_trackingExternalEventDefintions = incoming.trackingExternalEventDefintions;
+    // if at least one of these optionals is defined
+    if (existing_trackingExternalEventDefintions !== undefined || incoming_trackingExternalEventDefintions !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_trackingExternalEventDefintions === undefined || incoming_trackingExternalEventDefintions === undefined) {
+            return false;
+        }
+        const equals_trackingExternalEventDefintions_items = equalsArray(existing_trackingExternalEventDefintions, incoming_trackingExternalEventDefintions, (existing_trackingExternalEventDefintions_item, incoming_trackingExternalEventDefintions_item) => {
+            if (!(equals$3(existing_trackingExternalEventDefintions_item, incoming_trackingExternalEventDefintions_item))) {
+                return false;
+            }
+        });
+        if (equals_trackingExternalEventDefintions_items === false) {
+            return false;
+        }
+    }
+    const existing_trackingGroups = existing.trackingGroups;
+    const incoming_trackingGroups = incoming.trackingGroups;
+    // if at least one of these optionals is defined
+    if (existing_trackingGroups !== undefined || incoming_trackingGroups !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_trackingGroups === undefined || incoming_trackingGroups === undefined) {
+            return false;
+        }
+        const equals_trackingGroups_items = equalsArray(existing_trackingGroups, incoming_trackingGroups, (existing_trackingGroups_item, incoming_trackingGroups_item) => {
+            if (!(equals$2(existing_trackingGroups_item, incoming_trackingGroups_item))) {
+                return false;
+            }
+        });
+        if (equals_trackingGroups_items === false) {
+            return false;
+        }
+    }
+    return true;
+}
+const ingest$1 = function OmniAnalyticsMetadataRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$1(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = path.fullPath;
+    const ttlToUse = TTL$1;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$1, "omnianalytics", VERSION$1, RepresentationType$1, equals$1);
+    return createLink(key);
+};
+function getTypeCacheKeys$1(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = fullPathFactory();
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$1,
+        mergeable: false
+    });
+}
+
+function select$2(luvio, params) {
+    return select$3();
+}
+function keyBuilder$2(luvio, params) {
+    return keyPrefix + '::OmniAnalyticsMetadataRepresentation:(' + 'externalTrackingDefName:' + params.queryParams.externalTrackingDefName + ',' + 'fetchSettings:' + params.queryParams.fetchSettings + ',' + 'groupName:' + params.queryParams.groupName + ',' + 'isActive:' + params.queryParams.isActive + ')';
+}
+function getResponseCacheKeys$1(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$1(storeKeyMap, luvio, response, () => keyBuilder$2(luvio, resourceParams));
+}
+function ingestSuccess$1(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$2(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$1, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$2(),
+        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$2(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    const storeMetadataParams = {
+        ttl: TTL$1,
+        namespace: keyPrefix,
+        version: VERSION$1,
+        representationName: RepresentationType$1
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
+function createResourceRequest$1(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v66.0',
+        basePath: '/connect/omni-analytics/analytics-metadata',
+        method: 'get',
+        body: null,
+        urlParams: {},
+        queryParams: config.queryParams,
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$1 = 'fetchOmniAnalyticsMetadata';
+const fetchOmniAnalyticsMetadata_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('externalTrackingDefName', false, 1 /* QueryParameter */, 0 /* String */),
+    generateParamConfigMetadata('fetchSettings', false, 1 /* QueryParameter */, 1 /* Boolean */),
+    generateParamConfigMetadata('groupName', false, 1 /* QueryParameter */, 0 /* String */),
+    generateParamConfigMetadata('isActive', false, 1 /* QueryParameter */, 1 /* Boolean */),
+];
+const fetchOmniAnalyticsMetadata_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, fetchOmniAnalyticsMetadata_ConfigPropertyMetadata);
+const createResourceParams$1 = /*#__PURE__*/ createResourceParams$3(fetchOmniAnalyticsMetadata_ConfigPropertyMetadata);
+function keyBuilder$1(luvio, config) {
+    const resourceParams = createResourceParams$1(config);
+    return keyBuilder$2(luvio, resourceParams);
+}
+function typeCheckConfig$1(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$3(untrustedConfig, config, fetchOmniAnalyticsMetadata_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(luvio, config) {
+    createResourceParams$1(config);
+    return select$2();
+}
+function onFetchResponseSuccess(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(luvio, config, resourceParams, response) {
+    const snapshot = ingestError(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(luvio, config, resourceParams, response), () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$1(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$2(context, coercedAdapterRequestContext, buildNetworkSnapshot$1, undefined, false);
+}
+function buildCachedSnapshotCachePolicy(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$1(luvio, config),
+        node: adapterFragment(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const fetchOmniAnalyticsMetadataAdapterFactory = (luvio) => function omnianalytics__fetchOmniAnalyticsMetadata(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$1(untrustedConfig, fetchOmniAnalyticsMetadata_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
+};
+
+const TTL = 10000;
+const VERSION = "3d2e52fd8e2f4a4244b68292d0af7634";
+function validate(obj, path = 'OmniAnalyticsLogCreateRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.eventPublishStatus !== undefined) {
+            const obj_eventPublishStatus = obj.eventPublishStatus;
+            const path_eventPublishStatus = path + '.eventPublishStatus';
+            if (typeof obj_eventPublishStatus !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_eventPublishStatus + '" (at "' + path_eventPublishStatus + '")');
+            }
+        }
+        if (obj.externalStatusMesg !== undefined) {
+            const obj_externalStatusMesg = obj.externalStatusMesg;
+            const path_externalStatusMesg = path + '.externalStatusMesg';
+            if (typeof obj_externalStatusMesg !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_externalStatusMesg + '" (at "' + path_externalStatusMesg + '")');
+            }
+        }
+        if (obj.internalEventId !== undefined) {
+            const obj_internalEventId = obj.internalEventId;
+            const path_internalEventId = path + '.internalEventId';
+            if (typeof obj_internalEventId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_internalEventId + '" (at "' + path_internalEventId + '")');
+            }
+        }
+        const obj_responseId = obj.responseId;
+        const path_responseId = path + '.responseId';
+        if (typeof obj_responseId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_responseId + '" (at "' + path_responseId + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType = 'OmniAnalyticsLogCreateRepresentation';
+function keyBuilder(luvio, config) {
+    return keyPrefix + '::' + RepresentationType + ':' + config.responseId;
+}
+function keyBuilderFromType(luvio, object) {
+    const keyParams = {
+        responseId: object.responseId
+    };
+    return keyBuilder(luvio, keyParams);
+}
+function normalize(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$1 = function OmniAnalyticsLogCreateRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION,
+        private: [],
+        selections: [
+            {
+                name: 'eventPublishStatus',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'externalStatusMesg',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'internalEventId',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'responseId',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals(existing, incoming) {
+    const existing_eventPublishStatus = existing.eventPublishStatus;
+    const incoming_eventPublishStatus = incoming.eventPublishStatus;
+    // if at least one of these optionals is defined
+    if (existing_eventPublishStatus !== undefined || incoming_eventPublishStatus !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_eventPublishStatus === undefined || incoming_eventPublishStatus === undefined) {
+            return false;
+        }
+        if (!(existing_eventPublishStatus === incoming_eventPublishStatus)) {
+            return false;
+        }
+    }
+    const existing_externalStatusMesg = existing.externalStatusMesg;
+    const incoming_externalStatusMesg = incoming.externalStatusMesg;
+    // if at least one of these optionals is defined
+    if (existing_externalStatusMesg !== undefined || incoming_externalStatusMesg !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_externalStatusMesg === undefined || incoming_externalStatusMesg === undefined) {
+            return false;
+        }
+        if (!(existing_externalStatusMesg === incoming_externalStatusMesg)) {
+            return false;
+        }
+    }
+    const existing_internalEventId = existing.internalEventId;
+    const incoming_internalEventId = incoming.internalEventId;
+    // if at least one of these optionals is defined
+    if (existing_internalEventId !== undefined || incoming_internalEventId !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_internalEventId === undefined || incoming_internalEventId === undefined) {
+            return false;
+        }
+        if (!(existing_internalEventId === incoming_internalEventId)) {
+            return false;
+        }
+    }
+    const existing_responseId = existing.responseId;
+    const incoming_responseId = incoming.responseId;
+    if (!(existing_responseId === incoming_responseId)) {
+        return false;
+    }
+    return true;
+}
+const ingest = function OmniAnalyticsLogCreateRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType(luvio, input);
+    const ttlToUse = TTL;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize, "omnianalytics", VERSION, RepresentationType, equals);
+    return createLink(key);
+};
+function getTypeCacheKeys(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType,
+        mergeable: false
+    });
+}
+
+function select(luvio, params) {
+    return select$1();
+}
+function getResponseCacheKeys(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys(storeKeyMap, luvio, response);
+}
+function ingestSuccess(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType(luvio, body);
+    luvio.storeIngest(key, ingest, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select(),
+        variables: {},
+    });
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
+}
+function createResourceRequest(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v66.0',
+        basePath: '/connect/omni-analytics/analytics-logs',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName = 'storeOmniAnalyticsLogs';
+const storeOmniAnalyticsLogs_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('analyticsLog', true, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('analyticsLogDate', true, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('analyticsLogOwnerId', true, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('componentId', true, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('eventType', true, 2 /* Body */, 0 /* String */),
+];
+const storeOmniAnalyticsLogs_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, storeOmniAnalyticsLogs_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$3(storeOmniAnalyticsLogs_ConfigPropertyMetadata);
+function typeCheckConfig(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$3(untrustedConfig, config, storeOmniAnalyticsLogs_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot(luvio, config, options) {
+    const resourceParams = createResourceParams(config);
+    const request = createResourceRequest(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const storeOmniAnalyticsLogsAdapterFactory = (luvio) => {
+    return function storeOmniAnalyticsLogs(untrustedConfig) {
+        const config = validateAdapterConfig(untrustedConfig, storeOmniAnalyticsLogs_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "storeOmniAnalyticsLogs"');
+        }
+        return buildNetworkSnapshot(luvio, config);
+    };
+};
+
+let fetchOmniAnalyticsLogs;
+let fetchOmniAnalyticsMetadata;
+let storeOmniAnalyticsLogs;
+// Imperative GET Adapters
+let fetchOmniAnalyticsLogs_imperative;
+let fetchOmniAnalyticsMetadata_imperative;
+// Adapter Metadata
+const fetchOmniAnalyticsLogsMetadata = {
+    apiFamily: 'omnianalytics',
+    name: 'fetchOmniAnalyticsLogs',
+    ttl: 10000,
+};
+const fetchOmniAnalyticsMetadataMetadata = {
+    apiFamily: 'omnianalytics',
+    name: 'fetchOmniAnalyticsMetadata',
+    ttl: 60000,
+};
+// Notify Update Available
+function bindExportsTo(luvio) {
+    // LDS Adapters
+    const fetchOmniAnalyticsLogs_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'fetchOmniAnalyticsLogs', fetchOmniAnalyticsLogsAdapterFactory), fetchOmniAnalyticsLogsMetadata);
+    const fetchOmniAnalyticsMetadata_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'fetchOmniAnalyticsMetadata', fetchOmniAnalyticsMetadataAdapterFactory), fetchOmniAnalyticsMetadataMetadata);
+    function unwrapSnapshotData(factory) {
+        const adapter = factory(luvio);
+        return (config) => adapter(config).then((snapshot) => snapshot.data);
+    }
+    return {
+        fetchOmniAnalyticsLogs: createWireAdapterConstructor(luvio, fetchOmniAnalyticsLogs_ldsAdapter, fetchOmniAnalyticsLogsMetadata),
+        fetchOmniAnalyticsMetadata: createWireAdapterConstructor(luvio, fetchOmniAnalyticsMetadata_ldsAdapter, fetchOmniAnalyticsMetadataMetadata),
+        storeOmniAnalyticsLogs: unwrapSnapshotData(storeOmniAnalyticsLogsAdapterFactory),
+        // Imperative GET Adapters
+        fetchOmniAnalyticsLogs_imperative: createImperativeAdapter(luvio, fetchOmniAnalyticsLogs_ldsAdapter, fetchOmniAnalyticsLogsMetadata),
+        fetchOmniAnalyticsMetadata_imperative: createImperativeAdapter(luvio, fetchOmniAnalyticsMetadata_ldsAdapter, fetchOmniAnalyticsMetadataMetadata),
+        // Notify Update Availables
+    };
+}
+withDefaultLuvio((luvio) => {
+    ({
+        fetchOmniAnalyticsLogs,
+        fetchOmniAnalyticsMetadata,
+        storeOmniAnalyticsLogs,
+        fetchOmniAnalyticsLogs_imperative,
+        fetchOmniAnalyticsMetadata_imperative,
+    } = bindExportsTo(luvio));
+});
+
+export { fetchOmniAnalyticsLogs, fetchOmniAnalyticsLogs_imperative, fetchOmniAnalyticsMetadata, fetchOmniAnalyticsMetadata_imperative, storeOmniAnalyticsLogs };
+// version: 0.1.0-dev1-c978a7b010