@salesforce/lds-adapters-sfap-analytics-insights 1.298.0

package/sfdc/index.js

@@ -0,0 +1,2852 @@
+/**
+ * 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, StoreKeyMap, createResourceParams as createResourceParams$4, typeCheckConfig as typeCheckConfig$4, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$1 } 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 = 'analytics-insights';
+
+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),
+    };
+}
+
+function validate$w(obj, path = 'MetricMetadata') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.definitionId !== undefined) {
+            const obj_definitionId = obj.definitionId;
+            const path_definitionId = path + '.definitionId';
+            if (typeof obj_definitionId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_definitionId + '" (at "' + path_definitionId + '")');
+            }
+        }
+        if (obj.name !== undefined) {
+            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;
+}
+
+function validate$v(obj, path = 'ExtensionOptions') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.analysisDimensions !== undefined) {
+            const obj_analysisDimensions = obj.analysisDimensions;
+            const path_analysisDimensions = path + '.analysisDimensions';
+            if (!ArrayIsArray(obj_analysisDimensions)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_analysisDimensions + '" (at "' + path_analysisDimensions + '")');
+            }
+            for (let i = 0; i < obj_analysisDimensions.length; i++) {
+                const obj_analysisDimensions_item = obj_analysisDimensions[i];
+                const path_analysisDimensions_item = path_analysisDimensions + '[' + i + ']';
+                if (typeof obj_analysisDimensions_item !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_analysisDimensions_item + '" (at "' + path_analysisDimensions_item + '")');
+                }
+            }
+        }
+        if (obj.minimumGranularity !== undefined) {
+            const obj_minimumGranularity = obj.minimumGranularity;
+            const path_minimumGranularity = path + '.minimumGranularity';
+            if (typeof obj_minimumGranularity !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_minimumGranularity + '" (at "' + path_minimumGranularity + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$u(obj, path = 'InsightsOptions_InsightSetting') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.disabled !== undefined) {
+            const obj_disabled = obj.disabled;
+            const path_disabled = path + '.disabled';
+            if (typeof obj_disabled !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_disabled + '" (at "' + path_disabled + '")');
+            }
+        }
+        if (obj.type !== undefined) {
+            const obj_type = obj.type;
+            const path_type = path + '.type';
+            if (typeof obj_type !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_type + '" (at "' + path_type + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$t(obj, path = 'InsightsOptions') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.settings !== undefined) {
+            const obj_settings = obj.settings;
+            const path_settings = path + '.settings';
+            if (!ArrayIsArray(obj_settings)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_settings + '" (at "' + path_settings + '")');
+            }
+            for (let i = 0; i < obj_settings.length; i++) {
+                const obj_settings_item = obj_settings[i];
+                const path_settings_item = path_settings + '[' + i + ']';
+                const referencepath_settings_itemValidationError = validate$u(obj_settings_item, path_settings_item);
+                if (referencepath_settings_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match InsightsOptions_InsightSetting (at "' + path_settings_item + '")\n';
+                    message += referencepath_settings_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$s(obj, path = 'SemanticField') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.name !== undefined) {
+            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;
+}
+
+function validate$r(obj, path = 'TableField') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.name !== undefined) {
+            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.tableName !== undefined) {
+            const obj_tableName = obj.tableName;
+            const path_tableName = path + '.tableName';
+            if (typeof obj_tableName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_tableName + '" (at "' + path_tableName + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$q(obj, path = 'NullableValue') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.boolean !== undefined) {
+            const obj_boolean = obj.boolean;
+            const path_boolean = path + '.boolean';
+            if (typeof obj_boolean !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_boolean + '" (at "' + path_boolean + '")');
+            }
+        }
+        if (obj.date !== undefined) {
+            const obj_date = obj.date;
+            const path_date = path + '.date';
+            if (typeof obj_date !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_date + '" (at "' + path_date + '")');
+            }
+        }
+        if (obj.nullValue !== undefined) {
+            const obj_nullValue = obj.nullValue;
+            const path_nullValue = path + '.nullValue';
+            if (typeof obj_nullValue !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_nullValue + '" (at "' + path_nullValue + '")');
+            }
+        }
+        if (obj.number !== undefined) {
+            const obj_number = obj.number;
+            const path_number = path + '.number';
+            if (typeof obj_number !== 'number') {
+                return new TypeError('Expected "number" but received "' + typeof obj_number + '" (at "' + path_number + '")');
+            }
+        }
+        if (obj.string !== undefined) {
+            const obj_string = obj.string;
+            const path_string = path + '.string';
+            if (typeof obj_string !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_string + '" (at "' + path_string + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$p(obj, path = 'Filter') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.operator !== undefined) {
+            const obj_operator = obj.operator;
+            const path_operator = path + '.operator';
+            if (typeof obj_operator !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_operator + '" (at "' + path_operator + '")');
+            }
+        }
+        const obj_semanticField = obj.semanticField;
+        const path_semanticField = path + '.semanticField';
+        const referencepath_semanticFieldValidationError = validate$s(obj_semanticField, path_semanticField);
+        if (referencepath_semanticFieldValidationError !== null) {
+            let message = 'Object doesn\'t match SemanticField (at "' + path_semanticField + '")\n';
+            message += referencepath_semanticFieldValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_tableField = obj.tableField;
+        const path_tableField = path + '.tableField';
+        const referencepath_tableFieldValidationError = validate$r(obj_tableField, path_tableField);
+        if (referencepath_tableFieldValidationError !== null) {
+            let message = 'Object doesn\'t match TableField (at "' + path_tableField + '")\n';
+            message += referencepath_tableFieldValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        if (obj.values !== undefined) {
+            const obj_values = obj.values;
+            const path_values = path + '.values';
+            if (!ArrayIsArray(obj_values)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_values + '" (at "' + path_values + '")');
+            }
+            for (let i = 0; i < obj_values.length; i++) {
+                const obj_values_item = obj_values[i];
+                const path_values_item = path_values + '[' + i + ']';
+                const referencepath_values_itemValidationError = validate$q(obj_values_item, path_values_item);
+                if (referencepath_values_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match NullableValue (at "' + path_values_item + '")\n';
+                    message += referencepath_values_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$o(obj, path = 'MeasurementPeriod') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.end !== undefined) {
+            const obj_end = obj.end;
+            const path_end = path + '.end';
+            if (typeof obj_end !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_end + '" (at "' + path_end + '")');
+            }
+        }
+        if (obj.granularity !== undefined) {
+            const obj_granularity = obj.granularity;
+            const path_granularity = path + '.granularity';
+            if (typeof obj_granularity !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_granularity + '" (at "' + path_granularity + '")');
+            }
+        }
+        if (obj.range !== undefined) {
+            const obj_range = obj.range;
+            const path_range = path + '.range';
+            if (typeof obj_range !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_range + '" (at "' + path_range + '")');
+            }
+        }
+        if (obj.start !== undefined) {
+            const obj_start = obj.start;
+            const path_start = path + '.start';
+            if (typeof obj_start !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_start + '" (at "' + path_start + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$n(obj, path = 'MetricInstance') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.filters !== undefined) {
+            const obj_filters = obj.filters;
+            const path_filters = path + '.filters';
+            if (!ArrayIsArray(obj_filters)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_filters + '" (at "' + path_filters + '")');
+            }
+            for (let i = 0; i < obj_filters.length; i++) {
+                const obj_filters_item = obj_filters[i];
+                const path_filters_item = path_filters + '[' + i + ']';
+                const referencepath_filters_itemValidationError = validate$p(obj_filters_item, path_filters_item);
+                if (referencepath_filters_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match Filter (at "' + path_filters_item + '")\n';
+                    message += referencepath_filters_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+        const obj_measurementPeriod = obj.measurementPeriod;
+        const path_measurementPeriod = path + '.measurementPeriod';
+        const referencepath_measurementPeriodValidationError = validate$o(obj_measurementPeriod, path_measurementPeriod);
+        if (referencepath_measurementPeriodValidationError !== null) {
+            let message = 'Object doesn\'t match MeasurementPeriod (at "' + path_measurementPeriod + '")\n';
+            message += referencepath_measurementPeriodValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$m(obj, path = 'CompareConfig') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.comparison !== undefined) {
+            const obj_comparison = obj.comparison;
+            const path_comparison = path + '.comparison';
+            if (typeof obj_comparison !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_comparison + '" (at "' + path_comparison + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$l(obj, path = 'Measure') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.aggregation !== undefined) {
+            const obj_aggregation = obj.aggregation;
+            const path_aggregation = path + '.aggregation';
+            if (typeof obj_aggregation !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_aggregation + '" (at "' + path_aggregation + '")');
+            }
+        }
+        const obj_semanticField = obj.semanticField;
+        const path_semanticField = path + '.semanticField';
+        const referencepath_semanticFieldValidationError = validate$s(obj_semanticField, path_semanticField);
+        if (referencepath_semanticFieldValidationError !== null) {
+            let message = 'Object doesn\'t match SemanticField (at "' + path_semanticField + '")\n';
+            message += referencepath_semanticFieldValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_tableField = obj.tableField;
+        const path_tableField = path + '.tableField';
+        const referencepath_tableFieldValidationError = validate$r(obj_tableField, path_tableField);
+        if (referencepath_tableFieldValidationError !== null) {
+            let message = 'Object doesn\'t match TableField (at "' + path_tableField + '")\n';
+            message += referencepath_tableFieldValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$k(obj, path = 'SemanticDataModel') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.apiName !== undefined) {
+            const obj_apiName = obj.apiName;
+            const path_apiName = path + '.apiName';
+            if (typeof obj_apiName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_apiName + '" (at "' + path_apiName + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$j(obj, path = 'TimeDimension') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_semanticField = obj.semanticField;
+        const path_semanticField = path + '.semanticField';
+        const referencepath_semanticFieldValidationError = validate$s(obj_semanticField, path_semanticField);
+        if (referencepath_semanticFieldValidationError !== null) {
+            let message = 'Object doesn\'t match SemanticField (at "' + path_semanticField + '")\n';
+            message += referencepath_semanticFieldValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_tableField = obj.tableField;
+        const path_tableField = path + '.tableField';
+        const referencepath_tableFieldValidationError = validate$r(obj_tableField, path_tableField);
+        if (referencepath_tableFieldValidationError !== null) {
+            let message = 'Object doesn\'t match TableField (at "' + path_tableField + '")\n';
+            message += referencepath_tableFieldValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$i(obj, path = 'MetricDefinition') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_comparison = obj.comparison;
+        const path_comparison = path + '.comparison';
+        const referencepath_comparisonValidationError = validate$m(obj_comparison, path_comparison);
+        if (referencepath_comparisonValidationError !== null) {
+            let message = 'Object doesn\'t match CompareConfig (at "' + path_comparison + '")\n';
+            message += referencepath_comparisonValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        if (obj.filters !== undefined) {
+            const obj_filters = obj.filters;
+            const path_filters = path + '.filters';
+            if (!ArrayIsArray(obj_filters)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_filters + '" (at "' + path_filters + '")');
+            }
+            for (let i = 0; i < obj_filters.length; i++) {
+                const obj_filters_item = obj_filters[i];
+                const path_filters_item = path_filters + '[' + i + ']';
+                const referencepath_filters_itemValidationError = validate$p(obj_filters_item, path_filters_item);
+                if (referencepath_filters_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match Filter (at "' + path_filters_item + '")\n';
+                    message += referencepath_filters_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+        const obj_measure = obj.measure;
+        const path_measure = path + '.measure';
+        const referencepath_measureValidationError = validate$l(obj_measure, path_measure);
+        if (referencepath_measureValidationError !== null) {
+            let message = 'Object doesn\'t match Measure (at "' + path_measure + '")\n';
+            message += referencepath_measureValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        if (obj.runningTotal !== undefined) {
+            const obj_runningTotal = obj.runningTotal;
+            const path_runningTotal = path + '.runningTotal';
+            if (typeof obj_runningTotal !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_runningTotal + '" (at "' + path_runningTotal + '")');
+            }
+        }
+        const obj_semanticDataModel = obj.semanticDataModel;
+        const path_semanticDataModel = path + '.semanticDataModel';
+        const referencepath_semanticDataModelValidationError = validate$k(obj_semanticDataModel, path_semanticDataModel);
+        if (referencepath_semanticDataModelValidationError !== null) {
+            let message = 'Object doesn\'t match SemanticDataModel (at "' + path_semanticDataModel + '")\n';
+            message += referencepath_semanticDataModelValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_timeDimension = obj.timeDimension;
+        const path_timeDimension = path + '.timeDimension';
+        const referencepath_timeDimensionValidationError = validate$j(obj_timeDimension, path_timeDimension);
+        if (referencepath_timeDimensionValidationError !== null) {
+            let message = 'Object doesn\'t match TimeDimension (at "' + path_timeDimension + '")\n';
+            message += referencepath_timeDimensionValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$h(obj, path = 'RepresentationOptions_NumberUnits') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.pluralNoun !== undefined) {
+            const obj_pluralNoun = obj.pluralNoun;
+            const path_pluralNoun = path + '.pluralNoun';
+            if (typeof obj_pluralNoun !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_pluralNoun + '" (at "' + path_pluralNoun + '")');
+            }
+        }
+        if (obj.singularNoun !== undefined) {
+            const obj_singularNoun = obj.singularNoun;
+            const path_singularNoun = path + '.singularNoun';
+            if (typeof obj_singularNoun !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_singularNoun + '" (at "' + path_singularNoun + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$g(obj, path = 'RepresentationOptions') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_numberUnits = obj.numberUnits;
+        const path_numberUnits = path + '.numberUnits';
+        const referencepath_numberUnitsValidationError = validate$h(obj_numberUnits, path_numberUnits);
+        if (referencepath_numberUnitsValidationError !== null) {
+            let message = 'Object doesn\'t match RepresentationOptions_NumberUnits (at "' + path_numberUnits + '")\n';
+            message += referencepath_numberUnitsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        if (obj.sentimentType !== undefined) {
+            const obj_sentimentType = obj.sentimentType;
+            const path_sentimentType = path + '.sentimentType';
+            if (typeof obj_sentimentType !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_sentimentType + '" (at "' + path_sentimentType + '")');
+            }
+        }
+        if (obj.type !== undefined) {
+            const obj_type = obj.type;
+            const path_type = path + '.type';
+            if (typeof obj_type !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_type + '" (at "' + path_type + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$f(obj, path = 'InputMetric') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_extensionOptions = obj.extensionOptions;
+        const path_extensionOptions = path + '.extensionOptions';
+        const referencepath_extensionOptionsValidationError = validate$v(obj_extensionOptions, path_extensionOptions);
+        if (referencepath_extensionOptionsValidationError !== null) {
+            let message = 'Object doesn\'t match ExtensionOptions (at "' + path_extensionOptions + '")\n';
+            message += referencepath_extensionOptionsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_insightsOptions = obj.insightsOptions;
+        const path_insightsOptions = path + '.insightsOptions';
+        const referencepath_insightsOptionsValidationError = validate$t(obj_insightsOptions, path_insightsOptions);
+        if (referencepath_insightsOptionsValidationError !== null) {
+            let message = 'Object doesn\'t match InsightsOptions (at "' + path_insightsOptions + '")\n';
+            message += referencepath_insightsOptionsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_instance = obj.instance;
+        const path_instance = path + '.instance';
+        const referencepath_instanceValidationError = validate$n(obj_instance, path_instance);
+        if (referencepath_instanceValidationError !== null) {
+            let message = 'Object doesn\'t match MetricInstance (at "' + path_instance + '")\n';
+            message += referencepath_instanceValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_metric = obj.metric;
+        const path_metric = path + '.metric';
+        const referencepath_metricValidationError = validate$i(obj_metric, path_metric);
+        if (referencepath_metricValidationError !== null) {
+            let message = 'Object doesn\'t match MetricDefinition (at "' + path_metric + '")\n';
+            message += referencepath_metricValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_representationOptions = obj.representationOptions;
+        const path_representationOptions = path + '.representationOptions';
+        const referencepath_representationOptionsValidationError = validate$g(obj_representationOptions, path_representationOptions);
+        if (referencepath_representationOptionsValidationError !== null) {
+            let message = 'Object doesn\'t match RepresentationOptions (at "' + path_representationOptions + '")\n';
+            message += referencepath_representationOptionsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$e(obj, path = 'InsightBundleInput') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_metadata = obj.metadata;
+        const path_metadata = path + '.metadata';
+        const referencepath_metadataValidationError = validate$w(obj_metadata, path_metadata);
+        if (referencepath_metadataValidationError !== null) {
+            let message = 'Object doesn\'t match MetricMetadata (at "' + path_metadata + '")\n';
+            message += referencepath_metadataValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_metric = obj.metric;
+        const path_metric = path + '.metric';
+        const referencepath_metricValidationError = validate$f(obj_metric, path_metric);
+        if (referencepath_metricValidationError !== null) {
+            let message = 'Object doesn\'t match InputMetric (at "' + path_metric + '")\n';
+            message += referencepath_metricValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$d(obj, path = 'BatchInput') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.bundleInput !== undefined) {
+            const obj_bundleInput = obj.bundleInput;
+            const path_bundleInput = path + '.bundleInput';
+            const referencepath_bundleInputValidationError = validate$e(obj_bundleInput, path_bundleInput);
+            if (referencepath_bundleInputValidationError !== null) {
+                let message = 'Object doesn\'t match InsightBundleInput (at "' + path_bundleInput + '")\n';
+                message += referencepath_bundleInputValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.metricInstanceId !== undefined) {
+            const obj_metricInstanceId = obj.metricInstanceId;
+            const path_metricInstanceId = path + '.metricInstanceId';
+            if (typeof obj_metricInstanceId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_metricInstanceId + '" (at "' + path_metricInstanceId + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+const VERSION$c = "a8b8e8e21e2dc1b5b067efa90209dce3";
+function validate$c(obj, path = 'GenerateInsightBatchResponse') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_batchId = obj.batchId;
+        const path_batchId = path + '.batchId';
+        if (typeof obj_batchId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_batchId + '" (at "' + path_batchId + '")');
+        }
+        if (obj.generatingSummary !== undefined) {
+            const obj_generatingSummary = obj.generatingSummary;
+            const path_generatingSummary = path + '.generatingSummary';
+            if (typeof obj_generatingSummary !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_generatingSummary + '" (at "' + path_generatingSummary + '")');
+            }
+        }
+        if (obj.summary !== undefined) {
+            const obj_summary = obj.summary;
+            const path_summary = path + '.summary';
+            if (obj_summary === undefined) {
+                return new TypeError('Expected "defined" but received "' + typeof obj_summary + '" (at "' + path_summary + '")');
+            }
+        }
+        if (obj.timestamp !== undefined) {
+            const obj_timestamp = obj.timestamp;
+            const path_timestamp = path + '.timestamp';
+            if (typeof obj_timestamp !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_timestamp + '" (at "' + path_timestamp + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$3 = 'GenerateInsightBatchResponse';
+function keyBuilder$5(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$3 + ':' + config.batchid;
+}
+function keyBuilderFromType$3(luvio, object) {
+    const keyParams = {
+        batchid: object.batchId
+    };
+    return keyBuilder$5(luvio, keyParams);
+}
+function normalize$3(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$g = function GenerateInsightBatchResponseSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$c,
+        private: [],
+        selections: [
+            {
+                name: 'batchId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'generatingSummary',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'summary',
+                kind: 'Object',
+                // any
+            },
+            {
+                name: 'timestamp',
+                kind: 'Scalar',
+                required: false
+            }
+        ]
+    };
+};
+function equals$c(existing, incoming) {
+    const existing_generatingSummary = existing.generatingSummary;
+    const incoming_generatingSummary = incoming.generatingSummary;
+    // if at least one of these optionals is defined
+    if (existing_generatingSummary !== undefined || incoming_generatingSummary !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_generatingSummary === undefined || incoming_generatingSummary === undefined) {
+            return false;
+        }
+        if (!(existing_generatingSummary === incoming_generatingSummary)) {
+            return false;
+        }
+    }
+    const existing_batchId = existing.batchId;
+    const incoming_batchId = incoming.batchId;
+    if (!(existing_batchId === incoming_batchId)) {
+        return false;
+    }
+    const existing_timestamp = existing.timestamp;
+    const incoming_timestamp = incoming.timestamp;
+    // if at least one of these optionals is defined
+    if (existing_timestamp !== undefined || incoming_timestamp !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_timestamp === undefined || incoming_timestamp === undefined) {
+            return false;
+        }
+        if (!(existing_timestamp === incoming_timestamp)) {
+            return false;
+        }
+    }
+    const existing_summary = existing.summary;
+    const incoming_summary = incoming.summary;
+    // if at least one of these optionals is defined
+    if (existing_summary !== undefined || incoming_summary !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_summary === undefined || incoming_summary === undefined) {
+            return false;
+        }
+        if (JSONStringify(incoming_summary) !== JSONStringify(existing_summary)) {
+            return false;
+        }
+    }
+    return true;
+}
+const ingest$3 = function GenerateInsightBatchResponseIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$c(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$3(luvio, input);
+    const ttlToUse = path.ttl !== undefined ? path.ttl : 300000;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$3, "analytics-insights", VERSION$c, RepresentationType$3, equals$c);
+    return createLink(key);
+};
+function getTypeCacheKeys$3(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$3,
+        mergeable: false
+    });
+}
+
+function select$f(luvio, params) {
+    return select$g();
+}
+function getResponseCacheKeys$3(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$3(storeKeyMap, luvio, response);
+}
+function ingestSuccess$3(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$3(luvio, body);
+    luvio.storeIngest(key, ingest$3, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$f(),
+        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: 'https://api.salesforce.com/analytics/insights/{version}',
+        basePath: '/batches',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$3 = 'createInsightsBatch';
+const createInsightsBatch_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('batchInput', false, 2 /* Body */, 4 /* Unsupported */, true),
+    generateParamConfigMetadata('options', false, 2 /* Body */, 4 /* Unsupported */),
+];
+const createInsightsBatch_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, createInsightsBatch_ConfigPropertyMetadata);
+const createResourceParams$3 = /*#__PURE__*/ createResourceParams$4(createInsightsBatch_ConfigPropertyMetadata);
+function typeCheckConfig$3(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_batchInput = untrustedConfig.batchInput;
+    if (ArrayIsArray$1(untrustedConfig_batchInput)) {
+        const untrustedConfig_batchInput_array = [];
+        for (let i = 0, arrayLength = untrustedConfig_batchInput.length; i < arrayLength; i++) {
+            const untrustedConfig_batchInput_item = untrustedConfig_batchInput[i];
+            const referenceBatchInputValidationError = validate$d(untrustedConfig_batchInput_item);
+            if (referenceBatchInputValidationError === null) {
+                untrustedConfig_batchInput_array.push(untrustedConfig_batchInput_item);
+            }
+        }
+        config.batchInput = untrustedConfig_batchInput_array;
+    }
+    const untrustedConfig_options = untrustedConfig.options;
+    config.options = untrustedConfig_options;
+    return config;
+}
+function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$3(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function 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 createInsightsBatchAdapterFactory = (luvio) => {
+    return function createInsightsBatch(untrustedConfig) {
+        const config = validateAdapterConfig$3(untrustedConfig, createInsightsBatch_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "createInsightsBatch"');
+        }
+        return buildNetworkSnapshot$3(luvio, config);
+    };
+};
+
+const VERSION$b = "07a8c889542dbad6f958515513d4e3fb";
+function validate$b(obj, path = 'Error') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.code !== undefined) {
+            const obj_code = obj.code;
+            const path_code = path + '.code';
+            if (typeof obj_code !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_code + '" (at "' + path_code + '")');
+            }
+        }
+        if (obj.message !== undefined) {
+            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$e = function ErrorSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$b,
+        private: [],
+        selections: [
+            {
+                name: 'code',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'message',
+                kind: 'Scalar',
+                required: false
+            }
+        ]
+    };
+};
+function equals$b(existing, incoming) {
+    const existing_code = existing.code;
+    const incoming_code = incoming.code;
+    // if at least one of these optionals is defined
+    if (existing_code !== undefined || incoming_code !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_code === undefined || incoming_code === undefined) {
+            return false;
+        }
+        if (!(existing_code === incoming_code)) {
+            return false;
+        }
+    }
+    const existing_message = existing.message;
+    const incoming_message = incoming.message;
+    // if at least one of these optionals is defined
+    if (existing_message !== undefined || incoming_message !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_message === undefined || incoming_message === undefined) {
+            return false;
+        }
+        if (!(existing_message === incoming_message)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const VERSION$a = "e64bc88a0a4f11fcf5a12538b4b51a87";
+function validate$a(obj, path = 'GenerateInsightBundleResponse') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.error !== undefined) {
+            const obj_error = obj.error;
+            const path_error = path + '.error';
+            const referencepath_errorValidationError = validate$b(obj_error, path_error);
+            if (referencepath_errorValidationError !== null) {
+                let message = 'Object doesn\'t match Error (at "' + path_error + '")\n';
+                message += referencepath_errorValidationError.message.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 + '")');
+        }
+        if (obj.result !== undefined) {
+            const obj_result = obj.result;
+            const path_result = path + '.result';
+            if (obj_result === undefined) {
+                return new TypeError('Expected "defined" but received "' + typeof obj_result + '" (at "' + path_result + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$2 = 'GenerateInsightBundleResponse';
+function keyBuilder$4(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$2 + ':' + config.bundleresponseid;
+}
+function keyBuilderFromType$2(luvio, object) {
+    const keyParams = {
+        bundleresponseid: object.id
+    };
+    return keyBuilder$4(luvio, keyParams);
+}
+function normalize$2(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$d = function GenerateInsightBundleResponseSelect() {
+    const { selections: Error__selections, opaque: Error__opaque, } = select$e();
+    return {
+        kind: 'Fragment',
+        version: VERSION$a,
+        private: [],
+        selections: [
+            {
+                name: 'error',
+                kind: 'Object',
+                selections: Error__selections,
+                required: false
+            },
+            {
+                name: 'id',
+                kind: 'Scalar'
+            },
+            {
+                name: 'result',
+                kind: 'Object',
+                // any
+            }
+        ]
+    };
+};
+function equals$a(existing, incoming) {
+    const existing_id = existing.id;
+    const incoming_id = incoming.id;
+    if (!(existing_id === incoming_id)) {
+        return false;
+    }
+    const existing_error = existing.error;
+    const incoming_error = incoming.error;
+    // if at least one of these optionals is defined
+    if (existing_error !== undefined || incoming_error !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_error === undefined || incoming_error === undefined) {
+            return false;
+        }
+        if (!(equals$b(existing_error, incoming_error))) {
+            return false;
+        }
+    }
+    const existing_result = existing.result;
+    const incoming_result = incoming.result;
+    // if at least one of these optionals is defined
+    if (existing_result !== undefined || incoming_result !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_result === undefined || incoming_result === undefined) {
+            return false;
+        }
+        if (JSONStringify(incoming_result) !== JSONStringify(existing_result)) {
+            return false;
+        }
+    }
+    return true;
+}
+const ingest$2 = function GenerateInsightBundleResponseIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$a(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$2(luvio, input);
+    const ttlToUse = path.ttl !== undefined ? path.ttl : 300000;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$2, "analytics-insights", VERSION$a, RepresentationType$2, equals$a);
+    return createLink(key);
+};
+function getTypeCacheKeys$2(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$2,
+        mergeable: false
+    });
+}
+
+function select$c(luvio, params) {
+    return select$d();
+}
+function getResponseCacheKeys$2(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$2(storeKeyMap, luvio, response);
+}
+function ingestSuccess$2(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$2(luvio, body);
+    luvio.storeIngest(key, ingest$2, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$c(),
+        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: 'https://api.salesforce.com/analytics/insights/{version}',
+        basePath: '/v1/generateBundle',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$2 = 'generateInsights';
+const generateInsights_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('type', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('version', false, 2 /* Body */, 3 /* Integer */),
+    generateParamConfigMetadata('input', false, 2 /* Body */, 4 /* Unsupported */),
+    generateParamConfigMetadata('options', false, 2 /* Body */, 4 /* Unsupported */),
+];
+const generateInsights_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, generateInsights_ConfigPropertyMetadata);
+const createResourceParams$2 = /*#__PURE__*/ createResourceParams$4(generateInsights_ConfigPropertyMetadata);
+function typeCheckConfig$2(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$4(untrustedConfig, config, generateInsights_ConfigPropertyMetadata);
+    const untrustedConfig_input = untrustedConfig.input;
+    config.input = untrustedConfig_input;
+    const untrustedConfig_options = untrustedConfig.options;
+    config.options = untrustedConfig_options;
+    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 generateInsightsAdapterFactory = (luvio) => {
+    return function generateInsights(untrustedConfig) {
+        const config = validateAdapterConfig$2(untrustedConfig, generateInsights_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "generateInsights"');
+        }
+        return buildNetworkSnapshot$2(luvio, config);
+    };
+};
+
+const VERSION$9 = "6b47d2ed35a900956ff58b7d8a527e7f";
+function validate$9(obj, path = 'InsightFeedbackMetadata') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.dimensionHash !== undefined) {
+            const obj_dimensionHash = obj.dimensionHash;
+            const path_dimensionHash = path + '.dimensionHash';
+            if (typeof obj_dimensionHash !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_dimensionHash + '" (at "' + path_dimensionHash + '")');
+            }
+        }
+        if (obj.score !== undefined) {
+            obj.score;
+        }
+        if (obj.type !== undefined) {
+            const obj_type = obj.type;
+            const path_type = path + '.type';
+            if (typeof obj_type !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_type + '" (at "' + path_type + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$b = function InsightFeedbackMetadataSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$9,
+        private: [],
+        selections: [
+            {
+                name: 'dimensionHash',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'score',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'type',
+                kind: 'Scalar',
+                required: false
+            }
+        ]
+    };
+};
+function equals$9(existing, incoming) {
+    const existing_dimensionHash = existing.dimensionHash;
+    const incoming_dimensionHash = incoming.dimensionHash;
+    // if at least one of these optionals is defined
+    if (existing_dimensionHash !== undefined || incoming_dimensionHash !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_dimensionHash === undefined || incoming_dimensionHash === undefined) {
+            return false;
+        }
+        if (!(existing_dimensionHash === incoming_dimensionHash)) {
+            return false;
+        }
+    }
+    const existing_type = existing.type;
+    const incoming_type = incoming.type;
+    // if at least one of these optionals is defined
+    if (existing_type !== undefined || incoming_type !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_type === undefined || incoming_type === undefined) {
+            return false;
+        }
+        if (!(existing_type === incoming_type)) {
+            return false;
+        }
+    }
+    const existing_score = existing.score;
+    const incoming_score = incoming.score;
+    // if at least one of these optionals is defined
+    if (existing_score !== undefined || incoming_score !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_score === undefined || incoming_score === undefined) {
+            return false;
+        }
+        if (!(existing_score === incoming_score)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const VERSION$8 = "b973507f0d8eb5a125451461b0e5cea2";
+function validate$8(obj, path = 'Insight') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.characterization !== undefined) {
+            const obj_characterization = obj.characterization;
+            const path_characterization = path + '.characterization';
+            if (typeof obj_characterization !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_characterization + '" (at "' + path_characterization + '")');
+            }
+        }
+        if (obj.facts !== undefined) {
+            const obj_facts = obj.facts;
+            const path_facts = path + '.facts';
+            if (typeof obj_facts !== 'object' || ArrayIsArray(obj_facts) || obj_facts === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj_facts + '" (at "' + path_facts + '")');
+            }
+        }
+        if (obj.id !== undefined) {
+            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_insightFeedbackMetadata = obj.insightFeedbackMetadata;
+        const path_insightFeedbackMetadata = path + '.insightFeedbackMetadata';
+        const referencepath_insightFeedbackMetadataValidationError = validate$9(obj_insightFeedbackMetadata, path_insightFeedbackMetadata);
+        if (referencepath_insightFeedbackMetadataValidationError !== null) {
+            let message = 'Object doesn\'t match InsightFeedbackMetadata (at "' + path_insightFeedbackMetadata + '")\n';
+            message += referencepath_insightFeedbackMetadataValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        if (obj.markup !== undefined) {
+            const obj_markup = obj.markup;
+            const path_markup = path + '.markup';
+            if (typeof obj_markup !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_markup + '" (at "' + path_markup + '")');
+            }
+        }
+        if (obj.question !== undefined) {
+            const obj_question = obj.question;
+            const path_question = path + '.question';
+            if (typeof obj_question !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_question + '" (at "' + path_question + '")');
+            }
+        }
+        if (obj.score !== undefined) {
+            obj.score;
+        }
+        if (obj.type !== undefined) {
+            const obj_type = obj.type;
+            const path_type = path + '.type';
+            if (typeof obj_type !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_type + '" (at "' + path_type + '")');
+            }
+        }
+        if (obj.vegaLiteViz !== undefined) {
+            const obj_vegaLiteViz = obj.vegaLiteViz;
+            const path_vegaLiteViz = path + '.vegaLiteViz';
+            if (typeof obj_vegaLiteViz !== 'object' || ArrayIsArray(obj_vegaLiteViz) || obj_vegaLiteViz === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj_vegaLiteViz + '" (at "' + path_vegaLiteViz + '")');
+            }
+        }
+        if (obj.version !== undefined) {
+            const obj_version = obj.version;
+            const path_version = path + '.version';
+            if (typeof obj_version !== 'number' || (typeof obj_version === 'number' && Math.floor(obj_version) !== obj_version)) {
+                return new TypeError('Expected "integer" but received "' + typeof obj_version + '" (at "' + path_version + '")');
+            }
+        }
+        if (obj.viz !== undefined) {
+            const obj_viz = obj.viz;
+            const path_viz = path + '.viz';
+            if (typeof obj_viz !== 'object' || ArrayIsArray(obj_viz) || obj_viz === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj_viz + '" (at "' + path_viz + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$a = function InsightSelect() {
+    const { selections: InsightFeedbackMetadata__selections, opaque: InsightFeedbackMetadata__opaque, } = select$b();
+    return {
+        kind: 'Fragment',
+        version: VERSION$8,
+        private: [],
+        selections: [
+            {
+                name: 'characterization',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'id',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'insightFeedbackMetadata',
+                kind: 'Object',
+                selections: InsightFeedbackMetadata__selections
+            },
+            {
+                name: 'markup',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'question',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'score',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'type',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'version',
+                kind: 'Scalar',
+                required: false
+            }
+        ]
+    };
+};
+function equals$8(existing, incoming) {
+    const existing_version = existing.version;
+    const incoming_version = incoming.version;
+    // if at least one of these optionals is defined
+    if (existing_version !== undefined || incoming_version !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_version === undefined || incoming_version === undefined) {
+            return false;
+        }
+        if (!(existing_version === incoming_version)) {
+            return false;
+        }
+    }
+    const existing_characterization = existing.characterization;
+    const incoming_characterization = incoming.characterization;
+    // if at least one of these optionals is defined
+    if (existing_characterization !== undefined || incoming_characterization !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_characterization === undefined || incoming_characterization === undefined) {
+            return false;
+        }
+        if (!(existing_characterization === incoming_characterization)) {
+            return false;
+        }
+    }
+    const existing_id = existing.id;
+    const incoming_id = incoming.id;
+    // if at least one of these optionals is defined
+    if (existing_id !== undefined || incoming_id !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_id === undefined || incoming_id === undefined) {
+            return false;
+        }
+        if (!(existing_id === incoming_id)) {
+            return false;
+        }
+    }
+    const existing_markup = existing.markup;
+    const incoming_markup = incoming.markup;
+    // if at least one of these optionals is defined
+    if (existing_markup !== undefined || incoming_markup !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_markup === undefined || incoming_markup === undefined) {
+            return false;
+        }
+        if (!(existing_markup === incoming_markup)) {
+            return false;
+        }
+    }
+    const existing_question = existing.question;
+    const incoming_question = incoming.question;
+    // if at least one of these optionals is defined
+    if (existing_question !== undefined || incoming_question !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_question === undefined || incoming_question === undefined) {
+            return false;
+        }
+        if (!(existing_question === incoming_question)) {
+            return false;
+        }
+    }
+    const existing_type = existing.type;
+    const incoming_type = incoming.type;
+    // if at least one of these optionals is defined
+    if (existing_type !== undefined || incoming_type !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_type === undefined || incoming_type === undefined) {
+            return false;
+        }
+        if (!(existing_type === incoming_type)) {
+            return false;
+        }
+    }
+    const existing_score = existing.score;
+    const incoming_score = incoming.score;
+    // if at least one of these optionals is defined
+    if (existing_score !== undefined || incoming_score !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_score === undefined || incoming_score === undefined) {
+            return false;
+        }
+        if (!(existing_score === incoming_score)) {
+            return false;
+        }
+    }
+    const existing_facts = existing.facts;
+    const incoming_facts = incoming.facts;
+    // if at least one of these optionals is defined
+    if (existing_facts !== undefined || incoming_facts !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_facts === undefined || incoming_facts === undefined) {
+            return false;
+        }
+    }
+    const existing_insightFeedbackMetadata = existing.insightFeedbackMetadata;
+    const incoming_insightFeedbackMetadata = incoming.insightFeedbackMetadata;
+    if (!(equals$9(existing_insightFeedbackMetadata, incoming_insightFeedbackMetadata))) {
+        return false;
+    }
+    const existing_vegaLiteViz = existing.vegaLiteViz;
+    const incoming_vegaLiteViz = incoming.vegaLiteViz;
+    // if at least one of these optionals is defined
+    if (existing_vegaLiteViz !== undefined || incoming_vegaLiteViz !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_vegaLiteViz === undefined || incoming_vegaLiteViz === undefined) {
+            return false;
+        }
+    }
+    const existing_viz = existing.viz;
+    const incoming_viz = incoming.viz;
+    // if at least one of these optionals is defined
+    if (existing_viz !== undefined || incoming_viz !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_viz === undefined || incoming_viz === undefined) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const VERSION$7 = "6707f0d0aa09112abbca1db5e32bb172";
+function validate$7(obj, path = 'InsightResponse') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.error !== undefined) {
+            const obj_error = obj.error;
+            const path_error = path + '.error';
+            const referencepath_errorValidationError = validate$b(obj_error, path_error);
+            if (referencepath_errorValidationError !== null) {
+                let message = 'Object doesn\'t match Error (at "' + path_error + '")\n';
+                message += referencepath_errorValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.insightType !== undefined) {
+            const obj_insightType = obj.insightType;
+            const path_insightType = path + '.insightType';
+            if (typeof obj_insightType !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_insightType + '" (at "' + path_insightType + '")');
+            }
+        }
+        const obj_result = obj.result;
+        const path_result = path + '.result';
+        const referencepath_resultValidationError = validate$8(obj_result, path_result);
+        if (referencepath_resultValidationError !== null) {
+            let message = 'Object doesn\'t match Insight (at "' + path_result + '")\n';
+            message += referencepath_resultValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$9 = function InsightResponseSelect() {
+    const { selections: Error__selections, opaque: Error__opaque, } = select$e();
+    const { selections: Insight__selections, opaque: Insight__opaque, } = select$a();
+    return {
+        kind: 'Fragment',
+        version: VERSION$7,
+        private: [],
+        selections: [
+            {
+                name: 'error',
+                kind: 'Object',
+                selections: Error__selections,
+                required: false
+            },
+            {
+                name: 'insightType',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'result',
+                kind: 'Object',
+                selections: Insight__selections
+            }
+        ]
+    };
+};
+function equals$7(existing, incoming) {
+    const existing_insightType = existing.insightType;
+    const incoming_insightType = incoming.insightType;
+    // if at least one of these optionals is defined
+    if (existing_insightType !== undefined || incoming_insightType !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_insightType === undefined || incoming_insightType === undefined) {
+            return false;
+        }
+        if (!(existing_insightType === incoming_insightType)) {
+            return false;
+        }
+    }
+    const existing_error = existing.error;
+    const incoming_error = incoming.error;
+    // if at least one of these optionals is defined
+    if (existing_error !== undefined || incoming_error !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_error === undefined || incoming_error === undefined) {
+            return false;
+        }
+        if (!(equals$b(existing_error, incoming_error))) {
+            return false;
+        }
+    }
+    const existing_result = existing.result;
+    const incoming_result = incoming.result;
+    if (!(equals$8(existing_result, incoming_result))) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$6 = "9a4f5492d8e4788f172b90ac222f71c5";
+function validate$6(obj, path = 'Overview') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.vegaLiteViz !== undefined) {
+            const obj_vegaLiteViz = obj.vegaLiteViz;
+            const path_vegaLiteViz = path + '.vegaLiteViz';
+            if (typeof obj_vegaLiteViz !== 'object' || ArrayIsArray(obj_vegaLiteViz) || obj_vegaLiteViz === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj_vegaLiteViz + '" (at "' + path_vegaLiteViz + '")');
+            }
+        }
+        if (obj.viz !== undefined) {
+            const obj_viz = obj.viz;
+            const path_viz = path + '.viz';
+            if (typeof obj_viz !== 'object' || ArrayIsArray(obj_viz) || obj_viz === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj_viz + '" (at "' + path_viz + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$8 = function OverviewSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$6,
+        private: [],
+        selections: []
+    };
+};
+function equals$6(existing, incoming) {
+    const existing_vegaLiteViz = existing.vegaLiteViz;
+    const incoming_vegaLiteViz = incoming.vegaLiteViz;
+    // if at least one of these optionals is defined
+    if (existing_vegaLiteViz !== undefined || incoming_vegaLiteViz !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_vegaLiteViz === undefined || incoming_vegaLiteViz === undefined) {
+            return false;
+        }
+    }
+    const existing_viz = existing.viz;
+    const incoming_viz = incoming.viz;
+    // if at least one of these optionals is defined
+    if (existing_viz !== undefined || incoming_viz !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_viz === undefined || incoming_viz === undefined) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const VERSION$5 = "ac3296a9832f46fda66420bc753d8c61";
+function validate$5(obj, path = 'OverviewResponse') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.error !== undefined) {
+            const obj_error = obj.error;
+            const path_error = path + '.error';
+            const referencepath_errorValidationError = validate$b(obj_error, path_error);
+            if (referencepath_errorValidationError !== null) {
+                let message = 'Object doesn\'t match Error (at "' + path_error + '")\n';
+                message += referencepath_errorValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_result = obj.result;
+        const path_result = path + '.result';
+        const referencepath_resultValidationError = validate$6(obj_result, path_result);
+        if (referencepath_resultValidationError !== null) {
+            let message = 'Object doesn\'t match Overview (at "' + path_result + '")\n';
+            message += referencepath_resultValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$7 = function OverviewResponseSelect() {
+    const { selections: Error__selections, opaque: Error__opaque, } = select$e();
+    const { selections: Overview__selections, opaque: Overview__opaque, } = select$8();
+    return {
+        kind: 'Fragment',
+        version: VERSION$5,
+        private: [],
+        selections: [
+            {
+                name: 'error',
+                kind: 'Object',
+                selections: Error__selections,
+                required: false
+            },
+            {
+                name: 'result',
+                kind: 'Object',
+                selections: Overview__selections
+            }
+        ]
+    };
+};
+function equals$5(existing, incoming) {
+    const existing_error = existing.error;
+    const incoming_error = incoming.error;
+    // if at least one of these optionals is defined
+    if (existing_error !== undefined || incoming_error !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_error === undefined || incoming_error === undefined) {
+            return false;
+        }
+        if (!(equals$b(existing_error, incoming_error))) {
+            return false;
+        }
+    }
+    const existing_result = existing.result;
+    const incoming_result = incoming.result;
+    if (!(equals$6(existing_result, incoming_result))) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$4 = "a70a5e68e786c3f38efb73cc0812d394";
+function validate$4(obj, path = 'InsightGroup') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.error !== undefined) {
+            const obj_error = obj.error;
+            const path_error = path + '.error';
+            const referencepath_errorValidationError = validate$b(obj_error, path_error);
+            if (referencepath_errorValidationError !== null) {
+                let message = 'Object doesn\'t match Error (at "' + path_error + '")\n';
+                message += referencepath_errorValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.insights !== undefined) {
+            const obj_insights = obj.insights;
+            const path_insights = path + '.insights';
+            if (!ArrayIsArray(obj_insights)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_insights + '" (at "' + path_insights + '")');
+            }
+            for (let i = 0; i < obj_insights.length; i++) {
+                const obj_insights_item = obj_insights[i];
+                const path_insights_item = path_insights + '[' + i + ']';
+                const referencepath_insights_itemValidationError = validate$7(obj_insights_item, path_insights_item);
+                if (referencepath_insights_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match InsightResponse (at "' + path_insights_item + '")\n';
+                    message += referencepath_insights_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+        if (obj.overviews !== undefined) {
+            const obj_overviews = obj.overviews;
+            const path_overviews = path + '.overviews';
+            if (!ArrayIsArray(obj_overviews)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_overviews + '" (at "' + path_overviews + '")');
+            }
+            for (let i = 0; i < obj_overviews.length; i++) {
+                const obj_overviews_item = obj_overviews[i];
+                const path_overviews_item = path_overviews + '[' + i + ']';
+                const referencepath_overviews_itemValidationError = validate$5(obj_overviews_item, path_overviews_item);
+                if (referencepath_overviews_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match OverviewResponse (at "' + path_overviews_item + '")\n';
+                    message += referencepath_overviews_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+        if (obj.type !== undefined) {
+            const obj_type = obj.type;
+            const path_type = path + '.type';
+            if (typeof obj_type !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_type + '" (at "' + path_type + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$6 = function InsightGroupSelect() {
+    const { selections: Error__selections, opaque: Error__opaque, } = select$e();
+    const { selections: InsightResponse__selections, opaque: InsightResponse__opaque, } = select$9();
+    const { selections: OverviewResponse__selections, opaque: OverviewResponse__opaque, } = select$7();
+    return {
+        kind: 'Fragment',
+        version: VERSION$4,
+        private: [],
+        selections: [
+            {
+                name: 'error',
+                kind: 'Object',
+                selections: Error__selections,
+                required: false
+            },
+            {
+                name: 'insights',
+                kind: 'Object',
+                plural: true,
+                selections: InsightResponse__selections,
+                required: false
+            },
+            {
+                name: 'overviews',
+                kind: 'Object',
+                plural: true,
+                selections: OverviewResponse__selections,
+                required: false
+            },
+            {
+                name: 'type',
+                kind: 'Scalar',
+                required: false
+            }
+        ]
+    };
+};
+function equals$4(existing, incoming) {
+    const existing_type = existing.type;
+    const incoming_type = incoming.type;
+    // if at least one of these optionals is defined
+    if (existing_type !== undefined || incoming_type !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_type === undefined || incoming_type === undefined) {
+            return false;
+        }
+        if (!(existing_type === incoming_type)) {
+            return false;
+        }
+    }
+    const existing_error = existing.error;
+    const incoming_error = incoming.error;
+    // if at least one of these optionals is defined
+    if (existing_error !== undefined || incoming_error !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_error === undefined || incoming_error === undefined) {
+            return false;
+        }
+        if (!(equals$b(existing_error, incoming_error))) {
+            return false;
+        }
+    }
+    const existing_insights = existing.insights;
+    const incoming_insights = incoming.insights;
+    // if at least one of these optionals is defined
+    if (existing_insights !== undefined || incoming_insights !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_insights === undefined || incoming_insights === undefined) {
+            return false;
+        }
+        const equals_insights_items = equalsArray(existing_insights, incoming_insights, (existing_insights_item, incoming_insights_item) => {
+            if (!(equals$7(existing_insights_item, incoming_insights_item))) {
+                return false;
+            }
+        });
+        if (equals_insights_items === false) {
+            return false;
+        }
+    }
+    const existing_overviews = existing.overviews;
+    const incoming_overviews = incoming.overviews;
+    // if at least one of these optionals is defined
+    if (existing_overviews !== undefined || incoming_overviews !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_overviews === undefined || incoming_overviews === undefined) {
+            return false;
+        }
+        const equals_overviews_items = equalsArray(existing_overviews, incoming_overviews, (existing_overviews_item, incoming_overviews_item) => {
+            if (!(equals$5(existing_overviews_item, incoming_overviews_item))) {
+                return false;
+            }
+        });
+        if (equals_overviews_items === false) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const VERSION$3 = "ccf83d258110a04c1949592c91b69b3b";
+function validate$3(obj, path = 'InsightBundle') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.characterization !== undefined) {
+            const obj_characterization = obj.characterization;
+            const path_characterization = path + '.characterization';
+            if (typeof obj_characterization !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_characterization + '" (at "' + path_characterization + '")');
+            }
+        }
+        if (obj.hasErrors !== undefined) {
+            const obj_hasErrors = obj.hasErrors;
+            const path_hasErrors = path + '.hasErrors';
+            if (typeof obj_hasErrors !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_hasErrors + '" (at "' + path_hasErrors + '")');
+            }
+        }
+        if (obj.insightGroups !== undefined) {
+            const obj_insightGroups = obj.insightGroups;
+            const path_insightGroups = path + '.insightGroups';
+            if (!ArrayIsArray(obj_insightGroups)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_insightGroups + '" (at "' + path_insightGroups + '")');
+            }
+            for (let i = 0; i < obj_insightGroups.length; i++) {
+                const obj_insightGroups_item = obj_insightGroups[i];
+                const path_insightGroups_item = path_insightGroups + '[' + i + ']';
+                const referencepath_insightGroups_itemValidationError = validate$4(obj_insightGroups_item, path_insightGroups_item);
+                if (referencepath_insightGroups_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match InsightGroup (at "' + path_insightGroups_item + '")\n';
+                    message += referencepath_insightGroups_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$5 = function InsightBundleSelect() {
+    const { selections: InsightGroup__selections, opaque: InsightGroup__opaque, } = select$6();
+    return {
+        kind: 'Fragment',
+        version: VERSION$3,
+        private: [],
+        selections: [
+            {
+                name: 'characterization',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'hasErrors',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'insightGroups',
+                kind: 'Object',
+                plural: true,
+                selections: InsightGroup__selections,
+                required: false
+            }
+        ]
+    };
+};
+function equals$3(existing, incoming) {
+    const existing_hasErrors = existing.hasErrors;
+    const incoming_hasErrors = incoming.hasErrors;
+    // if at least one of these optionals is defined
+    if (existing_hasErrors !== undefined || incoming_hasErrors !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_hasErrors === undefined || incoming_hasErrors === undefined) {
+            return false;
+        }
+        if (!(existing_hasErrors === incoming_hasErrors)) {
+            return false;
+        }
+    }
+    const existing_characterization = existing.characterization;
+    const incoming_characterization = incoming.characterization;
+    // if at least one of these optionals is defined
+    if (existing_characterization !== undefined || incoming_characterization !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_characterization === undefined || incoming_characterization === undefined) {
+            return false;
+        }
+        if (!(existing_characterization === incoming_characterization)) {
+            return false;
+        }
+    }
+    const existing_insightGroups = existing.insightGroups;
+    const incoming_insightGroups = incoming.insightGroups;
+    // if at least one of these optionals is defined
+    if (existing_insightGroups !== undefined || incoming_insightGroups !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_insightGroups === undefined || incoming_insightGroups === undefined) {
+            return false;
+        }
+        const equals_insightGroups_items = equalsArray(existing_insightGroups, incoming_insightGroups, (existing_insightGroups_item, incoming_insightGroups_item) => {
+            if (!(equals$4(existing_insightGroups_item, incoming_insightGroups_item))) {
+                return false;
+            }
+        });
+        if (equals_insightGroups_items === false) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const VERSION$2 = "8c719ff91e25e9ab6139733bd1b5c2bc";
+function validate$2(obj, path = 'GetInsightBatchResponse') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_batchId = obj.batchId;
+        const path_batchId = path + '.batchId';
+        if (typeof obj_batchId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_batchId + '" (at "' + path_batchId + '")');
+        }
+        if (obj.bundles !== undefined) {
+            const obj_bundles = obj.bundles;
+            const path_bundles = path + '.bundles';
+            if (!ArrayIsArray(obj_bundles)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_bundles + '" (at "' + path_bundles + '")');
+            }
+            for (let i = 0; i < obj_bundles.length; i++) {
+                const obj_bundles_item = obj_bundles[i];
+                const path_bundles_item = path_bundles + '[' + i + ']';
+                const referencepath_bundles_itemValidationError = validate$3(obj_bundles_item, path_bundles_item);
+                if (referencepath_bundles_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match InsightBundle (at "' + path_bundles_item + '")\n';
+                    message += referencepath_bundles_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+        if (obj.hasErrors !== undefined) {
+            const obj_hasErrors = obj.hasErrors;
+            const path_hasErrors = path + '.hasErrors';
+            if (typeof obj_hasErrors !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_hasErrors + '" (at "' + path_hasErrors + '")');
+            }
+        }
+        if (obj.summary !== undefined) {
+            const obj_summary = obj.summary;
+            const path_summary = path + '.summary';
+            if (obj_summary === undefined) {
+                return new TypeError('Expected "defined" but received "' + typeof obj_summary + '" (at "' + path_summary + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$1 = 'GetInsightBatchResponse';
+function keyBuilder$3(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$1 + ':' + config.batchid;
+}
+function keyBuilderFromType$1(luvio, object) {
+    const keyParams = {
+        batchid: object.batchId
+    };
+    return keyBuilder$3(luvio, keyParams);
+}
+function normalize$1(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$4 = function GetInsightBatchResponseSelect() {
+    const { selections: InsightBundle__selections, opaque: InsightBundle__opaque, } = select$5();
+    return {
+        kind: 'Fragment',
+        version: VERSION$2,
+        private: [],
+        selections: [
+            {
+                name: 'batchId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'bundles',
+                kind: 'Object',
+                plural: true,
+                selections: InsightBundle__selections,
+                required: false
+            },
+            {
+                name: 'hasErrors',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'summary',
+                kind: 'Object',
+                // any
+            }
+        ]
+    };
+};
+function equals$2(existing, incoming) {
+    const existing_hasErrors = existing.hasErrors;
+    const incoming_hasErrors = incoming.hasErrors;
+    // if at least one of these optionals is defined
+    if (existing_hasErrors !== undefined || incoming_hasErrors !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_hasErrors === undefined || incoming_hasErrors === undefined) {
+            return false;
+        }
+        if (!(existing_hasErrors === incoming_hasErrors)) {
+            return false;
+        }
+    }
+    const existing_batchId = existing.batchId;
+    const incoming_batchId = incoming.batchId;
+    if (!(existing_batchId === incoming_batchId)) {
+        return false;
+    }
+    const existing_bundles = existing.bundles;
+    const incoming_bundles = incoming.bundles;
+    // if at least one of these optionals is defined
+    if (existing_bundles !== undefined || incoming_bundles !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_bundles === undefined || incoming_bundles === undefined) {
+            return false;
+        }
+        const equals_bundles_items = equalsArray(existing_bundles, incoming_bundles, (existing_bundles_item, incoming_bundles_item) => {
+            if (!(equals$3(existing_bundles_item, incoming_bundles_item))) {
+                return false;
+            }
+        });
+        if (equals_bundles_items === false) {
+            return false;
+        }
+    }
+    const existing_summary = existing.summary;
+    const incoming_summary = incoming.summary;
+    // if at least one of these optionals is defined
+    if (existing_summary !== undefined || incoming_summary !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_summary === undefined || incoming_summary === undefined) {
+            return false;
+        }
+        if (JSONStringify(incoming_summary) !== JSONStringify(existing_summary)) {
+            return false;
+        }
+    }
+    return true;
+}
+const ingest$1 = function GetInsightBatchResponseIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$2(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$1(luvio, input);
+    const ttlToUse = path.ttl !== undefined ? path.ttl : 300000;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$1, "analytics-insights", VERSION$2, RepresentationType$1, equals$2);
+    return createLink(key);
+};
+function getTypeCacheKeys$1(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$1(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$1,
+        mergeable: false
+    });
+}
+
+function select$3(luvio, params) {
+    return select$4();
+}
+function keyBuilder$2(luvio, params) {
+    return keyBuilder$3(luvio, {
+        batchid: params.urlParams.batch_id
+    });
+}
+function getResponseCacheKeys$1(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$1(storeKeyMap, luvio, response);
+}
+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$3(),
+        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);
+    luvio.storeIngestError(key, errorSnapshot);
+    return errorSnapshot;
+}
+function createResourceRequest$1(config) {
+    const headers = {};
+    return {
+        baseUri: 'https://api.salesforce.com/analytics/insights/{version}',
+        basePath: '/batches/' + config.urlParams.batch_id + '',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+function createResourceRequestFromRepresentation(representation) {
+    const config = {
+        urlParams: {},
+    };
+    config.urlParams.batch_id = representation.batchId;
+    return createResourceRequest$1(config);
+}
+
+const adapterName$1 = 'getInsightsBatch';
+const getInsightsBatch_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('batch_id', true, 0 /* UrlParameter */, 0 /* String */),
+];
+const getInsightsBatch_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, getInsightsBatch_ConfigPropertyMetadata);
+const createResourceParams$1 = /*#__PURE__*/ createResourceParams$4(getInsightsBatch_ConfigPropertyMetadata);
+function keyBuilder$1(luvio, config) {
+    const resourceParams = createResourceParams$1(config);
+    return keyBuilder$2(luvio, resourceParams);
+}
+function typeCheckConfig$1(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$4(untrustedConfig, config, getInsightsBatch_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$3();
+}
+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$1(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 getInsightsBatchAdapterFactory = (luvio) => function analyticsInsights__getInsightsBatch(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$1(untrustedConfig, getInsightsBatch_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
+};
+const notifyChangeFactory = (luvio, options) => {
+    return function getBatchesByBatch_idNotifyChange(configs) {
+        const keys = configs.map(c => keyBuilder$3(luvio, c));
+        luvio.getNotifyChangeStoreEntries(keys).then(entries => {
+            for (let i = 0, len = entries.length; i < len; i++) {
+                const { key, record: val } = entries[i];
+                const refreshRequest = createResourceRequestFromRepresentation(val);
+                luvio.dispatchResourceRequest(refreshRequest, options)
+                    .then((response) => {
+                    return luvio.handleSuccessResponse(() => {
+                        const { body } = response;
+                        luvio.storeIngest(key, ingest$1, body);
+                        return luvio.storeBroadcast();
+                    }, () => {
+                        const cache = new StoreKeyMap();
+                        getTypeCacheKeys$1(cache, luvio, response.body);
+                        return cache;
+                    });
+                }, (error) => {
+                    return luvio.handleErrorResponse(() => {
+                        const errorSnapshot = luvio.errorSnapshot(error);
+                        luvio.storeIngestError(key, errorSnapshot, undefined);
+                        return luvio.storeBroadcast().then(() => errorSnapshot);
+                    });
+                });
+            }
+        });
+    };
+};
+
+const VERSION$1 = "f898ff84f82ad0ca1eca0045e17ce492";
+function validate$1(obj, path = 'GetFilterValuesResponse_CategoricalValues') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.values !== undefined) {
+            const obj_values = obj.values;
+            const path_values = path + '.values';
+            if (!ArrayIsArray(obj_values)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_values + '" (at "' + path_values + '")');
+            }
+            for (let i = 0; i < obj_values.length; i++) {
+                const obj_values_item = obj_values[i];
+                const path_values_item = path_values + '[' + i + ']';
+                let obj_values_item_union0 = null;
+                const obj_values_item_union0_error = (() => {
+                    if (typeof obj_values_item !== 'string') {
+                        return new TypeError('Expected "string" but received "' + typeof obj_values_item + '" (at "' + path_values_item + '")');
+                    }
+                })();
+                if (obj_values_item_union0_error != null) {
+                    obj_values_item_union0 = obj_values_item_union0_error.message;
+                }
+                let obj_values_item_union1 = null;
+                const obj_values_item_union1_error = (() => {
+                    if (typeof obj_values_item !== 'number') {
+                        return new TypeError('Expected "number" but received "' + typeof obj_values_item + '" (at "' + path_values_item + '")');
+                    }
+                })();
+                if (obj_values_item_union1_error != null) {
+                    obj_values_item_union1 = obj_values_item_union1_error.message;
+                }
+                let obj_values_item_union2 = null;
+                const obj_values_item_union2_error = (() => {
+                    if (typeof obj_values_item !== 'boolean') {
+                        return new TypeError('Expected "boolean" but received "' + typeof obj_values_item + '" (at "' + path_values_item + '")');
+                    }
+                })();
+                if (obj_values_item_union2_error != null) {
+                    obj_values_item_union2 = obj_values_item_union2_error.message;
+                }
+                let obj_values_item_union3 = null;
+                const obj_values_item_union3_error = (() => {
+                    if (obj_values_item !== null) {
+                        return new TypeError('Expected "null" but received "' + typeof obj_values_item + '" (at "' + path_values_item + '")');
+                    }
+                })();
+                if (obj_values_item_union3_error != null) {
+                    obj_values_item_union3 = obj_values_item_union3_error.message;
+                }
+                if (obj_values_item_union0 && obj_values_item_union1 && obj_values_item_union2 && obj_values_item_union3) {
+                    let message = 'Object doesn\'t match union (at "' + path_values_item + '")';
+                    message += '\n' + obj_values_item_union0.split('\n').map((line) => '\t' + line).join('\n');
+                    message += '\n' + obj_values_item_union1.split('\n').map((line) => '\t' + line).join('\n');
+                    message += '\n' + obj_values_item_union2.split('\n').map((line) => '\t' + line).join('\n');
+                    message += '\n' + obj_values_item_union3.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$2 = function GetFilterValuesResponse_CategoricalValuesSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$1,
+        private: [],
+        selections: [
+            {
+                name: 'values',
+                kind: 'Scalar',
+                plural: true,
+                required: false
+            }
+        ]
+    };
+};
+function equals$1(existing, incoming) {
+    const existing_values = existing.values;
+    const incoming_values = incoming.values;
+    // if at least one of these optionals is defined
+    if (existing_values !== undefined || incoming_values !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_values === undefined || incoming_values === undefined) {
+            return false;
+        }
+        const equals_values_items = equalsArray(existing_values, incoming_values, (existing_values_item, incoming_values_item) => {
+            if (!(existing_values_item === incoming_values_item)) {
+                return false;
+            }
+        });
+        if (equals_values_items === false) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const VERSION = "2025bbf393050a10fae76d5b4d5d0f58";
+function validate(obj, path = 'GetFilterValuesResponse') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_categoricalValues = obj.categoricalValues;
+        const path_categoricalValues = path + '.categoricalValues';
+        const referencepath_categoricalValuesValidationError = validate$1(obj_categoricalValues, path_categoricalValues);
+        if (referencepath_categoricalValuesValidationError !== null) {
+            let message = 'Object doesn\'t match GetFilterValuesResponse_CategoricalValues (at "' + path_categoricalValues + '")\n';
+            message += referencepath_categoricalValuesValidationError.message.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 + '")');
+        }
+        if (obj.nextPageToken !== undefined) {
+            const obj_nextPageToken = obj.nextPageToken;
+            const path_nextPageToken = path + '.nextPageToken';
+            if (typeof obj_nextPageToken !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_nextPageToken + '" (at "' + path_nextPageToken + '")');
+            }
+        }
+        if (obj.totalAvailable !== undefined) {
+            const obj_totalAvailable = obj.totalAvailable;
+            const path_totalAvailable = path + '.totalAvailable';
+            if (typeof obj_totalAvailable !== 'number' || (typeof obj_totalAvailable === 'number' && Math.floor(obj_totalAvailable) !== obj_totalAvailable)) {
+                return new TypeError('Expected "integer" but received "' + typeof obj_totalAvailable + '" (at "' + path_totalAvailable + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType = 'GetFilterValuesResponse';
+function keyBuilder(luvio, config) {
+    return keyPrefix + '::' + RepresentationType + ':' + config.filterpageid;
+}
+function keyBuilderFromType(luvio, object) {
+    const keyParams = {
+        filterpageid: object.id
+    };
+    return keyBuilder(luvio, keyParams);
+}
+function normalize(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$1 = function GetFilterValuesResponseSelect() {
+    const { selections: GetFilterValuesResponse_CategoricalValues__selections, opaque: GetFilterValuesResponse_CategoricalValues__opaque, } = select$2();
+    return {
+        kind: 'Fragment',
+        version: VERSION,
+        private: [],
+        selections: [
+            {
+                name: 'categoricalValues',
+                kind: 'Object',
+                selections: GetFilterValuesResponse_CategoricalValues__selections
+            },
+            {
+                name: 'id',
+                kind: 'Scalar'
+            },
+            {
+                name: 'nextPageToken',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'totalAvailable',
+                kind: 'Scalar',
+                required: false
+            }
+        ]
+    };
+};
+function equals(existing, incoming) {
+    const existing_totalAvailable = existing.totalAvailable;
+    const incoming_totalAvailable = incoming.totalAvailable;
+    // if at least one of these optionals is defined
+    if (existing_totalAvailable !== undefined || incoming_totalAvailable !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_totalAvailable === undefined || incoming_totalAvailable === undefined) {
+            return false;
+        }
+        if (!(existing_totalAvailable === incoming_totalAvailable)) {
+            return false;
+        }
+    }
+    const existing_id = existing.id;
+    const incoming_id = incoming.id;
+    if (!(existing_id === incoming_id)) {
+        return false;
+    }
+    const existing_nextPageToken = existing.nextPageToken;
+    const incoming_nextPageToken = incoming.nextPageToken;
+    // if at least one of these optionals is defined
+    if (existing_nextPageToken !== undefined || incoming_nextPageToken !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_nextPageToken === undefined || incoming_nextPageToken === undefined) {
+            return false;
+        }
+        if (!(existing_nextPageToken === incoming_nextPageToken)) {
+            return false;
+        }
+    }
+    const existing_categoricalValues = existing.categoricalValues;
+    const incoming_categoricalValues = incoming.categoricalValues;
+    if (!(equals$1(existing_categoricalValues, incoming_categoricalValues))) {
+        return false;
+    }
+    return true;
+}
+const ingest = function GetFilterValuesResponseIngest(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 = path.ttl !== undefined ? path.ttl : 300000;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize, "analytics-insights", 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: 'https://api.salesforce.com/analytics/insights/{version}',
+        basePath: '/filterValues',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName = 'getMetricFilterValues';
+const getMetricFilterValues_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('semanticDataModel', true, 2 /* Body */, 4 /* Unsupported */),
+    generateParamConfigMetadata('tableField', false, 2 /* Body */, 4 /* Unsupported */),
+    generateParamConfigMetadata('semanticField', false, 2 /* Body */, 4 /* Unsupported */),
+    generateParamConfigMetadata('pageToken', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('pageSize', false, 2 /* Body */, 3 /* Integer */),
+    generateParamConfigMetadata('searchTerm', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('filters', false, 2 /* Body */, 4 /* Unsupported */, true),
+];
+const getMetricFilterValues_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, getMetricFilterValues_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$4(getMetricFilterValues_ConfigPropertyMetadata);
+function typeCheckConfig(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$4(untrustedConfig, config, getMetricFilterValues_ConfigPropertyMetadata);
+    const untrustedConfig_semanticDataModel = untrustedConfig.semanticDataModel;
+    const referenceSemanticDataModelValidationError = validate$k(untrustedConfig_semanticDataModel);
+    if (referenceSemanticDataModelValidationError === null) {
+        config.semanticDataModel = untrustedConfig_semanticDataModel;
+    }
+    const untrustedConfig_tableField = untrustedConfig.tableField;
+    const referenceTableFieldValidationError = validate$r(untrustedConfig_tableField);
+    if (referenceTableFieldValidationError === null) {
+        config.tableField = untrustedConfig_tableField;
+    }
+    const untrustedConfig_semanticField = untrustedConfig.semanticField;
+    const referenceSemanticFieldValidationError = validate$s(untrustedConfig_semanticField);
+    if (referenceSemanticFieldValidationError === null) {
+        config.semanticField = untrustedConfig_semanticField;
+    }
+    const untrustedConfig_filters = untrustedConfig.filters;
+    if (ArrayIsArray$1(untrustedConfig_filters)) {
+        const untrustedConfig_filters_array = [];
+        for (let i = 0, arrayLength = untrustedConfig_filters.length; i < arrayLength; i++) {
+            const untrustedConfig_filters_item = untrustedConfig_filters[i];
+            const referenceFilterValidationError = validate$p(untrustedConfig_filters_item);
+            if (referenceFilterValidationError === null) {
+                untrustedConfig_filters_array.push(untrustedConfig_filters_item);
+            }
+        }
+        config.filters = untrustedConfig_filters_array;
+    }
+    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 getMetricFilterValuesAdapterFactory = (luvio) => {
+    return function getMetricFilterValues(untrustedConfig) {
+        const config = validateAdapterConfig(untrustedConfig, getMetricFilterValues_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "getMetricFilterValues"');
+        }
+        return buildNetworkSnapshot(luvio, config);
+    };
+};
+
+let createInsightsBatch;
+let generateInsights;
+let getInsightsBatch;
+let getInsightsBatchNotifyChange;
+let getMetricFilterValues;
+// Imperative GET Adapters
+let getInsightsBatch_imperative;
+const getInsightsBatchMetadata = { apiFamily: 'analyticsinsights', name: 'getInsightsBatch' };
+// Notify Update Available
+function bindExportsTo(luvio) {
+    // LDS Adapters
+    const getInsightsBatch_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getInsightsBatch', getInsightsBatchAdapterFactory), getInsightsBatchMetadata);
+    function unwrapSnapshotData(factory) {
+        const adapter = factory(luvio);
+        return (config) => adapter(config).then((snapshot) => snapshot.data);
+    }
+    return {
+        createInsightsBatch: unwrapSnapshotData(createInsightsBatchAdapterFactory),
+        generateInsights: unwrapSnapshotData(generateInsightsAdapterFactory),
+        getInsightsBatch: createWireAdapterConstructor(luvio, getInsightsBatch_ldsAdapter, getInsightsBatchMetadata),
+        getInsightsBatchNotifyChange: createLDSAdapter(luvio, 'getInsightsBatchNotifyChange', notifyChangeFactory),
+        getMetricFilterValues: unwrapSnapshotData(getMetricFilterValuesAdapterFactory),
+        // Imperative GET Adapters
+        getInsightsBatch_imperative: createImperativeAdapter(luvio, getInsightsBatch_ldsAdapter, getInsightsBatchMetadata),
+        // Notify Update Availables
+    };
+}
+withDefaultLuvio((luvio) => {
+    ({
+        createInsightsBatch,
+        generateInsights,
+        getInsightsBatch,
+        getInsightsBatchNotifyChange,
+        getMetricFilterValues,
+        getInsightsBatch_imperative,
+    } = bindExportsTo(luvio));
+});
+
+export { createInsightsBatch, generateInsights, getInsightsBatch, getInsightsBatchNotifyChange, getInsightsBatch_imperative, getMetricFilterValues };
+// version: 1.298.0-6f15dc1ec