@salesforce/lds-adapters-sfap-analytics-insights 0.1.0-dev1

package/dist/es/es2018/sfap-analytics-insights.js

@@ -0,0 +1,3750 @@
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, createResourceParams as createResourceParams$5, typeCheckConfig as typeCheckConfig$5, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$1 } from '@luvio/engine';
+
+const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
+const { keys: ObjectKeys, create: ObjectCreate } = Object;
+const { isArray: ArrayIsArray$1 } = Array;
+/**
+ * Validates an adapter config is well-formed.
+ * @param config The config to validate.
+ * @param adapter The adapter validation configuration.
+ * @param oneOf The keys the config must contain at least one of.
+ * @throws A TypeError if config doesn't satisfy the adapter's config validation.
+ */
+function validateConfig(config, adapter, oneOf) {
+    const { displayName } = adapter;
+    const { required, optional, unsupported } = adapter.parameters;
+    if (config === undefined ||
+        required.every(req => ObjectPrototypeHasOwnProperty.call(config, req)) === false) {
+        throw new TypeError(`adapter ${displayName} configuration must specify ${required.sort().join(', ')}`);
+    }
+    if (oneOf && oneOf.some(req => ObjectPrototypeHasOwnProperty.call(config, req)) === false) {
+        throw new TypeError(`adapter ${displayName} configuration must specify one of ${oneOf.sort().join(', ')}`);
+    }
+    if (unsupported !== undefined &&
+        unsupported.some(req => ObjectPrototypeHasOwnProperty.call(config, req))) {
+        throw new TypeError(`adapter ${displayName} does not yet support ${unsupported.sort().join(', ')}`);
+    }
+    const supported = required.concat(optional);
+    if (ObjectKeys(config).some(key => !supported.includes(key))) {
+        throw new TypeError(`adapter ${displayName} configuration supports only ${supported.sort().join(', ')}`);
+    }
+}
+function untrustedIsObject(untrusted) {
+    return typeof untrusted === 'object' && untrusted !== null && ArrayIsArray$1(untrusted) === false;
+}
+function areRequiredParametersPresent(config, configPropertyNames) {
+    return configPropertyNames.parameters.required.every(req => req in config);
+}
+const snapshotRefreshOptions = {
+    overrides: {
+        headers: {
+            'Cache-Control': 'no-cache',
+        },
+    }
+};
+function generateParamConfigMetadata(name, required, resourceType, typeCheckShape, isArrayShape = false, coerceFn) {
+    return {
+        name,
+        required,
+        resourceType,
+        typeCheckShape,
+        isArrayShape,
+        coerceFn,
+    };
+}
+function buildAdapterValidationConfig(displayName, paramsMeta) {
+    const required = paramsMeta.filter(p => p.required).map(p => p.name);
+    const optional = paramsMeta.filter(p => !p.required).map(p => p.name);
+    return {
+        displayName,
+        parameters: {
+            required,
+            optional,
+        }
+    };
+}
+const keyPrefix = '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$I(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$H(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$G(obj, path = 'GoalMetadata_StatusCondition') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.color !== undefined) {
+            const obj_color = obj.color;
+            const path_color = path + '.color';
+            if (typeof obj_color !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_color + '" (at "' + path_color + '")');
+            }
+        }
+        if (obj.currencyIsoCode !== undefined) {
+            const obj_currencyIsoCode = obj.currencyIsoCode;
+            const path_currencyIsoCode = path + '.currencyIsoCode';
+            if (typeof obj_currencyIsoCode !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_currencyIsoCode + '" (at "' + path_currencyIsoCode + '")');
+            }
+        }
+        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 + '")');
+            }
+        }
+        if (obj.primary !== undefined) {
+            const obj_primary = obj.primary;
+            const path_primary = path + '.primary';
+            if (typeof obj_primary !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_primary + '" (at "' + path_primary + '")');
+            }
+        }
+        if (obj.statusName !== undefined) {
+            const obj_statusName = obj.statusName;
+            const path_statusName = path + '.statusName';
+            if (typeof obj_statusName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_statusName + '" (at "' + path_statusName + '")');
+            }
+        }
+        if (obj.value !== undefined) {
+            const obj_value = obj.value;
+            const path_value = path + '.value';
+            if (typeof obj_value !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_value + '" (at "' + path_value + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$F(obj, path = 'GoalMetadata') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.forecasting !== undefined) {
+            const obj_forecasting = obj.forecasting;
+            const path_forecasting = path + '.forecasting';
+            if (typeof obj_forecasting !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_forecasting + '" (at "' + path_forecasting + '")');
+            }
+        }
+        if (obj.statusConditions !== undefined) {
+            const obj_statusConditions = obj.statusConditions;
+            const path_statusConditions = path + '.statusConditions';
+            if (!ArrayIsArray(obj_statusConditions)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_statusConditions + '" (at "' + path_statusConditions + '")');
+            }
+            for (let i = 0; i < obj_statusConditions.length; i++) {
+                const obj_statusConditions_item = obj_statusConditions[i];
+                const path_statusConditions_item = path_statusConditions + '[' + i + ']';
+                const referencepath_statusConditions_itemValidationError = validate$G(obj_statusConditions_item, path_statusConditions_item);
+                if (referencepath_statusConditions_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match GoalMetadata_StatusCondition (at "' + path_statusConditions_item + '")\n';
+                    message += referencepath_statusConditions_itemValidationError.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 = '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$D(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$E(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$C(obj, path = 'CategoricalFilterOptions') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.nullOption !== undefined) {
+            const obj_nullOption = obj.nullOption;
+            const path_nullOption = path + '.nullOption';
+            if (typeof obj_nullOption !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_nullOption + '" (at "' + path_nullOption + '")');
+            }
+        }
+        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 + '")');
+            }
+        }
+        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 + ']';
+                if (obj_values_item === undefined) {
+                    return new TypeError('Expected "defined" but received "' + typeof obj_values_item + '" (at "' + path_values_item + '")');
+                }
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$B(obj, path = 'FieldId') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.datasource !== undefined) {
+            const obj_datasource = obj.datasource;
+            const path_datasource = path + '.datasource';
+            if (typeof obj_datasource !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_datasource + '" (at "' + path_datasource + '")');
+            }
+        }
+        if (obj.fieldName !== undefined) {
+            const obj_fieldName = obj.fieldName;
+            const path_fieldName = path + '.fieldName';
+            if (typeof obj_fieldName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_fieldName + '" (at "' + path_fieldName + '")');
+            }
+        }
+        if (obj.objectName !== undefined) {
+            const obj_objectName = obj.objectName;
+            const path_objectName = path + '.objectName';
+            if (typeof obj_objectName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_objectName + '" (at "' + path_objectName + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$A(obj, path = 'RangeFilterOptions') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.excludeMax !== undefined) {
+            const obj_excludeMax = obj.excludeMax;
+            const path_excludeMax = path + '.excludeMax';
+            if (typeof obj_excludeMax !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_excludeMax + '" (at "' + path_excludeMax + '")');
+            }
+        }
+        if (obj.excludeMin !== undefined) {
+            const obj_excludeMin = obj.excludeMin;
+            const path_excludeMin = path + '.excludeMin';
+            if (typeof obj_excludeMin !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_excludeMin + '" (at "' + path_excludeMin + '")');
+            }
+        }
+        if (obj.max !== undefined) {
+            const obj_max = obj.max;
+            const path_max = path + '.max';
+            if (obj_max === undefined) {
+                return new TypeError('Expected "defined" but received "' + typeof obj_max + '" (at "' + path_max + '")');
+            }
+        }
+        if (obj.min !== undefined) {
+            const obj_min = obj.min;
+            const path_min = path + '.min';
+            if (obj_min === undefined) {
+                return new TypeError('Expected "defined" but received "' + typeof obj_min + '" (at "' + path_min + '")');
+            }
+        }
+        if (obj.nullOption !== undefined) {
+            const obj_nullOption = obj.nullOption;
+            const path_nullOption = path + '.nullOption';
+            if (typeof obj_nullOption !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_nullOption + '" (at "' + path_nullOption + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$z(obj, path = 'RelativeDateFilterOptions') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$y(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.categoricalFilterOptions !== undefined) {
+            const obj_categoricalFilterOptions = obj.categoricalFilterOptions;
+            const path_categoricalFilterOptions = path + '.categoricalFilterOptions';
+            const referencepath_categoricalFilterOptionsValidationError = validate$C(obj_categoricalFilterOptions, path_categoricalFilterOptions);
+            if (referencepath_categoricalFilterOptionsValidationError !== null) {
+                let message = 'Object doesn\'t match CategoricalFilterOptions (at "' + path_categoricalFilterOptions + '")\n';
+                message += referencepath_categoricalFilterOptionsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.field !== undefined) {
+            const obj_field = obj.field;
+            const path_field = path + '.field';
+            const referencepath_fieldValidationError = validate$B(obj_field, path_field);
+            if (referencepath_fieldValidationError !== null) {
+                let message = 'Object doesn\'t match FieldId (at "' + path_field + '")\n';
+                message += referencepath_fieldValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.fieldId !== undefined) {
+            const obj_fieldId = obj.fieldId;
+            const path_fieldId = path + '.fieldId';
+            const referencepath_fieldIdValidationError = validate$B(obj_fieldId, path_fieldId);
+            if (referencepath_fieldIdValidationError !== null) {
+                let message = 'Object doesn\'t match FieldId (at "' + path_fieldId + '")\n';
+                message += referencepath_fieldIdValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.rangeFilterOptions !== undefined) {
+            const obj_rangeFilterOptions = obj.rangeFilterOptions;
+            const path_rangeFilterOptions = path + '.rangeFilterOptions';
+            const referencepath_rangeFilterOptionsValidationError = validate$A(obj_rangeFilterOptions, path_rangeFilterOptions);
+            if (referencepath_rangeFilterOptionsValidationError !== null) {
+                let message = 'Object doesn\'t match RangeFilterOptions (at "' + path_rangeFilterOptions + '")\n';
+                message += referencepath_rangeFilterOptionsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.relativeDateFilterOptions !== undefined) {
+            const obj_relativeDateFilterOptions = obj.relativeDateFilterOptions;
+            const path_relativeDateFilterOptions = path + '.relativeDateFilterOptions';
+            const referencepath_relativeDateFilterOptionsValidationError = validate$z(obj_relativeDateFilterOptions, path_relativeDateFilterOptions);
+            if (referencepath_relativeDateFilterOptionsValidationError !== null) {
+                let message = 'Object doesn\'t match RelativeDateFilterOptions (at "' + path_relativeDateFilterOptions + '")\n';
+                message += referencepath_relativeDateFilterOptionsValidationError.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;
+}
+
+function validate$x(obj, path = 'SemanticFilter') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.aggregationMethod !== undefined) {
+            const obj_aggregationMethod = obj.aggregationMethod;
+            const path_aggregationMethod = path + '.aggregationMethod';
+            if (typeof obj_aggregationMethod !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_aggregationMethod + '" (at "' + path_aggregationMethod + '")');
+            }
+        }
+        const obj_fieldName = obj.fieldName;
+        const path_fieldName = path + '.fieldName';
+        if (typeof obj_fieldName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_fieldName + '" (at "' + path_fieldName + '")');
+        }
+        if (obj.fieldType !== undefined) {
+            const obj_fieldType = obj.fieldType;
+            const path_fieldType = path + '.fieldType';
+            if (typeof obj_fieldType !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_fieldType + '" (at "' + path_fieldType + '")');
+            }
+        }
+        const obj_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 + '")');
+        }
+        if (obj.value !== undefined) {
+            const obj_value = obj.value;
+            const path_value = path + '.value';
+            if (typeof obj_value !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_value + '" (at "' + path_value + '")');
+            }
+        }
+        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 + ']';
+                if (typeof obj_values_item !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_values_item + '" (at "' + path_values_item + '")');
+                }
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$w(obj, path = 'FlattenFilter') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.filterLogic !== undefined) {
+            const obj_filterLogic = obj.filterLogic;
+            const path_filterLogic = path + '.filterLogic';
+            if (typeof obj_filterLogic !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_filterLogic + '" (at "' + path_filterLogic + '")');
+            }
+        }
+        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$x(obj_filters_item, path_filters_item);
+                if (referencepath_filters_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match SemanticFilter (at "' + path_filters_item + '")\n';
+                    message += referencepath_filters_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$v(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$y(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);
+                }
+            }
+        }
+        if (obj.goals !== undefined) {
+            const obj_goals = obj.goals;
+            const path_goals = path + '.goals';
+            const referencepath_goalsValidationError = validate$F(obj_goals, path_goals);
+            if (referencepath_goalsValidationError !== null) {
+                let message = 'Object doesn\'t match GoalMetadata (at "' + path_goals + '")\n';
+                message += referencepath_goalsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.measurementPeriod !== undefined) {
+            const obj_measurementPeriod = obj.measurementPeriod;
+            const path_measurementPeriod = path + '.measurementPeriod';
+            if (obj_measurementPeriod === undefined) {
+                return new TypeError('Expected "defined" but received "' + typeof obj_measurementPeriod + '" (at "' + path_measurementPeriod + '")');
+            }
+        }
+        if (obj.semanticFilter !== undefined) {
+            const obj_semanticFilter = obj.semanticFilter;
+            const path_semanticFilter = path + '.semanticFilter';
+            const referencepath_semanticFilterValidationError = validate$w(obj_semanticFilter, path_semanticFilter);
+            if (referencepath_semanticFilterValidationError !== null) {
+                let message = 'Object doesn\'t match FlattenFilter (at "' + path_semanticFilter + '")\n';
+                message += referencepath_semanticFilterValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$u(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$t(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_field = obj.field;
+        const path_field = path + '.field';
+        const referencepath_fieldValidationError = validate$B(obj_field, path_field);
+        if (referencepath_fieldValidationError !== null) {
+            let message = 'Object doesn\'t match FieldId (at "' + path_field + '")\n';
+            message += referencepath_fieldValidationError.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 = '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$r(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_field = obj.field;
+        const path_field = path + '.field';
+        const referencepath_fieldValidationError = validate$B(obj_field, path_field);
+        if (referencepath_fieldValidationError !== null) {
+            let message = 'Object doesn\'t match FieldId (at "' + path_field + '")\n';
+            message += referencepath_fieldValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$q(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$u(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$y(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$t(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$s(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);
+        }
+        if (obj.semanticFilter !== undefined) {
+            const obj_semanticFilter = obj.semanticFilter;
+            const path_semanticFilter = path + '.semanticFilter';
+            const referencepath_semanticFilterValidationError = validate$w(obj_semanticFilter, path_semanticFilter);
+            if (referencepath_semanticFilterValidationError !== null) {
+                let message = 'Object doesn\'t match FlattenFilter (at "' + path_semanticFilter + '")\n';
+                message += referencepath_semanticFilterValidationError.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$r(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$p(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$o(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$p(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$n(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$H(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);
+        }
+        if (obj.goals !== undefined) {
+            const obj_goals = obj.goals;
+            const path_goals = path + '.goals';
+            const referencepath_goalsValidationError = validate$F(obj_goals, path_goals);
+            if (referencepath_goalsValidationError !== null) {
+                let message = 'Object doesn\'t match GoalMetadata (at "' + path_goals + '")\n';
+                message += referencepath_goalsValidationError.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$D(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$v(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$q(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$o(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$m(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$I(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$n(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;
+}
+
+const VERSION$g = "7948f62379bf327a3cc190504223aecc";
+function validate$l(obj, path = 'UnifiedFilter') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.fieldName !== undefined) {
+            const obj_fieldName = obj.fieldName;
+            const path_fieldName = path + '.fieldName';
+            if (typeof obj_fieldName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_fieldName + '" (at "' + path_fieldName + '")');
+            }
+        }
+        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 + '")');
+            }
+        }
+        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 + ']';
+                if (obj_values_item === undefined) {
+                    return new TypeError('Expected "defined" but received "' + typeof obj_values_item + '" (at "' + path_values_item + '")');
+                }
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$l = function UnifiedFilterSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$g,
+        private: [],
+        selections: [
+            {
+                name: 'fieldName',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'operator',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'values',
+                kind: 'Object',
+                // any
+            }
+        ]
+    };
+};
+function equals$g(existing, incoming) {
+    const existing_fieldName = existing.fieldName;
+    const incoming_fieldName = incoming.fieldName;
+    // if at least one of these optionals is defined
+    if (existing_fieldName !== undefined || incoming_fieldName !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_fieldName === undefined || incoming_fieldName === undefined) {
+            return false;
+        }
+        if (!(existing_fieldName === incoming_fieldName)) {
+            return false;
+        }
+    }
+    const existing_operator = existing.operator;
+    const incoming_operator = incoming.operator;
+    // if at least one of these optionals is defined
+    if (existing_operator !== undefined || incoming_operator !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_operator === undefined || incoming_operator === undefined) {
+            return false;
+        }
+        if (!(existing_operator === incoming_operator)) {
+            return false;
+        }
+    }
+    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 (JSONStringify(incoming_values_item) !== JSONStringify(existing_values_item)) {
+                return false;
+            }
+        });
+        if (equals_values_items === false) {
+            return false;
+        }
+    }
+    return true;
+}
+
+function validate$k(obj, path = 'MetricInstanceInput') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.measurementPeriod !== undefined) {
+            const obj_measurementPeriod = obj.measurementPeriod;
+            const path_measurementPeriod = path + '.measurementPeriod';
+            const referencepath_measurementPeriodValidationError = validate$l(obj_measurementPeriod, path_measurementPeriod);
+            if (referencepath_measurementPeriodValidationError !== null) {
+                let message = 'Object doesn\'t match UnifiedFilter (at "' + path_measurementPeriod + '")\n';
+                message += referencepath_measurementPeriodValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        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 + '")');
+        }
+        const obj_sdmId = obj.sdmId;
+        const path_sdmId = path + '.sdmId';
+        if (typeof obj_sdmId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_sdmId + '" (at "' + path_sdmId + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$j(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$m(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.metricInstanceInput !== undefined) {
+            const obj_metricInstanceInput = obj.metricInstanceInput;
+            const path_metricInstanceInput = path + '.metricInstanceInput';
+            const referencepath_metricInstanceInputValidationError = validate$k(obj_metricInstanceInput, path_metricInstanceInput);
+            if (referencepath_metricInstanceInputValidationError !== null) {
+                let message = 'Object doesn\'t match MetricInstanceInput (at "' + path_metricInstanceInput + '")\n';
+                message += referencepath_metricInstanceInputValidationError.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 = 'InsightBundleOptions') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.now !== undefined) {
+            const obj_now = obj.now;
+            const path_now = path + '.now';
+            if (typeof obj_now !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_now + '" (at "' + path_now + '")');
+            }
+        }
+        if (obj.outputFormat !== undefined) {
+            const obj_outputFormat = obj.outputFormat;
+            const path_outputFormat = path + '.outputFormat';
+            if (typeof obj_outputFormat !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_outputFormat + '" (at "' + path_outputFormat + '")');
+            }
+        }
+        if (obj.timeZone !== undefined) {
+            const obj_timeZone = obj.timeZone;
+            const path_timeZone = path + '.timeZone';
+            if (typeof obj_timeZone !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_timeZone + '" (at "' + path_timeZone + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$h(obj, path = 'SummarizationOptions') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.strategy !== undefined) {
+            const obj_strategy = obj.strategy;
+            const path_strategy = path + '.strategy';
+            if (typeof obj_strategy !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_strategy + '" (at "' + path_strategy + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$g(obj, path = 'BatchOptions') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.bundle !== undefined) {
+            const obj_bundle = obj.bundle;
+            const path_bundle = path + '.bundle';
+            const referencepath_bundleValidationError = validate$i(obj_bundle, path_bundle);
+            if (referencepath_bundleValidationError !== null) {
+                let message = 'Object doesn\'t match InsightBundleOptions (at "' + path_bundle + '")\n';
+                message += referencepath_bundleValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.skipCache !== undefined) {
+            const obj_skipCache = obj.skipCache;
+            const path_skipCache = path + '.skipCache';
+            if (typeof obj_skipCache !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_skipCache + '" (at "' + path_skipCache + '")');
+            }
+        }
+        if (obj.summarization !== undefined) {
+            const obj_summarization = obj.summarization;
+            const path_summarization = path + '.summarization';
+            const referencepath_summarizationValidationError = validate$h(obj_summarization, path_summarization);
+            if (referencepath_summarizationValidationError !== null) {
+                let message = 'Object doesn\'t match SummarizationOptions (at "' + path_summarization + '")\n';
+                message += referencepath_summarizationValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+const VERSION$f = "07a8c889542dbad6f958515513d4e3fb";
+function validate$f(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$k = function ErrorSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$f,
+        private: [],
+        selections: [
+            {
+                name: 'code',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'message',
+                kind: 'Scalar',
+                required: false
+            }
+        ]
+    };
+};
+function equals$f(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$e = "6e24eb6767cb7eb05e4ae19fffe299b1";
+function validate$e(obj, path = 'Summary') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.generationId !== undefined) {
+            const obj_generationId = obj.generationId;
+            const path_generationId = path + '.generationId';
+            if (typeof obj_generationId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_generationId + '" (at "' + path_generationId + '")');
+            }
+        }
+        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 + '")');
+        }
+        const obj_strategy = obj.strategy;
+        const path_strategy = path + '.strategy';
+        if (typeof obj_strategy !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_strategy + '" (at "' + path_strategy + '")');
+        }
+        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 select$j = function SummarySelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$e,
+        private: [],
+        selections: [
+            {
+                name: 'generationId',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'markup',
+                kind: 'Scalar'
+            },
+            {
+                name: 'strategy',
+                kind: 'Scalar'
+            },
+            {
+                name: 'timestamp',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$e(existing, incoming) {
+    const existing_generationId = existing.generationId;
+    const incoming_generationId = incoming.generationId;
+    // if at least one of these optionals is defined
+    if (existing_generationId !== undefined || incoming_generationId !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_generationId === undefined || incoming_generationId === undefined) {
+            return false;
+        }
+        if (!(existing_generationId === incoming_generationId)) {
+            return false;
+        }
+    }
+    const existing_markup = existing.markup;
+    const incoming_markup = incoming.markup;
+    if (!(existing_markup === incoming_markup)) {
+        return false;
+    }
+    const existing_strategy = existing.strategy;
+    const incoming_strategy = incoming.strategy;
+    if (!(existing_strategy === incoming_strategy)) {
+        return false;
+    }
+    const existing_timestamp = existing.timestamp;
+    const incoming_timestamp = incoming.timestamp;
+    if (!(existing_timestamp === incoming_timestamp)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$d = "fc433e1c68019470090193fa4fdf976f";
+function validate$d(obj, path = 'SummaryResponse') {
+    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$f(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$e(obj_result, path_result);
+        if (referencepath_resultValidationError !== null) {
+            let message = 'Object doesn\'t match Summary (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$i = function SummaryResponseSelect() {
+    const { selections: Error__selections, opaque: Error__opaque, } = select$k();
+    const { selections: Summary__selections, opaque: Summary__opaque, } = select$j();
+    return {
+        kind: 'Fragment',
+        version: VERSION$d,
+        private: [],
+        selections: [
+            {
+                name: 'error',
+                kind: 'Object',
+                selections: Error__selections,
+                required: false
+            },
+            {
+                name: 'result',
+                kind: 'Object',
+                selections: Summary__selections
+            }
+        ]
+    };
+};
+function equals$d(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$f(existing_error, incoming_error))) {
+            return false;
+        }
+    }
+    const existing_result = existing.result;
+    const incoming_result = incoming.result;
+    if (!(equals$e(existing_result, incoming_result))) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$c = "18d65084646c870abf335d268675999e";
+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';
+            const referencepath_summaryValidationError = validate$d(obj_summary, path_summary);
+            if (referencepath_summaryValidationError !== null) {
+                let message = 'Object doesn\'t match SummaryResponse (at "' + path_summary + '")\n';
+                message += referencepath_summaryValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        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$h = function GenerateInsightBatchResponseSelect() {
+    const { selections: SummaryResponse__selections, opaque: SummaryResponse__opaque, } = select$i();
+    return {
+        kind: 'Fragment',
+        version: VERSION$c,
+        private: [],
+        selections: [
+            {
+                name: 'batchId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'generatingSummary',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'summary',
+                kind: 'Object',
+                selections: SummaryResponse__selections,
+                required: false
+            },
+            {
+                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 (!(equals$d(existing_summary, incoming_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$g(luvio, params) {
+    return select$h();
+}
+function getResponseCacheKeys$4(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$3(storeKeyMap, luvio, response);
+}
+function ingestSuccess$4(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$g(),
+        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$4(config) {
+    const headers = {};
+    const header_xSfdcSourceapp = config.headers.xSfdcSourceapp;
+    if (header_xSfdcSourceapp !== undefined) {
+        headers['x-sfdc-sourceapp'] = header_xSfdcSourceapp;
+    }
+    const header_xSfdcSourcecontext = config.headers.xSfdcSourcecontext;
+    if (header_xSfdcSourcecontext !== undefined) {
+        headers['x-sfdc-sourcecontext'] = header_xSfdcSourcecontext;
+    }
+    return {
+        baseUri: 'api.salesforce.com',
+        basePath: '/analytics/insights/v1/batches',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$4 = 'createInsightsBatch';
+const createInsightsBatch_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('batchInput', false, 2 /* Body */, 4 /* Unsupported */, true),
+    generateParamConfigMetadata('options', false, 2 /* Body */, 4 /* Unsupported */),
+    generateParamConfigMetadata('xSfdcSourceapp', false, 3 /* Header */, 0 /* String */),
+    generateParamConfigMetadata('xSfdcSourcecontext', false, 3 /* Header */, 0 /* String */),
+];
+const createInsightsBatch_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, createInsightsBatch_ConfigPropertyMetadata);
+const createResourceParams$4 = /*#__PURE__*/ createResourceParams$5(createInsightsBatch_ConfigPropertyMetadata);
+function typeCheckConfig$4(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$5(untrustedConfig, config, createInsightsBatch_ConfigPropertyMetadata);
+    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$j(untrustedConfig_batchInput_item);
+            if (referenceBatchInputValidationError === null) {
+                untrustedConfig_batchInput_array.push(untrustedConfig_batchInput_item);
+            }
+        }
+        config.batchInput = untrustedConfig_batchInput_array;
+    }
+    const untrustedConfig_options = untrustedConfig.options;
+    const referenceBatchOptionsValidationError = validate$g(untrustedConfig_options);
+    if (referenceBatchOptionsValidationError === null) {
+        config.options = untrustedConfig_options;
+    }
+    return config;
+}
+function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$4(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$4(luvio, config, options) {
+    const resourceParams = createResourceParams$4(config);
+    const request = createResourceRequest$4(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$4(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$4(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const createInsightsBatchAdapterFactory = (luvio) => {
+    return function createInsightsBatch(untrustedConfig) {
+        const config = validateAdapterConfig$4(untrustedConfig, createInsightsBatch_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "createInsightsBatch"');
+        }
+        return buildNetworkSnapshot$4(luvio, config);
+    };
+};
+
+const VERSION$b = "f898ff84f82ad0ca1eca0045e17ce492";
+function validate$b(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$f = function GetFilterValuesResponse_CategoricalValuesSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$b,
+        private: [],
+        selections: [
+            {
+                name: 'values',
+                kind: 'Scalar',
+                plural: true,
+                required: false
+            }
+        ]
+    };
+};
+function equals$b(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$a = "2025bbf393050a10fae76d5b4d5d0f58";
+function validate$a(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$b(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$2 = 'GetFilterValuesResponse';
+function keyBuilder$4(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$2 + ':' + config.filterpageid;
+}
+function keyBuilderFromType$2(luvio, object) {
+    const keyParams = {
+        filterpageid: object.id
+    };
+    return keyBuilder$4(luvio, keyParams);
+}
+function normalize$2(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$e = function GetFilterValuesResponseSelect() {
+    const { selections: GetFilterValuesResponse_CategoricalValues__selections, opaque: GetFilterValuesResponse_CategoricalValues__opaque, } = select$f();
+    return {
+        kind: 'Fragment',
+        version: VERSION$a,
+        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$a(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$b(existing_categoricalValues, incoming_categoricalValues))) {
+        return false;
+    }
+    return true;
+}
+const ingest$2 = function GetFilterValuesResponseIngest(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$d(luvio, params) {
+    return select$e();
+}
+function getResponseCacheKeys$3(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$2(storeKeyMap, luvio, response);
+}
+function ingestSuccess$3(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$d(),
+        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 = {};
+    const header_xSfdcSourceapp = config.headers.xSfdcSourceapp;
+    if (header_xSfdcSourceapp !== undefined) {
+        headers['x-sfdc-sourceapp'] = header_xSfdcSourceapp;
+    }
+    const header_xSfdcSourcecontext = config.headers.xSfdcSourcecontext;
+    if (header_xSfdcSourcecontext !== undefined) {
+        headers['x-sfdc-sourcecontext'] = header_xSfdcSourcecontext;
+    }
+    return {
+        baseUri: 'api.salesforce.com',
+        basePath: '/analytics/insights/v1/filterValues',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$3 = 'getMetricFilterValues';
+const getMetricFilterValues_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('semanticDataModel', true, 2 /* Body */, 4 /* Unsupported */),
+    generateParamConfigMetadata('field', true, 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),
+    generateParamConfigMetadata('semanticFilter', false, 2 /* Body */, 4 /* Unsupported */),
+    generateParamConfigMetadata('xSfdcSourceapp', false, 3 /* Header */, 0 /* String */),
+    generateParamConfigMetadata('xSfdcSourcecontext', false, 3 /* Header */, 0 /* String */),
+];
+const getMetricFilterValues_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, getMetricFilterValues_ConfigPropertyMetadata);
+const createResourceParams$3 = /*#__PURE__*/ createResourceParams$5(getMetricFilterValues_ConfigPropertyMetadata);
+function typeCheckConfig$3(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$5(untrustedConfig, config, getMetricFilterValues_ConfigPropertyMetadata);
+    const untrustedConfig_semanticDataModel = untrustedConfig.semanticDataModel;
+    const referenceSemanticDataModelValidationError = validate$s(untrustedConfig_semanticDataModel);
+    if (referenceSemanticDataModelValidationError === null) {
+        config.semanticDataModel = untrustedConfig_semanticDataModel;
+    }
+    const untrustedConfig_field = untrustedConfig.field;
+    const referenceFieldIdValidationError = validate$B(untrustedConfig_field);
+    if (referenceFieldIdValidationError === null) {
+        config.field = untrustedConfig_field;
+    }
+    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$y(untrustedConfig_filters_item);
+            if (referenceFilterValidationError === null) {
+                untrustedConfig_filters_array.push(untrustedConfig_filters_item);
+            }
+        }
+        config.filters = untrustedConfig_filters_array;
+    }
+    const untrustedConfig_semanticFilter = untrustedConfig.semanticFilter;
+    const referenceFlattenFilterValidationError = validate$w(untrustedConfig_semanticFilter);
+    if (referenceFlattenFilterValidationError === null) {
+        config.semanticFilter = untrustedConfig_semanticFilter;
+    }
+    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 getMetricFilterValuesAdapterFactory = (luvio) => {
+    return function getMetricFilterValues(untrustedConfig) {
+        const config = validateAdapterConfig$3(untrustedConfig, getMetricFilterValues_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "getMetricFilterValues"');
+        }
+        return buildNetworkSnapshot$3(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$c = 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 = "be7014b0043386672b06a22807d7e549";
+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 (obj_facts === undefined) {
+                return new TypeError('Expected "defined" 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.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 (obj_viz === undefined) {
+                return new TypeError('Expected "defined" but received "' + typeof obj_viz + '" (at "' + path_viz + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$b = function InsightSelect() {
+    const { selections: InsightFeedbackMetadata__selections, opaque: InsightFeedbackMetadata__opaque, } = select$c();
+    return {
+        kind: 'Fragment',
+        version: VERSION$8,
+        private: [],
+        selections: [
+            {
+                name: 'characterization',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'facts',
+                kind: 'Object',
+                // any
+            },
+            {
+                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
+            },
+            {
+                name: 'viz',
+                kind: 'Object',
+                // any
+            }
+        ]
+    };
+};
+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;
+        }
+        if (JSONStringify(incoming_facts) !== JSONStringify(existing_facts)) {
+            return false;
+        }
+    }
+    const existing_insightFeedbackMetadata = existing.insightFeedbackMetadata;
+    const incoming_insightFeedbackMetadata = incoming.insightFeedbackMetadata;
+    if (!(equals$9(existing_insightFeedbackMetadata, incoming_insightFeedbackMetadata))) {
+        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;
+        }
+        if (JSONStringify(incoming_viz) !== JSONStringify(existing_viz)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const VERSION$7 = "09a140bdbc97294bdce2b9555910f209";
+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$f(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 + '")');
+            }
+        }
+        if (obj.result !== undefined) {
+            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$a = function InsightResponseSelect() {
+    const { selections: Error__selections, opaque: Error__opaque, } = select$k();
+    const { selections: Insight__selections, opaque: Insight__opaque, } = select$b();
+    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,
+                required: false
+            }
+        ]
+    };
+};
+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$f(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 (!(equals$8(existing_result, incoming_result))) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const VERSION$6 = "bbba5f281b443221e96fa2e9e8eae2d9";
+function validate$6(obj, path = 'Status') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.qualifier !== undefined) {
+            const obj_qualifier = obj.qualifier;
+            const path_qualifier = path + '.qualifier';
+            if (typeof obj_qualifier !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_qualifier + '" (at "' + path_qualifier + '")');
+            }
+        }
+        if (obj.sentiment !== undefined) {
+            const obj_sentiment = obj.sentiment;
+            const path_sentiment = path + '.sentiment';
+            if (typeof obj_sentiment !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_sentiment + '" (at "' + path_sentiment + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$9 = function StatusSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$6,
+        private: [],
+        selections: [
+            {
+                name: 'qualifier',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'sentiment',
+                kind: 'Scalar',
+                required: false
+            }
+        ]
+    };
+};
+function equals$6(existing, incoming) {
+    const existing_qualifier = existing.qualifier;
+    const incoming_qualifier = incoming.qualifier;
+    // if at least one of these optionals is defined
+    if (existing_qualifier !== undefined || incoming_qualifier !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_qualifier === undefined || incoming_qualifier === undefined) {
+            return false;
+        }
+        if (!(existing_qualifier === incoming_qualifier)) {
+            return false;
+        }
+    }
+    const existing_sentiment = existing.sentiment;
+    const incoming_sentiment = incoming.sentiment;
+    // if at least one of these optionals is defined
+    if (existing_sentiment !== undefined || incoming_sentiment !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_sentiment === undefined || incoming_sentiment === undefined) {
+            return false;
+        }
+        if (!(existing_sentiment === incoming_sentiment)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const VERSION$5 = "b8ee380c83f9ec2fff1e8045ba2301fc";
+function validate$5(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.status !== undefined) {
+            const obj_status = obj.status;
+            const path_status = path + '.status';
+            const referencepath_statusValidationError = validate$6(obj_status, path_status);
+            if (referencepath_statusValidationError !== null) {
+                let message = 'Object doesn\'t match Status (at "' + path_status + '")\n';
+                message += referencepath_statusValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.viz !== undefined) {
+            const obj_viz = obj.viz;
+            const path_viz = path + '.viz';
+            if (obj_viz === undefined) {
+                return new TypeError('Expected "defined" but received "' + typeof obj_viz + '" (at "' + path_viz + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$8 = function OverviewSelect() {
+    const { selections: Status__selections, opaque: Status__opaque, } = select$9();
+    return {
+        kind: 'Fragment',
+        version: VERSION$5,
+        private: [],
+        selections: [
+            {
+                name: 'status',
+                kind: 'Object',
+                selections: Status__selections,
+                required: false
+            },
+            {
+                name: 'viz',
+                kind: 'Object',
+                // any
+            }
+        ]
+    };
+};
+function equals$5(existing, incoming) {
+    const existing_status = existing.status;
+    const incoming_status = incoming.status;
+    // if at least one of these optionals is defined
+    if (existing_status !== undefined || incoming_status !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_status === undefined || incoming_status === undefined) {
+            return false;
+        }
+        if (!(equals$6(existing_status, incoming_status))) {
+            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;
+        }
+        if (JSONStringify(incoming_viz) !== JSONStringify(existing_viz)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const VERSION$4 = "ff01bfcbb0b2877fe279be648aceb371";
+function validate$4(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$f(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.result !== undefined) {
+            const obj_result = obj.result;
+            const path_result = path + '.result';
+            const referencepath_resultValidationError = validate$5(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$k();
+    const { selections: Overview__selections, opaque: Overview__opaque, } = select$8();
+    return {
+        kind: 'Fragment',
+        version: VERSION$4,
+        private: [],
+        selections: [
+            {
+                name: 'error',
+                kind: 'Object',
+                selections: Error__selections,
+                required: false
+            },
+            {
+                name: 'result',
+                kind: 'Object',
+                selections: Overview__selections,
+                required: false
+            }
+        ]
+    };
+};
+function equals$4(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$f(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 (!(equals$5(existing_result, incoming_result))) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const VERSION$3 = "a70a5e68e786c3f38efb73cc0812d394";
+function validate$3(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$f(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$4(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$k();
+    const { selections: InsightResponse__selections, opaque: InsightResponse__opaque, } = select$a();
+    const { selections: OverviewResponse__selections, opaque: OverviewResponse__opaque, } = select$7();
+    return {
+        kind: 'Fragment',
+        version: VERSION$3,
+        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$3(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$f(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$4(existing_overviews_item, incoming_overviews_item))) {
+                return false;
+            }
+        });
+        if (equals_overviews_items === false) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const VERSION$2 = "ccf83d258110a04c1949592c91b69b3b";
+function validate$2(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$3(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$2,
+        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$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_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$3(existing_insightGroups_item, incoming_insightGroups_item))) {
+                return false;
+            }
+        });
+        if (equals_insightGroups_items === false) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const VERSION$1 = "5da3ddbbd8ef8f7b1f24b4d609f91108";
+function validate$1(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$f(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.measurementPeriod !== undefined) {
+            const obj_measurementPeriod = obj.measurementPeriod;
+            const path_measurementPeriod = path + '.measurementPeriod';
+            const referencepath_measurementPeriodValidationError = validate$l(obj_measurementPeriod, path_measurementPeriod);
+            if (referencepath_measurementPeriodValidationError !== null) {
+                let message = 'Object doesn\'t match UnifiedFilter (at "' + path_measurementPeriod + '")\n';
+                message += referencepath_measurementPeriodValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.result !== undefined) {
+            const obj_result = obj.result;
+            const path_result = path + '.result';
+            const referencepath_resultValidationError = validate$2(obj_result, path_result);
+            if (referencepath_resultValidationError !== null) {
+                let message = 'Object doesn\'t match InsightBundle (at "' + path_result + '")\n';
+                message += referencepath_resultValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_sdm = obj.sdm;
+        const path_sdm = path + '.sdm';
+        if (typeof obj_sdm !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_sdm + '" (at "' + path_sdm + '")');
+        }
+        const obj_submetric = obj.submetric;
+        const path_submetric = path + '.submetric';
+        if (typeof obj_submetric !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_submetric + '" (at "' + path_submetric + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$1 = 'GenerateInsightBundleResponse';
+function keyBuilder$3(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$1 + ':' + config.metricid;
+}
+function keyBuilderFromType$1(luvio, object) {
+    const keyParams = {
+        metricid: object.submetric
+    };
+    return keyBuilder$3(luvio, keyParams);
+}
+function normalize$1(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$4 = function GenerateInsightBundleResponseSelect() {
+    const { selections: Error__selections, opaque: Error__opaque, } = select$k();
+    const { selections: UnifiedFilter__selections, opaque: UnifiedFilter__opaque, } = select$l();
+    const { selections: InsightBundle__selections, opaque: InsightBundle__opaque, } = select$5();
+    return {
+        kind: 'Fragment',
+        version: VERSION$1,
+        private: [],
+        selections: [
+            {
+                name: 'error',
+                kind: 'Object',
+                selections: Error__selections,
+                required: false
+            },
+            {
+                name: 'measurementPeriod',
+                kind: 'Object',
+                selections: UnifiedFilter__selections,
+                required: false
+            },
+            {
+                name: 'result',
+                kind: 'Object',
+                selections: InsightBundle__selections,
+                required: false
+            },
+            {
+                name: 'sdm',
+                kind: 'Scalar'
+            },
+            {
+                name: 'submetric',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$1(existing, incoming) {
+    const existing_sdm = existing.sdm;
+    const incoming_sdm = incoming.sdm;
+    if (!(existing_sdm === incoming_sdm)) {
+        return false;
+    }
+    const existing_submetric = existing.submetric;
+    const incoming_submetric = incoming.submetric;
+    if (!(existing_submetric === incoming_submetric)) {
+        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$f(existing_error, incoming_error))) {
+            return false;
+        }
+    }
+    const existing_measurementPeriod = existing.measurementPeriod;
+    const incoming_measurementPeriod = incoming.measurementPeriod;
+    // if at least one of these optionals is defined
+    if (existing_measurementPeriod !== undefined || incoming_measurementPeriod !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_measurementPeriod === undefined || incoming_measurementPeriod === undefined) {
+            return false;
+        }
+        if (!(equals$g(existing_measurementPeriod, incoming_measurementPeriod))) {
+            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 (!(equals$2(existing_result, incoming_result))) {
+            return false;
+        }
+    }
+    return true;
+}
+const ingest$1 = function GenerateInsightBundleResponseIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$1(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$1, RepresentationType$1, equals$1);
+    return createLink(key);
+};
+function getTypeCacheKeys$1(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$1(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$1,
+        mergeable: false
+    });
+}
+
+function select$3(luvio, params) {
+    return select$4();
+}
+function getResponseCacheKeys$2(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$1(storeKeyMap, luvio, response);
+}
+function ingestSuccess$2(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$1(luvio, body);
+    luvio.storeIngest(key, ingest$1, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$3(),
+        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 = {};
+    const header_xSfdcSourceapp = config.headers.xSfdcSourceapp;
+    if (header_xSfdcSourceapp !== undefined) {
+        headers['x-sfdc-sourceapp'] = header_xSfdcSourceapp;
+    }
+    const header_xSfdcSourcecontext = config.headers.xSfdcSourcecontext;
+    if (header_xSfdcSourcecontext !== undefined) {
+        headers['x-sfdc-sourcecontext'] = header_xSfdcSourcecontext;
+    }
+    return {
+        baseUri: 'api.salesforce.com',
+        basePath: '/analytics/insights/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 */),
+    generateParamConfigMetadata('xSfdcSourceapp', false, 3 /* Header */, 0 /* String */),
+    generateParamConfigMetadata('xSfdcSourcecontext', false, 3 /* Header */, 0 /* String */),
+];
+const generateInsights_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, generateInsights_ConfigPropertyMetadata);
+const createResourceParams$2 = /*#__PURE__*/ createResourceParams$5(generateInsights_ConfigPropertyMetadata);
+function typeCheckConfig$2(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$5(untrustedConfig, config, generateInsights_ConfigPropertyMetadata);
+    const untrustedConfig_input = untrustedConfig.input;
+    const referenceInsightBundleInputValidationError = validate$m(untrustedConfig_input);
+    if (referenceInsightBundleInputValidationError === null) {
+        config.input = untrustedConfig_input;
+    }
+    const untrustedConfig_options = untrustedConfig.options;
+    const referenceInsightBundleOptionsValidationError = validate$i(untrustedConfig_options);
+    if (referenceInsightBundleOptionsValidationError === null) {
+        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);
+    };
+};
+
+function select$2(luvio, params) {
+    return select$4();
+}
+function getResponseCacheKeys$1(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$1(storeKeyMap, luvio, response);
+}
+function ingestSuccess$1(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$1(luvio, body);
+    luvio.storeIngest(key, ingest$1, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$2(),
+        variables: {},
+    });
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
+}
+function createResourceRequest$1(config) {
+    const headers = {};
+    const header_xSfdcSourceapp = config.headers.xSfdcSourceapp;
+    if (header_xSfdcSourceapp !== undefined) {
+        headers['x-sfdc-sourceapp'] = header_xSfdcSourceapp;
+    }
+    const header_xSfdcSourcecontext = config.headers.xSfdcSourcecontext;
+    if (header_xSfdcSourcecontext !== undefined) {
+        headers['x-sfdc-sourcecontext'] = header_xSfdcSourcecontext;
+    }
+    return {
+        baseUri: 'api.salesforce.com',
+        basePath: '/analytics/insights/v1/basic/generateBundle',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$1 = 'generateInsightsBasic';
+const generateInsightsBasic_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 */),
+    generateParamConfigMetadata('xSfdcSourceapp', false, 3 /* Header */, 0 /* String */),
+    generateParamConfigMetadata('xSfdcSourcecontext', false, 3 /* Header */, 0 /* String */),
+];
+const generateInsightsBasic_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, generateInsightsBasic_ConfigPropertyMetadata);
+const createResourceParams$1 = /*#__PURE__*/ createResourceParams$5(generateInsightsBasic_ConfigPropertyMetadata);
+function typeCheckConfig$1(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$5(untrustedConfig, config, generateInsightsBasic_ConfigPropertyMetadata);
+    const untrustedConfig_input = untrustedConfig.input;
+    const referenceInsightBundleInputValidationError = validate$m(untrustedConfig_input);
+    if (referenceInsightBundleInputValidationError === null) {
+        config.input = untrustedConfig_input;
+    }
+    const untrustedConfig_options = untrustedConfig.options;
+    const referenceInsightBundleOptionsValidationError = validate$i(untrustedConfig_options);
+    if (referenceInsightBundleOptionsValidationError === null) {
+        config.options = untrustedConfig_options;
+    }
+    return config;
+}
+function validateAdapterConfig$1(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$1(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$1(luvio, config, options) {
+    const resourceParams = createResourceParams$1(config);
+    const request = createResourceRequest$1(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$1(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$1(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const generateInsightsBasicAdapterFactory = (luvio) => {
+    return function generateInsightsBasic(untrustedConfig) {
+        const config = validateAdapterConfig$1(untrustedConfig, generateInsightsBasic_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "generateInsightsBasic"');
+        }
+        return buildNetworkSnapshot$1(luvio, config);
+    };
+};
+
+const TTL = 5000;
+const VERSION = "b3ecf416df1c88948a22534e1143e6d5";
+function validate(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 + ']';
+                if (typeof obj_bundles_item !== 'object' || Array.isArray(obj_bundles_item)) {
+                    return new TypeError('Expected "object" but received "' + typeof obj_bundles_item + '" (at "' + path_bundles_item + '")');
+                }
+            }
+        }
+        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.status !== undefined) {
+            const obj_status = obj.status;
+            const path_status = path + '.status';
+            if (typeof obj_status !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_status + '" (at "' + path_status + '")');
+            }
+        }
+        if (obj.summary !== undefined) {
+            const obj_summary = obj.summary;
+            const path_summary = path + '.summary';
+            const referencepath_summaryValidationError = validate$d(obj_summary, path_summary);
+            if (referencepath_summaryValidationError !== null) {
+                let message = 'Object doesn\'t match SummaryResponse (at "' + path_summary + '")\n';
+                message += referencepath_summaryValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType = 'GetInsightBatchResponse';
+function keyBuilder$2(luvio, config) {
+    return keyPrefix + '::' + RepresentationType + ':' + config.batchid;
+}
+function keyBuilderFromType(luvio, object) {
+    const keyParams = {
+        batchid: object.batchId
+    };
+    return keyBuilder$2(luvio, keyParams);
+}
+function normalize(input, existing, path, luvio, store, timestamp) {
+    const input_bundles = input.bundles;
+    const input_bundles_id = path.fullPath + '__bundles';
+    if (input_bundles !== undefined) {
+        for (let i = 0; i < input_bundles.length; i++) {
+            const input_bundles_item = input_bundles[i];
+            let input_bundles_item_id = input_bundles_id + '__' + i;
+            input_bundles[i] = ingest$1(input_bundles_item, {
+                fullPath: input_bundles_item_id,
+                propertyName: i,
+                parent: {
+                    data: input,
+                    key: path.fullPath,
+                    existing: existing,
+                },
+                ttl: path.ttl
+            }, luvio, store, timestamp);
+        }
+    }
+    return input;
+}
+const select$1 = function GetInsightBatchResponseSelect() {
+    const { selections: SummaryResponse__selections, opaque: SummaryResponse__opaque, } = select$i();
+    return {
+        kind: 'Fragment',
+        version: VERSION,
+        private: [],
+        selections: [
+            {
+                name: 'batchId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'bundles',
+                kind: 'Link',
+                plural: true,
+                required: false,
+                fragment: select$4()
+            },
+            {
+                name: 'hasErrors',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'status',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'summary',
+                kind: 'Object',
+                selections: SummaryResponse__selections,
+                required: false
+            }
+        ]
+    };
+};
+function equals(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_status = existing.status;
+    const incoming_status = incoming.status;
+    // if at least one of these optionals is defined
+    if (existing_status !== undefined || incoming_status !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_status === undefined || incoming_status === undefined) {
+            return false;
+        }
+        if (!(existing_status === incoming_status)) {
+            return false;
+        }
+    }
+    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 (!(existing_bundles_item.__ref === incoming_bundles_item.__ref)) {
+                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 (!(equals$d(existing_summary, incoming_summary))) {
+            return false;
+        }
+    }
+    return true;
+}
+const ingest = function GetInsightBatchResponseIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType(luvio, input);
+    const ttlToUse = TTL;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize, "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
+    });
+    if (input.bundles !== undefined) {
+        const input_bundles_length = input.bundles.length;
+        for (let i = 0; i < input_bundles_length; i++) {
+            getTypeCacheKeys$1(rootKeySet, luvio, input.bundles[i]);
+        }
+    }
+}
+
+function select(luvio, params) {
+    return select$1();
+}
+function keyBuilder$1(luvio, params) {
+    return keyBuilder$2(luvio, {
+        batchid: params.urlParams.batchId
+    });
+}
+function getResponseCacheKeys(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys(storeKeyMap, luvio, response);
+}
+function ingestSuccess(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$1(luvio, resourceParams);
+    luvio.storeIngest(key, ingest, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select(),
+        variables: {},
+    }, snapshotRefresh);
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
+}
+function ingestError(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$1(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    const storeMetadataParams = {
+        ttl: TTL,
+        namespace: keyPrefix,
+        version: VERSION,
+        representationName: RepresentationType
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
+function createResourceRequest(config) {
+    const headers = {};
+    const header_xSfdcSourceapp = config.headers.xSfdcSourceapp;
+    if (header_xSfdcSourceapp !== undefined) {
+        headers['x-sfdc-sourceapp'] = header_xSfdcSourceapp;
+    }
+    const header_xSfdcSourcecontext = config.headers.xSfdcSourcecontext;
+    if (header_xSfdcSourcecontext !== undefined) {
+        headers['x-sfdc-sourcecontext'] = header_xSfdcSourcecontext;
+    }
+    return {
+        baseUri: 'api.salesforce.com',
+        basePath: '/analytics/insights/v1/batches/' + config.urlParams.batchId + '',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName = 'getInsightsBatch';
+const getInsightsBatch_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('batchId', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('xSfdcSourceapp', false, 3 /* Header */, 0 /* String */),
+    generateParamConfigMetadata('xSfdcSourcecontext', false, 3 /* Header */, 0 /* String */),
+];
+const getInsightsBatch_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, getInsightsBatch_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$5(getInsightsBatch_ConfigPropertyMetadata);
+function keyBuilder(luvio, config) {
+    const resourceParams = createResourceParams(config);
+    return keyBuilder$1(luvio, resourceParams);
+}
+function typeCheckConfig(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$5(untrustedConfig, config, getInsightsBatch_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment(luvio, config) {
+    createResourceParams(config);
+    return select();
+}
+function onFetchResponseSuccess(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError(luvio, config, resourceParams, response) {
+    const snapshot = ingestError(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot(luvio, config, options) {
+    const resourceParams = createResourceParams(config);
+    const request = createResourceRequest(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess(luvio, config, resourceParams, response), () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext, buildNetworkSnapshot, undefined, false);
+}
+function buildCachedSnapshotCachePolicy(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder(luvio, config),
+        node: adapterFragment(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getInsightsBatchAdapterFactory = (luvio) => function analyticsInsights__getInsightsBatch(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig(untrustedConfig, getInsightsBatch_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
+};
+
+export { createInsightsBatchAdapterFactory, generateInsightsAdapterFactory, generateInsightsBasicAdapterFactory, getInsightsBatchAdapterFactory, getMetricFilterValuesAdapterFactory };