@salesforce/lds-adapters-sfap-analytics-insights 1.304.0 → 1.306.0

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

@@ -92,2431 +92,1616 @@ function createLink(ref) {
     };
 }
 
-const VERSION$c = "07a8c889542dbad6f958515513d4e3fb";
-function validate$w(obj, path = 'Error') {
+function validate$s(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.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.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.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 + '")');
+        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;
 }
-const select$g = function ErrorSelect() {
-    return {
-        kind: 'Fragment',
-        version: VERSION$c,
-        private: [],
-        selections: [
-            {
-                name: 'code',
-                kind: 'Scalar',
-                required: false
-            },
-            {
-                name: 'message',
-                kind: 'Scalar',
-                required: false
+
+function validate$r(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 + '")');
+                }
             }
-        ]
-    };
-};
-function equals$c(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;
+        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 + '")');
+            }
         }
-    }
-    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;
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$q(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 (!(existing_message === incoming_message)) {
-            return false;
+        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 + '")');
+            }
         }
-    }
-    return true;
+        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 VERSION$b = "e64bc88a0a4f11fcf5a12538b4b51a87";
-function validate$v(obj, path = 'GenerateInsightBundleResponse') {
+function validate$p(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.error !== undefined) {
-            const obj_error = obj.error;
-            const path_error = path + '.error';
-            const referencepath_errorValidationError = validate$w(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.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$q(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);
+                }
             }
         }
-        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 + '")');
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$o(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.result !== undefined) {
-            const obj_result = obj.result;
-            const path_result = path + '.result';
-            if (obj_result === undefined) {
-                return new TypeError('Expected "defined" but received "' + typeof obj_result + '" (at "' + path_result + '")');
+        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;
 }
-const RepresentationType$3 = 'GenerateInsightBundleResponse';
-function keyBuilder$5(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$3 + ':' + config.bundleresponseid;
-}
-function keyBuilderFromType$3(luvio, object) {
-    const keyParams = {
-        bundleresponseid: object.id
-    };
-    return keyBuilder$5(luvio, keyParams);
-}
-function normalize$3(input, existing, path, luvio, store, timestamp) {
-    return input;
+
+function validate$n(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;
 }
-const select$f = function GenerateInsightBundleResponseSelect() {
-    const { selections: Error__selections, opaque: Error__opaque, } = select$g();
-    return {
-        kind: 'Fragment',
-        version: VERSION$b,
-        private: [],
-        selections: [
-            {
-                name: 'error',
-                kind: 'Object',
-                selections: Error__selections,
-                required: false
-            },
-            {
-                name: 'id',
-                kind: 'Scalar'
-            },
-            {
-                name: 'result',
-                kind: 'Object',
-                // any
+
+function validate$m(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 + '")');
             }
-        ]
-    };
-};
-function equals$b(existing, incoming) {
-    const existing_id = existing.id;
-    const incoming_id = incoming.id;
-    if (!(existing_id === incoming_id)) {
-        return false;
-    }
-    const existing_error = existing.error;
-    const incoming_error = incoming.error;
-    // if at least one of these optionals is defined
-    if (existing_error !== undefined || incoming_error !== undefined) {
-        // if one of these is not defined we know the other is defined and therefore
-        // not equal
-        if (existing_error === undefined || incoming_error === undefined) {
-            return false;
         }
-        if (!(equals$c(existing_error, incoming_error))) {
-            return false;
+        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 + '")');
+            }
         }
-    }
-    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 (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 (JSONStringify(incoming_result) !== JSONStringify(existing_result)) {
-            return false;
+        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 + '")');
+            }
         }
-    }
-    return true;
+        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;
 }
-const ingest$3 = function GenerateInsightBundleResponseIngest(input, path, luvio, store, timestamp) {
-    if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$v(input);
-        if (validateError !== null) {
-            throw validateError;
+
+function validate$l(obj, path = 'RelativeDate') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
         }
-    }
-    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$b, RepresentationType$3, equals$b);
-    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$e(luvio, params) {
-    return select$f();
-}
-function getResponseCacheKeys$3(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$3(storeKeyMap, luvio, response);
-}
-function ingestSuccess$3(luvio, resourceParams, response) {
-    const { body } = response;
-    const key = keyBuilderFromType$3(luvio, body);
-    luvio.storeIngest(key, ingest$3, body);
-    const snapshot = luvio.storeLookup({
-        recordId: key,
-        node: select$e(),
-        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');
+        if (obj.periodType !== undefined) {
+            const obj_periodType = obj.periodType;
+            const path_periodType = path + '.periodType';
+            if (typeof obj_periodType !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_periodType + '" (at "' + path_periodType + '")');
+            }
         }
-    }
-    deepFreeze(snapshot.data);
-    return snapshot;
-}
-function createResourceRequest$3(config) {
-    const headers = {};
-    return {
-        baseUri: 'api.salesforce.com',
-        basePath: '/analytics/tua-insights-service/v1/generateBundle',
-        method: 'post',
-        body: config.body,
-        urlParams: {},
-        queryParams: {},
-        headers,
-        priority: 'normal',
-    };
-}
-
-const adapterName$3 = 'generateInsights';
-const generateInsights_ConfigPropertyMetadata = [
-    generateParamConfigMetadata('type', false, 2 /* Body */, 0 /* String */),
-    generateParamConfigMetadata('version', false, 2 /* Body */, 3 /* Integer */),
-    generateParamConfigMetadata('input', false, 2 /* Body */, 4 /* Unsupported */),
-    generateParamConfigMetadata('options', false, 2 /* Body */, 4 /* Unsupported */),
-];
-const generateInsights_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, generateInsights_ConfigPropertyMetadata);
-const createResourceParams$3 = /*#__PURE__*/ createResourceParams$4(generateInsights_ConfigPropertyMetadata);
-function typeCheckConfig$3(untrustedConfig) {
-    const config = {};
-    typeCheckConfig$4(untrustedConfig, config, generateInsights_ConfigPropertyMetadata);
-    const untrustedConfig_input = untrustedConfig.input;
-    config.input = untrustedConfig_input;
-    const untrustedConfig_options = untrustedConfig.options;
-    config.options = untrustedConfig_options;
-    return config;
-}
-function validateAdapterConfig$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 generateInsightsAdapterFactory = (luvio) => {
-    return function generateInsights(untrustedConfig) {
-        const config = validateAdapterConfig$3(untrustedConfig, generateInsights_ConfigPropertyNames);
-        // Invalid or incomplete config
-        if (config === null) {
-            throw new Error('Invalid config for "generateInsights"');
+        if (obj.rangeN !== undefined) {
+            const obj_rangeN = obj.rangeN;
+            const path_rangeN = path + '.rangeN';
+            if (typeof obj_rangeN !== 'number' || (typeof obj_rangeN === 'number' && Math.floor(obj_rangeN) !== obj_rangeN)) {
+                return new TypeError('Expected "integer" but received "' + typeof obj_rangeN + '" (at "' + path_rangeN + '")');
+            }
         }
-        return buildNetworkSnapshot$3(luvio, config);
-    };
-};
+        if (obj.rangeType !== undefined) {
+            const obj_rangeType = obj.rangeType;
+            const path_rangeType = path + '.rangeType';
+            if (typeof obj_rangeType !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_rangeType + '" (at "' + path_rangeType + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
 
-function validate$u(obj, path = 'SemanticDataModel') {
+function validate$k(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 + '")');
         }
-        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 + '")');
+        if (obj.anchorDate !== undefined) {
+            const obj_anchorDate = obj.anchorDate;
+            const path_anchorDate = path + '.anchorDate';
+            if (typeof obj_anchorDate !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_anchorDate + '" (at "' + path_anchorDate + '")');
             }
         }
+        const obj_max = obj.max;
+        const path_max = path + '.max';
+        const referencepath_maxValidationError = validate$l(obj_max, path_max);
+        if (referencepath_maxValidationError !== null) {
+            let message = 'Object doesn\'t match RelativeDate (at "' + path_max + '")\n';
+            message += referencepath_maxValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_min = obj.min;
+        const path_min = path + '.min';
+        const referencepath_minValidationError = validate$l(obj_min, path_min);
+        if (referencepath_minValidationError !== null) {
+            let message = 'Object doesn\'t match RelativeDate (at "' + path_min + '")\n';
+            message += referencepath_minValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
     })();
     return v_error === undefined ? null : v_error;
 }
 
-function validate$t(obj, path = 'TableField') {
+function validate$j(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.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 + '")');
-            }
+        const obj_categoricalFilterOptions = obj.categoricalFilterOptions;
+        const path_categoricalFilterOptions = path + '.categoricalFilterOptions';
+        const referencepath_categoricalFilterOptionsValidationError = validate$o(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);
+        }
+        const obj_field = obj.field;
+        const path_field = path + '.field';
+        const referencepath_fieldValidationError = validate$n(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);
+        }
+        const obj_rangeFilterOptions = obj.rangeFilterOptions;
+        const path_rangeFilterOptions = path + '.rangeFilterOptions';
+        const referencepath_rangeFilterOptionsValidationError = validate$m(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);
+        }
+        const obj_relativeDateFilterOptions = obj.relativeDateFilterOptions;
+        const path_relativeDateFilterOptions = path + '.relativeDateFilterOptions';
+        const referencepath_relativeDateFilterOptionsValidationError = validate$k(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.tableName !== undefined) {
-            const obj_tableName = obj.tableName;
-            const path_tableName = path + '.tableName';
-            if (typeof obj_tableName !== 'string') {
-                return new TypeError('Expected "string" but received "' + typeof obj_tableName + '" (at "' + path_tableName + '")');
+        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$s(obj, path = 'SemanticField') {
+function validate$i(obj, path = 'MeasurementPeriod') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
         }
-        if (obj.name !== undefined) {
-            const obj_name = obj.name;
-            const path_name = path + '.name';
-            if (typeof obj_name !== 'string') {
-                return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
+        if (obj.filter !== undefined) {
+            const obj_filter = obj.filter;
+            const path_filter = path + '.filter';
+            if (obj_filter === undefined) {
+                return new TypeError('Expected "defined" but received "' + typeof obj_filter + '" (at "' + path_filter + '")');
+            }
+        }
+        if (obj.relativePeriod !== undefined) {
+            const obj_relativePeriod = obj.relativePeriod;
+            const path_relativePeriod = path + '.relativePeriod';
+            if (obj_relativePeriod === undefined) {
+                return new TypeError('Expected "defined" but received "' + typeof obj_relativePeriod + '" (at "' + path_relativePeriod + '")');
             }
         }
     })();
     return v_error === undefined ? null : v_error;
 }
 
-function validate$r(obj, path = 'NullableValue') {
+function validate$h(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.boolean !== undefined) {
-            const obj_boolean = obj.boolean;
-            const path_boolean = path + '.boolean';
-            if (typeof obj_boolean !== 'boolean') {
-                return new TypeError('Expected "boolean" but received "' + typeof obj_boolean + '" (at "' + path_boolean + '")');
+        if (obj.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 + '")');
             }
-        }
-        if (obj.date !== undefined) {
-            const obj_date = obj.date;
-            const path_date = path + '.date';
-            if (typeof obj_date !== 'string') {
-                return new TypeError('Expected "string" but received "' + typeof obj_date + '" (at "' + path_date + '")');
+            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$j(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.nullValue !== undefined) {
-            const obj_nullValue = obj.nullValue;
-            const path_nullValue = path + '.nullValue';
-            if (typeof obj_nullValue !== 'string') {
-                return new TypeError('Expected "string" but received "' + typeof obj_nullValue + '" (at "' + path_nullValue + '")');
-            }
+        const obj_measurementPeriod = obj.measurementPeriod;
+        const path_measurementPeriod = path + '.measurementPeriod';
+        const referencepath_measurementPeriodValidationError = validate$i(obj_measurementPeriod, path_measurementPeriod);
+        if (referencepath_measurementPeriodValidationError !== null) {
+            let message = 'Object doesn\'t match MeasurementPeriod (at "' + path_measurementPeriod + '")\n';
+            message += referencepath_measurementPeriodValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
         }
-        if (obj.number !== undefined) {
-            const obj_number = obj.number;
-            const path_number = path + '.number';
-            if (typeof obj_number !== 'number') {
-                return new TypeError('Expected "number" but received "' + typeof obj_number + '" (at "' + path_number + '")');
-            }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$g(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.string !== undefined) {
-            const obj_string = obj.string;
-            const path_string = path + '.string';
-            if (typeof obj_string !== 'string') {
-                return new TypeError('Expected "string" but received "' + typeof obj_string + '" (at "' + path_string + '")');
+        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$q(obj, path = 'Filter') {
+function validate$f(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.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.aggregation !== undefined) {
+            const obj_aggregation = obj.aggregation;
+            const path_aggregation = path + '.aggregation';
+            if (typeof obj_aggregation !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_aggregation + '" (at "' + path_aggregation + '")');
             }
         }
-        const obj_semanticField = obj.semanticField;
-        const path_semanticField = path + '.semanticField';
-        const referencepath_semanticFieldValidationError = validate$s(obj_semanticField, path_semanticField);
-        if (referencepath_semanticFieldValidationError !== null) {
-            let message = 'Object doesn\'t match SemanticField (at "' + path_semanticField + '")\n';
-            message += referencepath_semanticFieldValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
-            return new TypeError(message);
-        }
-        const obj_tableField = obj.tableField;
-        const path_tableField = path + '.tableField';
-        const referencepath_tableFieldValidationError = validate$t(obj_tableField, path_tableField);
-        if (referencepath_tableFieldValidationError !== null) {
-            let message = 'Object doesn\'t match TableField (at "' + path_tableField + '")\n';
-            message += referencepath_tableFieldValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+        const obj_field = obj.field;
+        const path_field = path + '.field';
+        const referencepath_fieldValidationError = validate$n(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.values !== undefined) {
-            const obj_values = obj.values;
-            const path_values = path + '.values';
-            if (!ArrayIsArray(obj_values)) {
-                return new TypeError('Expected "array" but received "' + typeof obj_values + '" (at "' + path_values + '")');
-            }
-            for (let i = 0; i < obj_values.length; i++) {
-                const obj_values_item = obj_values[i];
-                const path_values_item = path_values + '[' + i + ']';
-                const referencepath_values_itemValidationError = validate$r(obj_values_item, path_values_item);
-                if (referencepath_values_itemValidationError !== null) {
-                    let message = 'Object doesn\'t match NullableValue (at "' + path_values_item + '")\n';
-                    message += referencepath_values_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
-                    return new TypeError(message);
-                }
-            }
-        }
     })();
     return v_error === undefined ? null : v_error;
 }
 
-const VERSION$a = "f898ff84f82ad0ca1eca0045e17ce492";
-function validate$p(obj, path = 'GetFilterValuesResponse_CategoricalValues') {
+function validate$e(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.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);
-                }
+        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;
 }
-const select$d = function GetFilterValuesResponse_CategoricalValuesSelect() {
-    return {
-        kind: 'Fragment',
-        version: VERSION$a,
-        private: [],
-        selections: [
-            {
-                name: 'values',
-                kind: 'Scalar',
-                plural: true,
-                required: false
-            }
-        ]
-    };
-};
-function equals$a(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;
+
+function validate$d(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 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;
+        const obj_field = obj.field;
+        const path_field = path + '.field';
+        const referencepath_fieldValidationError = validate$n(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 true;
+    })();
+    return v_error === undefined ? null : v_error;
 }
 
-const VERSION$9 = "2025bbf393050a10fae76d5b4d5d0f58";
-function validate$o(obj, path = 'GetFilterValuesResponse') {
+function validate$c(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_categoricalValues = obj.categoricalValues;
-        const path_categoricalValues = path + '.categoricalValues';
-        const referencepath_categoricalValuesValidationError = validate$p(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');
+        const obj_comparison = obj.comparison;
+        const path_comparison = path + '.comparison';
+        const referencepath_comparisonValidationError = validate$g(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);
         }
-        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.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$j(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.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 + '")');
+        const obj_measure = obj.measure;
+        const path_measure = path + '.measure';
+        const referencepath_measureValidationError = validate$f(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$e(obj_semanticDataModel, path_semanticDataModel);
+        if (referencepath_semanticDataModelValidationError !== null) {
+            let message = 'Object doesn\'t match SemanticDataModel (at "' + path_semanticDataModel + '")\n';
+            message += referencepath_semanticDataModelValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_timeDimension = obj.timeDimension;
+        const path_timeDimension = path + '.timeDimension';
+        const referencepath_timeDimensionValidationError = validate$d(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;
 }
-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$c = function GetFilterValuesResponseSelect() {
-    const { selections: GetFilterValuesResponse_CategoricalValues__selections, opaque: GetFilterValuesResponse_CategoricalValues__opaque, } = select$d();
-    return {
-        kind: 'Fragment',
-        version: VERSION$9,
-        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 validate$b(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 + '")');
             }
-        ]
-    };
-};
-function equals$9(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;
+        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 + '")');
+            }
         }
-    }
-    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;
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$a(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 + '")');
         }
-        if (!(existing_nextPageToken === incoming_nextPageToken)) {
-            return false;
+        const obj_numberUnits = obj.numberUnits;
+        const path_numberUnits = path + '.numberUnits';
+        const referencepath_numberUnitsValidationError = validate$b(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);
         }
-    }
-    const existing_categoricalValues = existing.categoricalValues;
-    const incoming_categoricalValues = incoming.categoricalValues;
-    if (!(equals$a(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$o(input);
-        if (validateError !== null) {
-            throw validateError;
+        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 + '")');
+            }
         }
-    }
-    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$9, RepresentationType$2, equals$9);
-    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
-    });
+        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 select$b(luvio, params) {
-    return select$c();
-}
-function getResponseCacheKeys$2(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$2(storeKeyMap, luvio, response);
-}
-function ingestSuccess$2(luvio, resourceParams, response) {
-    const { body } = response;
-    const key = keyBuilderFromType$2(luvio, body);
-    luvio.storeIngest(key, ingest$2, body);
-    const snapshot = luvio.storeLookup({
-        recordId: key,
-        node: select$b(),
-        variables: {},
-    });
-    if (process.env.NODE_ENV !== 'production') {
-        if (snapshot.state !== 'Fulfilled') {
-            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+function validate$9(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 + '")');
         }
-    }
-    deepFreeze(snapshot.data);
-    return snapshot;
-}
-function createResourceRequest$2(config) {
-    const headers = {};
-    return {
-        baseUri: 'api.salesforce.com',
-        basePath: '/analytics/tua-insights-service/v1/filterValues',
-        method: 'post',
-        body: config.body,
-        urlParams: {},
-        queryParams: {},
-        headers,
-        priority: 'normal',
-    };
+        const obj_extensionOptions = obj.extensionOptions;
+        const path_extensionOptions = path + '.extensionOptions';
+        const referencepath_extensionOptionsValidationError = validate$r(obj_extensionOptions, path_extensionOptions);
+        if (referencepath_extensionOptionsValidationError !== null) {
+            let message = 'Object doesn\'t match ExtensionOptions (at "' + path_extensionOptions + '")\n';
+            message += referencepath_extensionOptionsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_insightsOptions = obj.insightsOptions;
+        const path_insightsOptions = path + '.insightsOptions';
+        const referencepath_insightsOptionsValidationError = validate$p(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$h(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$c(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$a(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;
 }
 
-const adapterName$2 = 'getMetricFilterValues';
-const getMetricFilterValues_ConfigPropertyMetadata = [
-    generateParamConfigMetadata('semanticDataModel', true, 2 /* Body */, 4 /* Unsupported */),
-    generateParamConfigMetadata('tableField', false, 2 /* Body */, 4 /* Unsupported */),
-    generateParamConfigMetadata('semanticField', false, 2 /* Body */, 4 /* Unsupported */),
-    generateParamConfigMetadata('pageToken', false, 2 /* Body */, 0 /* String */),
-    generateParamConfigMetadata('pageSize', false, 2 /* Body */, 3 /* Integer */),
-    generateParamConfigMetadata('searchTerm', false, 2 /* Body */, 0 /* String */),
-    generateParamConfigMetadata('filters', false, 2 /* Body */, 4 /* Unsupported */, true),
-];
-const getMetricFilterValues_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, getMetricFilterValues_ConfigPropertyMetadata);
-const createResourceParams$2 = /*#__PURE__*/ createResourceParams$4(getMetricFilterValues_ConfigPropertyMetadata);
-function typeCheckConfig$2(untrustedConfig) {
-    const config = {};
-    typeCheckConfig$4(untrustedConfig, config, getMetricFilterValues_ConfigPropertyMetadata);
-    const untrustedConfig_semanticDataModel = untrustedConfig.semanticDataModel;
-    const referenceSemanticDataModelValidationError = validate$u(untrustedConfig_semanticDataModel);
-    if (referenceSemanticDataModelValidationError === null) {
-        config.semanticDataModel = untrustedConfig_semanticDataModel;
-    }
-    const untrustedConfig_tableField = untrustedConfig.tableField;
-    const referenceTableFieldValidationError = validate$t(untrustedConfig_tableField);
-    if (referenceTableFieldValidationError === null) {
-        config.tableField = untrustedConfig_tableField;
-    }
-    const untrustedConfig_semanticField = untrustedConfig.semanticField;
-    const referenceSemanticFieldValidationError = validate$s(untrustedConfig_semanticField);
-    if (referenceSemanticFieldValidationError === null) {
-        config.semanticField = untrustedConfig_semanticField;
-    }
-    const untrustedConfig_filters = untrustedConfig.filters;
-    if (ArrayIsArray$1(untrustedConfig_filters)) {
-        const untrustedConfig_filters_array = [];
-        for (let i = 0, arrayLength = untrustedConfig_filters.length; i < arrayLength; i++) {
-            const untrustedConfig_filters_item = untrustedConfig_filters[i];
-            const referenceFilterValidationError = validate$q(untrustedConfig_filters_item);
-            if (referenceFilterValidationError === null) {
-                untrustedConfig_filters_array.push(untrustedConfig_filters_item);
-            }
+function validate$8(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 + '")');
         }
-        config.filters = untrustedConfig_filters_array;
-    }
-    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;
+        const obj_metadata = obj.metadata;
+        const path_metadata = path + '.metadata';
+        const referencepath_metadataValidationError = validate$s(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$9(obj_metric, path_metric);
+        if (referencepath_metricValidationError !== null) {
+            let message = 'Object doesn\'t match InputMetric (at "' + path_metric + '")\n';
+            message += referencepath_metricValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+    })();
+    return v_error === undefined ? null : v_error;
 }
-function 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;
-    });
+
+function validate$7(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 + '")');
+        }
+        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;
 }
-const getMetricFilterValuesAdapterFactory = (luvio) => {
-    return function getMetricFilterValues(untrustedConfig) {
-        const config = validateAdapterConfig$2(untrustedConfig, getMetricFilterValues_ConfigPropertyNames);
-        // Invalid or incomplete config
-        if (config === null) {
-            throw new Error('Invalid config for "getMetricFilterValues"');
+
+function validate$6(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 + '")');
         }
-        return buildNetworkSnapshot$2(luvio, config);
-    };
-};
+        if (obj.bundleInput !== undefined) {
+            const obj_bundleInput = obj.bundleInput;
+            const path_bundleInput = path + '.bundleInput';
+            const referencepath_bundleInputValidationError = validate$8(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$7(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;
+}
 
-const VERSION$8 = "6b47d2ed35a900956ff58b7d8a527e7f";
-function validate$n(obj, path = 'InsightFeedbackMetadata') {
+const VERSION$5 = "a8b8e8e21e2dc1b5b067efa90209dce3";
+function validate$5(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 + '")');
         }
-        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 + '")');
+        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.score !== undefined) {
-            obj.score;
+        if (obj.summary !== undefined) {
+            const obj_summary = obj.summary;
+            const path_summary = path + '.summary';
+            if (obj_summary === undefined) {
+                return new TypeError('Expected "defined" but received "' + typeof obj_summary + '" (at "' + path_summary + '")');
+            }
         }
-        if (obj.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.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 select$a = function InsightFeedbackMetadataSelect() {
+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$9 = function GenerateInsightBatchResponseSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$8,
+        version: VERSION$5,
         private: [],
         selections: [
             {
-                name: 'dimensionHash',
-                kind: 'Scalar',
-                required: false
+                name: 'batchId',
+                kind: 'Scalar'
             },
             {
-                name: 'score',
+                name: 'generatingSummary',
                 kind: 'Scalar',
                 required: false
             },
             {
-                name: 'type',
+                name: 'summary',
+                kind: 'Object',
+                // any
+            },
+            {
+                name: 'timestamp',
                 kind: 'Scalar',
                 required: false
             }
         ]
     };
 };
-function equals$8(existing, incoming) {
-    const existing_dimensionHash = existing.dimensionHash;
-    const incoming_dimensionHash = incoming.dimensionHash;
+function equals$5(existing, incoming) {
+    const existing_generatingSummary = existing.generatingSummary;
+    const incoming_generatingSummary = incoming.generatingSummary;
     // if at least one of these optionals is defined
-    if (existing_dimensionHash !== undefined || incoming_dimensionHash !== undefined) {
+    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_dimensionHash === undefined || incoming_dimensionHash === undefined) {
+        if (existing_generatingSummary === undefined || incoming_generatingSummary === undefined) {
             return false;
         }
-        if (!(existing_dimensionHash === incoming_dimensionHash)) {
+        if (!(existing_generatingSummary === incoming_generatingSummary)) {
             return false;
         }
     }
-    const existing_type = existing.type;
-    const incoming_type = incoming.type;
+    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_type !== undefined || incoming_type !== undefined) {
+    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_type === undefined || incoming_type === undefined) {
+        if (existing_timestamp === undefined || incoming_timestamp === undefined) {
             return false;
         }
-        if (!(existing_type === incoming_type)) {
+        if (!(existing_timestamp === incoming_timestamp)) {
             return false;
         }
     }
-    const existing_score = existing.score;
-    const incoming_score = incoming.score;
+    const existing_summary = existing.summary;
+    const incoming_summary = incoming.summary;
     // if at least one of these optionals is defined
-    if (existing_score !== undefined || incoming_score !== undefined) {
+    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_score === undefined || incoming_score === undefined) {
+        if (existing_summary === undefined || incoming_summary === undefined) {
             return false;
         }
-        if (!(existing_score === incoming_score)) {
+        if (JSONStringify(incoming_summary) !== JSONStringify(existing_summary)) {
             return false;
         }
     }
     return true;
 }
-
-const VERSION$7 = "b973507f0d8eb5a125451461b0e5cea2";
-function validate$m(obj, path = 'Insight') {
-    const v_error = (() => {
-        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
-            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
-        }
-        if (obj.characterization !== undefined) {
-            const obj_characterization = obj.characterization;
-            const path_characterization = path + '.characterization';
-            if (typeof obj_characterization !== 'string') {
-                return new TypeError('Expected "string" but received "' + typeof obj_characterization + '" (at "' + path_characterization + '")');
-            }
-        }
-        if (obj.facts !== undefined) {
-            const obj_facts = obj.facts;
-            const path_facts = path + '.facts';
-            if (typeof obj_facts !== 'object' || ArrayIsArray(obj_facts) || obj_facts === null) {
-                return new TypeError('Expected "object" but received "' + typeof obj_facts + '" (at "' + path_facts + '")');
-            }
-        }
-        if (obj.id !== undefined) {
-            const obj_id = obj.id;
-            const path_id = path + '.id';
-            if (typeof obj_id !== 'string') {
-                return new TypeError('Expected "string" but received "' + typeof obj_id + '" (at "' + path_id + '")');
-            }
-        }
-        const obj_insightFeedbackMetadata = obj.insightFeedbackMetadata;
-        const path_insightFeedbackMetadata = path + '.insightFeedbackMetadata';
-        const referencepath_insightFeedbackMetadataValidationError = validate$n(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;
+const ingest$3 = function GenerateInsightBatchResponseIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$5(input);
+        if (validateError !== null) {
+            throw validateError;
         }
-        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 + '")');
-            }
+    }
+    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$5, RepresentationType$3, equals$5);
+    return createLink(key);
+};
+function getTypeCacheKeys$3(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$3(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$3,
+        mergeable: false
+    });
+}
+
+function select$8(luvio, params) {
+    return select$9();
+}
+function getResponseCacheKeys$3(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$3(storeKeyMap, luvio, response);
+}
+function ingestSuccess$3(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$3(luvio, body);
+    luvio.storeIngest(key, ingest$3, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$8(),
+        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');
         }
-        if (obj.vegaLiteViz !== undefined) {
-            const obj_vegaLiteViz = obj.vegaLiteViz;
-            const path_vegaLiteViz = path + '.vegaLiteViz';
-            if (typeof obj_vegaLiteViz !== 'object' || ArrayIsArray(obj_vegaLiteViz) || obj_vegaLiteViz === null) {
-                return new TypeError('Expected "object" but received "' + typeof obj_vegaLiteViz + '" (at "' + path_vegaLiteViz + '")');
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
+}
+function createResourceRequest$3(config) {
+    const headers = {};
+    return {
+        baseUri: 'api.salesforce.com',
+        basePath: '/analytics/insights/v1/batches',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$3 = 'createInsightsBatch';
+const createInsightsBatch_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('batchInput', false, 2 /* Body */, 4 /* Unsupported */, true),
+    generateParamConfigMetadata('options', false, 2 /* Body */, 4 /* Unsupported */),
+];
+const createInsightsBatch_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, createInsightsBatch_ConfigPropertyMetadata);
+const createResourceParams$3 = /*#__PURE__*/ createResourceParams$4(createInsightsBatch_ConfigPropertyMetadata);
+function typeCheckConfig$3(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_batchInput = untrustedConfig.batchInput;
+    if (ArrayIsArray$1(untrustedConfig_batchInput)) {
+        const untrustedConfig_batchInput_array = [];
+        for (let i = 0, arrayLength = untrustedConfig_batchInput.length; i < arrayLength; i++) {
+            const untrustedConfig_batchInput_item = untrustedConfig_batchInput[i];
+            const referenceBatchInputValidationError = validate$6(untrustedConfig_batchInput_item);
+            if (referenceBatchInputValidationError === null) {
+                untrustedConfig_batchInput_array.push(untrustedConfig_batchInput_item);
             }
         }
-        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 + '")');
-            }
+        config.batchInput = untrustedConfig_batchInput_array;
+    }
+    const untrustedConfig_options = untrustedConfig.options;
+    config.options = untrustedConfig_options;
+    return config;
+}
+function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$3(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$3(luvio, config, options) {
+    const resourceParams = createResourceParams$3(config);
+    const request = createResourceRequest$3(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$3(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$3(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const createInsightsBatchAdapterFactory = (luvio) => {
+    return function createInsightsBatch(untrustedConfig) {
+        const config = validateAdapterConfig$3(untrustedConfig, createInsightsBatch_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "createInsightsBatch"');
+        }
+        return buildNetworkSnapshot$3(luvio, config);
+    };
+};
+
+const VERSION$4 = "f898ff84f82ad0ca1eca0045e17ce492";
+function validate$4(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.viz !== undefined) {
-            const obj_viz = obj.viz;
-            const path_viz = path + '.viz';
-            if (typeof obj_viz !== 'object' || ArrayIsArray(obj_viz) || obj_viz === null) {
-                return new TypeError('Expected "object" but received "' + typeof obj_viz + '" (at "' + path_viz + '")');
+        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$9 = function InsightSelect() {
-    const { selections: InsightFeedbackMetadata__selections, opaque: InsightFeedbackMetadata__opaque, } = select$a();
+const select$7 = function GetFilterValuesResponse_CategoricalValuesSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$7,
+        version: VERSION$4,
         private: [],
         selections: [
             {
-                name: 'characterization',
-                kind: 'Scalar',
-                required: false
-            },
-            {
-                name: 'id',
-                kind: 'Scalar',
-                required: false
-            },
-            {
-                name: 'insightFeedbackMetadata',
-                kind: 'Object',
-                selections: InsightFeedbackMetadata__selections
-            },
-            {
-                name: 'markup',
-                kind: 'Scalar',
-                required: false
-            },
-            {
-                name: 'question',
-                kind: 'Scalar',
-                required: false
-            },
-            {
-                name: 'score',
-                kind: 'Scalar',
-                required: false
-            },
-            {
-                name: 'type',
-                kind: 'Scalar',
-                required: false
-            },
-            {
-                name: 'version',
+                name: 'values',
                 kind: 'Scalar',
+                plural: true,
                 required: false
             }
         ]
     };
 };
-function equals$7(existing, incoming) {
-    const existing_version = existing.version;
-    const incoming_version = incoming.version;
+function equals$4(existing, incoming) {
+    const existing_values = existing.values;
+    const incoming_values = incoming.values;
     // if at least one of these optionals is defined
-    if (existing_version !== undefined || incoming_version !== undefined) {
+    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_version === undefined || incoming_version === undefined) {
+        if (existing_values === undefined || incoming_values === undefined) {
             return false;
         }
-        if (!(existing_version === incoming_version)) {
+        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;
         }
     }
-    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;
+    return true;
+}
+
+const VERSION$3 = "2025bbf393050a10fae76d5b4d5d0f58";
+function validate$3(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 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;
+        const obj_categoricalValues = obj.categoricalValues;
+        const path_categoricalValues = path + '.categoricalValues';
+        const referencepath_categoricalValuesValidationError = validate$4(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);
         }
-        if (!(existing_id === incoming_id)) {
-            return false;
+        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 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 (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 (!(existing_markup === incoming_markup)) {
-            return false;
-        }
-    }
-    const existing_question = existing.question;
-    const incoming_question = incoming.question;
-    // if at least one of these optionals is defined
-    if (existing_question !== undefined || incoming_question !== undefined) {
-        // if one of these is not defined we know the other is defined and therefore
-        // not equal
-        if (existing_question === undefined || incoming_question === undefined) {
-            return false;
-        }
-        if (!(existing_question === incoming_question)) {
-            return false;
-        }
-    }
-    const existing_type = existing.type;
-    const incoming_type = incoming.type;
-    // if at least one of these optionals is defined
-    if (existing_type !== undefined || incoming_type !== undefined) {
-        // if one of these is not defined we know the other is defined and therefore
-        // not equal
-        if (existing_type === undefined || incoming_type === undefined) {
-            return false;
-        }
-        if (!(existing_type === incoming_type)) {
-            return false;
-        }
-    }
-    const existing_score = existing.score;
-    const incoming_score = incoming.score;
-    // if at least one of these optionals is defined
-    if (existing_score !== undefined || incoming_score !== undefined) {
-        // if one of these is not defined we know the other is defined and therefore
-        // not equal
-        if (existing_score === undefined || incoming_score === undefined) {
-            return false;
-        }
-        if (!(existing_score === incoming_score)) {
-            return false;
-        }
-    }
-    const existing_facts = existing.facts;
-    const incoming_facts = incoming.facts;
-    // if at least one of these optionals is defined
-    if (existing_facts !== undefined || incoming_facts !== undefined) {
-        // if one of these is not defined we know the other is defined and therefore
-        // not equal
-        if (existing_facts === undefined || incoming_facts === undefined) {
-            return false;
-        }
-    }
-    const existing_insightFeedbackMetadata = existing.insightFeedbackMetadata;
-    const incoming_insightFeedbackMetadata = incoming.insightFeedbackMetadata;
-    if (!(equals$8(existing_insightFeedbackMetadata, incoming_insightFeedbackMetadata))) {
-        return false;
-    }
-    const existing_vegaLiteViz = existing.vegaLiteViz;
-    const incoming_vegaLiteViz = incoming.vegaLiteViz;
-    // if at least one of these optionals is defined
-    if (existing_vegaLiteViz !== undefined || incoming_vegaLiteViz !== undefined) {
-        // if one of these is not defined we know the other is defined and therefore
-        // not equal
-        if (existing_vegaLiteViz === undefined || incoming_vegaLiteViz === undefined) {
-            return false;
-        }
-    }
-    const existing_viz = existing.viz;
-    const incoming_viz = incoming.viz;
-    // if at least one of these optionals is defined
-    if (existing_viz !== undefined || incoming_viz !== undefined) {
-        // if one of these is not defined we know the other is defined and therefore
-        // not equal
-        if (existing_viz === undefined || incoming_viz === undefined) {
-            return false;
-        }
-    }
-    return true;
-}
-
-const VERSION$6 = "6707f0d0aa09112abbca1db5e32bb172";
-function validate$l(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$w(obj_error, path_error);
-            if (referencepath_errorValidationError !== null) {
-                let message = 'Object doesn\'t match Error (at "' + path_error + '")\n';
-                message += referencepath_errorValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
-                return new TypeError(message);
-            }
-        }
-        if (obj.insightType !== undefined) {
-            const obj_insightType = obj.insightType;
-            const path_insightType = path + '.insightType';
-            if (typeof obj_insightType !== 'string') {
-                return new TypeError('Expected "string" but received "' + typeof obj_insightType + '" (at "' + path_insightType + '")');
-            }
-        }
-        const obj_result = obj.result;
-        const path_result = path + '.result';
-        const referencepath_resultValidationError = validate$m(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);
+        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 select$8 = function InsightResponseSelect() {
-    const { selections: Error__selections, opaque: Error__opaque, } = select$g();
-    const { selections: Insight__selections, opaque: Insight__opaque, } = select$9();
+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$6 = function GetFilterValuesResponseSelect() {
+    const { selections: GetFilterValuesResponse_CategoricalValues__selections, opaque: GetFilterValuesResponse_CategoricalValues__opaque, } = select$7();
     return {
         kind: 'Fragment',
-        version: VERSION$6,
+        version: VERSION$3,
         private: [],
         selections: [
             {
-                name: 'error',
+                name: 'categoricalValues',
                 kind: 'Object',
-                selections: Error__selections,
-                required: false
+                selections: GetFilterValuesResponse_CategoricalValues__selections
+            },
+            {
+                name: 'id',
+                kind: 'Scalar'
             },
             {
-                name: 'insightType',
+                name: 'nextPageToken',
                 kind: 'Scalar',
                 required: false
             },
             {
-                name: 'result',
-                kind: 'Object',
-                selections: Insight__selections
+                name: 'totalAvailable',
+                kind: 'Scalar',
+                required: false
             }
         ]
     };
 };
-function equals$6(existing, incoming) {
-    const existing_insightType = existing.insightType;
-    const incoming_insightType = incoming.insightType;
+function equals$3(existing, incoming) {
+    const existing_totalAvailable = existing.totalAvailable;
+    const incoming_totalAvailable = incoming.totalAvailable;
     // if at least one of these optionals is defined
-    if (existing_insightType !== undefined || incoming_insightType !== undefined) {
+    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_insightType === undefined || incoming_insightType === undefined) {
+        if (existing_totalAvailable === undefined || incoming_totalAvailable === undefined) {
             return false;
         }
-        if (!(existing_insightType === incoming_insightType)) {
+        if (!(existing_totalAvailable === incoming_totalAvailable)) {
             return false;
         }
     }
-    const existing_error = existing.error;
-    const incoming_error = incoming.error;
+    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_error !== undefined || incoming_error !== undefined) {
+    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_error === undefined || incoming_error === undefined) {
+        if (existing_nextPageToken === undefined || incoming_nextPageToken === undefined) {
             return false;
         }
-        if (!(equals$c(existing_error, incoming_error))) {
+        if (!(existing_nextPageToken === incoming_nextPageToken)) {
             return false;
         }
     }
-    const existing_result = existing.result;
-    const incoming_result = incoming.result;
-    if (!(equals$7(existing_result, incoming_result))) {
+    const existing_categoricalValues = existing.categoricalValues;
+    const incoming_categoricalValues = incoming.categoricalValues;
+    if (!(equals$4(existing_categoricalValues, incoming_categoricalValues))) {
         return false;
     }
     return true;
 }
-
-const VERSION$5 = "9a4f5492d8e4788f172b90ac222f71c5";
-function validate$k(obj, path = 'Overview') {
-    const v_error = (() => {
-        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
-            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
-        }
-        if (obj.vegaLiteViz !== undefined) {
-            const obj_vegaLiteViz = obj.vegaLiteViz;
-            const path_vegaLiteViz = path + '.vegaLiteViz';
-            if (typeof obj_vegaLiteViz !== 'object' || ArrayIsArray(obj_vegaLiteViz) || obj_vegaLiteViz === null) {
-                return new TypeError('Expected "object" but received "' + typeof obj_vegaLiteViz + '" (at "' + path_vegaLiteViz + '")');
-            }
-        }
-        if (obj.viz !== undefined) {
-            const obj_viz = obj.viz;
-            const path_viz = path + '.viz';
-            if (typeof obj_viz !== 'object' || ArrayIsArray(obj_viz) || obj_viz === null) {
-                return new TypeError('Expected "object" but received "' + typeof obj_viz + '" (at "' + path_viz + '")');
-            }
-        }
-    })();
-    return v_error === undefined ? null : v_error;
-}
-const select$7 = function OverviewSelect() {
-    return {
-        kind: 'Fragment',
-        version: VERSION$5,
-        private: [],
-        selections: []
-    };
-};
-function equals$5(existing, incoming) {
-    const existing_vegaLiteViz = existing.vegaLiteViz;
-    const incoming_vegaLiteViz = incoming.vegaLiteViz;
-    // if at least one of these optionals is defined
-    if (existing_vegaLiteViz !== undefined || incoming_vegaLiteViz !== undefined) {
-        // if one of these is not defined we know the other is defined and therefore
-        // not equal
-        if (existing_vegaLiteViz === undefined || incoming_vegaLiteViz === undefined) {
-            return false;
-        }
-    }
-    const existing_viz = existing.viz;
-    const incoming_viz = incoming.viz;
-    // if at least one of these optionals is defined
-    if (existing_viz !== undefined || incoming_viz !== undefined) {
-        // if one of these is not defined we know the other is defined and therefore
-        // not equal
-        if (existing_viz === undefined || incoming_viz === undefined) {
-            return false;
+const ingest$2 = function GetFilterValuesResponseIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$3(input);
+        if (validateError !== null) {
+            throw validateError;
         }
     }
-    return true;
+    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$3, RepresentationType$2, equals$3);
+    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
+    });
 }
 
-const VERSION$4 = "ac3296a9832f46fda66420bc753d8c61";
-function validate$j(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$w(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$k(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);
+function select$5(luvio, params) {
+    return select$6();
+}
+function getResponseCacheKeys$2(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$2(storeKeyMap, luvio, response);
+}
+function ingestSuccess$2(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$2(luvio, body);
+    luvio.storeIngest(key, ingest$2, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$5(),
+        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');
         }
-    })();
-    return v_error === undefined ? null : v_error;
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
 }
-const select$6 = function OverviewResponseSelect() {
-    const { selections: Error__selections, opaque: Error__opaque, } = select$g();
-    const { selections: Overview__selections, opaque: Overview__opaque, } = select$7();
+function createResourceRequest$2(config) {
+    const headers = {};
     return {
-        kind: 'Fragment',
-        version: VERSION$4,
-        private: [],
-        selections: [
-            {
-                name: 'error',
-                kind: 'Object',
-                selections: Error__selections,
-                required: false
-            },
-            {
-                name: 'result',
-                kind: 'Object',
-                selections: Overview__selections
-            }
-        ]
+        baseUri: 'api.salesforce.com',
+        basePath: '/analytics/insights/v1/filterValues',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
     };
-};
-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$c(existing_error, incoming_error))) {
-            return false;
-        }
-    }
-    const existing_result = existing.result;
-    const incoming_result = incoming.result;
-    if (!(equals$5(existing_result, incoming_result))) {
-        return false;
-    }
-    return true;
 }
 
-const VERSION$3 = "a70a5e68e786c3f38efb73cc0812d394";
-function validate$i(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$w(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$l(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$j(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$5 = function InsightGroupSelect() {
-    const { selections: Error__selections, opaque: Error__opaque, } = select$g();
-    const { selections: InsightResponse__selections, opaque: InsightResponse__opaque, } = select$8();
-    const { selections: OverviewResponse__selections, opaque: OverviewResponse__opaque, } = select$6();
-    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$c(existing_error, incoming_error))) {
-            return false;
-        }
+const adapterName$2 = '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),
+];
+const getMetricFilterValues_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, getMetricFilterValues_ConfigPropertyMetadata);
+const createResourceParams$2 = /*#__PURE__*/ createResourceParams$4(getMetricFilterValues_ConfigPropertyMetadata);
+function typeCheckConfig$2(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$4(untrustedConfig, config, getMetricFilterValues_ConfigPropertyMetadata);
+    const untrustedConfig_semanticDataModel = untrustedConfig.semanticDataModel;
+    const referenceSemanticDataModelValidationError = validate$e(untrustedConfig_semanticDataModel);
+    if (referenceSemanticDataModelValidationError === null) {
+        config.semanticDataModel = untrustedConfig_semanticDataModel;
     }
-    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$6(existing_insights_item, incoming_insights_item))) {
-                return false;
-            }
-        });
-        if (equals_insights_items === false) {
-            return false;
-        }
+    const untrustedConfig_field = untrustedConfig.field;
+    const referenceFieldIdValidationError = validate$n(untrustedConfig_field);
+    if (referenceFieldIdValidationError === null) {
+        config.field = untrustedConfig_field;
     }
-    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;
+    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$j(untrustedConfig_filters_item);
+            if (referenceFilterValidationError === null) {
+                untrustedConfig_filters_array.push(untrustedConfig_filters_item);
             }
-        });
-        if (equals_overviews_items === false) {
-            return false;
         }
+        config.filters = untrustedConfig_filters_array;
     }
-    return true;
-}
-
-const VERSION$2 = "ccf83d258110a04c1949592c91b69b3b";
-function validate$h(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$i(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;
+    return config;
 }
-const select$4 = function InsightBundleSelect() {
-    const { selections: InsightGroup__selections, opaque: InsightGroup__opaque, } = select$5();
-    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;
-        }
+function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
     }
-    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;
-        }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
     }
-    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;
-        }
+    const config = typeCheckConfig$2(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
     }
-    return true;
-}
-
-const VERSION$1 = "8c719ff91e25e9ab6139733bd1b5c2bc";
-function validate$g(obj, path = 'GetInsightBatchResponse') {
-    const v_error = (() => {
-        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
-            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
-        }
-        const obj_batchId = obj.batchId;
-        const path_batchId = path + '.batchId';
-        if (typeof obj_batchId !== 'string') {
-            return new TypeError('Expected "string" but received "' + typeof obj_batchId + '" (at "' + path_batchId + '")');
-        }
-        if (obj.bundles !== undefined) {
-            const obj_bundles = obj.bundles;
-            const path_bundles = path + '.bundles';
-            if (!ArrayIsArray(obj_bundles)) {
-                return new TypeError('Expected "array" but received "' + typeof obj_bundles + '" (at "' + path_bundles + '")');
-            }
-            for (let i = 0; i < obj_bundles.length; i++) {
-                const obj_bundles_item = obj_bundles[i];
-                const path_bundles_item = path_bundles + '[' + i + ']';
-                const referencepath_bundles_itemValidationError = validate$h(obj_bundles_item, path_bundles_item);
-                if (referencepath_bundles_itemValidationError !== null) {
-                    let message = 'Object doesn\'t match InsightBundle (at "' + path_bundles_item + '")\n';
-                    message += referencepath_bundles_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
-                    return new TypeError(message);
-                }
-            }
-        }
-        if (obj.hasErrors !== undefined) {
-            const obj_hasErrors = obj.hasErrors;
-            const path_hasErrors = path + '.hasErrors';
-            if (typeof obj_hasErrors !== 'boolean') {
-                return new TypeError('Expected "boolean" but received "' + typeof obj_hasErrors + '" (at "' + path_hasErrors + '")');
-            }
-        }
-        if (obj.summary !== undefined) {
-            const obj_summary = obj.summary;
-            const path_summary = path + '.summary';
-            if (obj_summary === undefined) {
-                return new TypeError('Expected "defined" but received "' + typeof obj_summary + '" (at "' + path_summary + '")');
-            }
-        }
-    })();
-    return v_error === undefined ? null : v_error;
-}
-const RepresentationType$1 = 'GetInsightBatchResponse';
-function keyBuilder$3(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$1 + ':' + config.batchid;
-}
-function keyBuilderFromType$1(luvio, object) {
-    const keyParams = {
-        batchid: object.batchId
-    };
-    return keyBuilder$3(luvio, keyParams);
-}
-function normalize$1(input, existing, path, luvio, store, timestamp) {
-    return input;
+    return config;
 }
-const select$3 = function GetInsightBatchResponseSelect() {
-    const { selections: InsightBundle__selections, opaque: InsightBundle__opaque, } = select$4();
-    return {
-        kind: 'Fragment',
-        version: VERSION$1,
-        private: [],
-        selections: [
-            {
-                name: 'batchId',
-                kind: 'Scalar'
-            },
-            {
-                name: 'bundles',
-                kind: 'Object',
-                plural: true,
-                selections: InsightBundle__selections,
-                required: false
-            },
-            {
-                name: 'hasErrors',
-                kind: 'Scalar',
-                required: false
-            },
-            {
-                name: 'summary',
-                kind: 'Object',
-                // any
-            }
-        ]
-    };
-};
-function equals$1(existing, incoming) {
-    const existing_hasErrors = existing.hasErrors;
-    const incoming_hasErrors = incoming.hasErrors;
-    // if at least one of these optionals is defined
-    if (existing_hasErrors !== undefined || incoming_hasErrors !== undefined) {
-        // if one of these is not defined we know the other is defined and therefore
-        // not equal
-        if (existing_hasErrors === undefined || incoming_hasErrors === undefined) {
-            return false;
-        }
-        if (!(existing_hasErrors === incoming_hasErrors)) {
-            return false;
-        }
-    }
-    const existing_batchId = existing.batchId;
-    const incoming_batchId = incoming.batchId;
-    if (!(existing_batchId === incoming_batchId)) {
-        return false;
-    }
-    const existing_bundles = existing.bundles;
-    const incoming_bundles = incoming.bundles;
-    // if at least one of these optionals is defined
-    if (existing_bundles !== undefined || incoming_bundles !== undefined) {
-        // if one of these is not defined we know the other is defined and therefore
-        // not equal
-        if (existing_bundles === undefined || incoming_bundles === undefined) {
-            return false;
-        }
-        const equals_bundles_items = equalsArray(existing_bundles, incoming_bundles, (existing_bundles_item, incoming_bundles_item) => {
-            if (!(equals$2(existing_bundles_item, incoming_bundles_item))) {
-                return false;
-            }
-        });
-        if (equals_bundles_items === false) {
-            return false;
-        }
-    }
-    const existing_summary = existing.summary;
-    const incoming_summary = incoming.summary;
-    // if at least one of these optionals is defined
-    if (existing_summary !== undefined || incoming_summary !== undefined) {
-        // if one of these is not defined we know the other is defined and therefore
-        // not equal
-        if (existing_summary === undefined || incoming_summary === undefined) {
-            return false;
-        }
-        if (JSONStringify(incoming_summary) !== JSONStringify(existing_summary)) {
-            return false;
-        }
-    }
-    return true;
-}
-const ingest$1 = function GetInsightBatchResponseIngest(input, path, luvio, store, timestamp) {
-    if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$g(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$2(luvio, params) {
-    return select$3();
-}
-function keyBuilder$2(luvio, params) {
-    return keyBuilder$3(luvio, {
-        batchid: params.urlParams.batch_id
-    });
-}
-function getResponseCacheKeys$1(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$1(storeKeyMap, luvio, response);
-}
-function ingestSuccess$1(luvio, resourceParams, response, snapshotRefresh) {
-    const { body } = response;
-    const key = keyBuilder$2(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$1, body);
-    const snapshot = luvio.storeLookup({
-        recordId: key,
-        node: select$2(),
-        variables: {},
-    }, snapshotRefresh);
-    if (process.env.NODE_ENV !== 'production') {
-        if (snapshot.state !== 'Fulfilled') {
-            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
-        }
-    }
-    deepFreeze(snapshot.data);
-    return snapshot;
-}
-function ingestError(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$2(luvio, params);
-    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
-    luvio.storeIngestError(key, errorSnapshot);
-    return errorSnapshot;
-}
-function createResourceRequest$1(config) {
-    const headers = {};
-    return {
-        baseUri: 'api.salesforce.com',
-        basePath: '/analytics/tua-insights-service/v1/batches/' + config.urlParams.batch_id + '',
-        method: 'get',
-        body: null,
-        urlParams: config.urlParams,
-        queryParams: {},
-        headers,
-        priority: 'normal',
-    };
-}
-
-const adapterName$1 = 'getInsightsBatch';
-const getInsightsBatch_ConfigPropertyMetadata = [
-    generateParamConfigMetadata('batch_id', true, 0 /* UrlParameter */, 0 /* String */),
-];
-const getInsightsBatch_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, getInsightsBatch_ConfigPropertyMetadata);
-const createResourceParams$1 = /*#__PURE__*/ createResourceParams$4(getInsightsBatch_ConfigPropertyMetadata);
-function keyBuilder$1(luvio, config) {
-    const resourceParams = createResourceParams$1(config);
-    return keyBuilder$2(luvio, resourceParams);
-}
-function typeCheckConfig$1(untrustedConfig) {
-    const config = {};
-    typeCheckConfig$4(untrustedConfig, config, getInsightsBatch_ConfigPropertyMetadata);
-    return config;
-}
-function validateAdapterConfig$1(untrustedConfig, configPropertyNames) {
-    if (!untrustedIsObject(untrustedConfig)) {
-        return null;
-    }
-    if (process.env.NODE_ENV !== 'production') {
-        validateConfig(untrustedConfig, configPropertyNames);
-    }
-    const config = typeCheckConfig$1(untrustedConfig);
-    if (!areRequiredParametersPresent(config, configPropertyNames)) {
-        return null;
-    }
-    return config;
-}
-function adapterFragment(luvio, config) {
-    createResourceParams$1(config);
-    return select$2();
-}
-function onFetchResponseSuccess(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$1(luvio, resourceParams, response, {
-        config,
-        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions)
-    });
-    return luvio.storeBroadcast().then(() => snapshot);
-}
-function onFetchResponseError(luvio, config, resourceParams, response) {
-    const snapshot = ingestError(luvio, resourceParams, response, {
-        config,
-        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions)
-    });
-    return luvio.storeBroadcast().then(() => snapshot);
-}
-function buildNetworkSnapshot$1(luvio, config, options) {
-    const resourceParams = createResourceParams$1(config);
-    const request = createResourceRequest$1(resourceParams);
+function buildNetworkSnapshot$2(luvio, config, options) {
+    const resourceParams = createResourceParams$2(config);
+    const request = createResourceRequest$2(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$2(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$1(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$2(cache, luvio, resourceParams, response.body);
             return cache;
         });
-    }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError(luvio, config, resourceParams, response));
-    });
-}
-function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext, buildNetworkSnapshot$1, undefined, false);
-}
-function buildCachedSnapshotCachePolicy(context, storeLookup) {
-    const { luvio, config } = context;
-    const selector = {
-        recordId: keyBuilder$1(luvio, config),
-        node: adapterFragment(luvio, config),
-        variables: {},
-    };
-    const cacheSnapshot = storeLookup(selector, {
-        config,
-        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions)
-    });
-    return cacheSnapshot;
-}
-const getInsightsBatchAdapterFactory = (luvio) => function analyticsInsights__getInsightsBatch(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$1(untrustedConfig, getInsightsBatch_ConfigPropertyNames);
-    // Invalid or incomplete config
-    if (config === null) {
-        return null;
-    }
-    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
-};
-
-function validate$f(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$e(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$d(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$c(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$d(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$b(obj, path = 'MeasurementPeriod') {
-    const v_error = (() => {
-        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
-            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
-        }
-        if (obj.end !== undefined) {
-            const obj_end = obj.end;
-            const path_end = path + '.end';
-            if (typeof obj_end !== 'string') {
-                return new TypeError('Expected "string" but received "' + typeof obj_end + '" (at "' + path_end + '")');
-            }
-        }
-        if (obj.granularity !== undefined) {
-            const obj_granularity = obj.granularity;
-            const path_granularity = path + '.granularity';
-            if (typeof obj_granularity !== 'string') {
-                return new TypeError('Expected "string" but received "' + typeof obj_granularity + '" (at "' + path_granularity + '")');
-            }
-        }
-        if (obj.range !== undefined) {
-            const obj_range = obj.range;
-            const path_range = path + '.range';
-            if (typeof obj_range !== 'string') {
-                return new TypeError('Expected "string" but received "' + typeof obj_range + '" (at "' + path_range + '")');
-            }
-        }
-        if (obj.start !== undefined) {
-            const obj_start = obj.start;
-            const path_start = path + '.start';
-            if (typeof obj_start !== 'string') {
-                return new TypeError('Expected "string" but received "' + typeof obj_start + '" (at "' + path_start + '")');
-            }
-        }
-    })();
-    return v_error === undefined ? null : v_error;
-}
-
-function validate$a(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$q(obj_filters_item, path_filters_item);
-                if (referencepath_filters_itemValidationError !== null) {
-                    let message = 'Object doesn\'t match Filter (at "' + path_filters_item + '")\n';
-                    message += referencepath_filters_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
-                    return new TypeError(message);
-                }
-            }
-        }
-        const obj_measurementPeriod = obj.measurementPeriod;
-        const path_measurementPeriod = path + '.measurementPeriod';
-        const referencepath_measurementPeriodValidationError = validate$b(obj_measurementPeriod, path_measurementPeriod);
-        if (referencepath_measurementPeriodValidationError !== null) {
-            let message = 'Object doesn\'t match MeasurementPeriod (at "' + path_measurementPeriod + '")\n';
-            message += referencepath_measurementPeriodValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
-            return new TypeError(message);
-        }
-    })();
-    return v_error === undefined ? null : v_error;
-}
-
-function validate$9(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$8(obj, path = 'Measure') {
-    const v_error = (() => {
-        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
-            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
-        }
-        if (obj.aggregation !== undefined) {
-            const obj_aggregation = obj.aggregation;
-            const path_aggregation = path + '.aggregation';
-            if (typeof obj_aggregation !== 'string') {
-                return new TypeError('Expected "string" but received "' + typeof obj_aggregation + '" (at "' + path_aggregation + '")');
-            }
-        }
-        const obj_semanticField = obj.semanticField;
-        const path_semanticField = path + '.semanticField';
-        const referencepath_semanticFieldValidationError = validate$s(obj_semanticField, path_semanticField);
-        if (referencepath_semanticFieldValidationError !== null) {
-            let message = 'Object doesn\'t match SemanticField (at "' + path_semanticField + '")\n';
-            message += referencepath_semanticFieldValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
-            return new TypeError(message);
-        }
-        const obj_tableField = obj.tableField;
-        const path_tableField = path + '.tableField';
-        const referencepath_tableFieldValidationError = validate$t(obj_tableField, path_tableField);
-        if (referencepath_tableFieldValidationError !== null) {
-            let message = 'Object doesn\'t match TableField (at "' + path_tableField + '")\n';
-            message += referencepath_tableFieldValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
-            return new TypeError(message);
-        }
-    })();
-    return v_error === undefined ? null : v_error;
-}
-
-function validate$7(obj, path = 'TimeDimension') {
-    const v_error = (() => {
-        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
-            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
-        }
-        const obj_semanticField = obj.semanticField;
-        const path_semanticField = path + '.semanticField';
-        const referencepath_semanticFieldValidationError = validate$s(obj_semanticField, path_semanticField);
-        if (referencepath_semanticFieldValidationError !== null) {
-            let message = 'Object doesn\'t match SemanticField (at "' + path_semanticField + '")\n';
-            message += referencepath_semanticFieldValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
-            return new TypeError(message);
-        }
-        const obj_tableField = obj.tableField;
-        const path_tableField = path + '.tableField';
-        const referencepath_tableFieldValidationError = validate$t(obj_tableField, path_tableField);
-        if (referencepath_tableFieldValidationError !== null) {
-            let message = 'Object doesn\'t match TableField (at "' + path_tableField + '")\n';
-            message += referencepath_tableFieldValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
-            return new TypeError(message);
-        }
-    })();
-    return v_error === undefined ? null : v_error;
-}
-
-function validate$6(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$9(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$q(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$8(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$u(obj_semanticDataModel, path_semanticDataModel);
-        if (referencepath_semanticDataModelValidationError !== null) {
-            let message = 'Object doesn\'t match SemanticDataModel (at "' + path_semanticDataModel + '")\n';
-            message += referencepath_semanticDataModelValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
-            return new TypeError(message);
-        }
-        const obj_timeDimension = obj.timeDimension;
-        const path_timeDimension = path + '.timeDimension';
-        const referencepath_timeDimensionValidationError = validate$7(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;
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
 }
+const getMetricFilterValuesAdapterFactory = (luvio) => {
+    return function getMetricFilterValues(untrustedConfig) {
+        const config = validateAdapterConfig$2(untrustedConfig, getMetricFilterValues_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "getMetricFilterValues"');
+        }
+        return buildNetworkSnapshot$2(luvio, config);
+    };
+};
 
-function validate$5(obj, path = 'RepresentationOptions_NumberUnits') {
+const VERSION$2 = "07a8c889542dbad6f958515513d4e3fb";
+function validate$2(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.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.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.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 + '")');
+        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;
 }
-
-function validate$4(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 select$4 = function ErrorSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$2,
+        private: [],
+        selections: [
+            {
+                name: 'code',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'message',
+                kind: 'Scalar',
+                required: false
+            }
+        ]
+    };
+};
+function equals$2(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;
         }
-        const obj_numberUnits = obj.numberUnits;
-        const path_numberUnits = path + '.numberUnits';
-        const referencepath_numberUnitsValidationError = validate$5(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 (!(existing_code === incoming_code)) {
+            return false;
         }
-        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 + '")');
-            }
+    }
+    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 (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 (!(existing_message === incoming_message)) {
+            return false;
         }
-    })();
-    return v_error === undefined ? null : v_error;
+    }
+    return true;
 }
 
-function validate$3(obj, path = 'InputMetric') {
+const VERSION$1 = "8dd18b6afd3fc20ff954cca4d0124897";
+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 + '")');
         }
-        const obj_extensionOptions = obj.extensionOptions;
-        const path_extensionOptions = path + '.extensionOptions';
-        const referencepath_extensionOptionsValidationError = validate$e(obj_extensionOptions, path_extensionOptions);
-        if (referencepath_extensionOptionsValidationError !== null) {
-            let message = 'Object doesn\'t match ExtensionOptions (at "' + path_extensionOptions + '")\n';
-            message += referencepath_extensionOptionsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
-            return new TypeError(message);
-        }
-        const obj_insightsOptions = obj.insightsOptions;
-        const path_insightsOptions = path + '.insightsOptions';
-        const referencepath_insightsOptionsValidationError = validate$c(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);
+        if (obj.error !== undefined) {
+            const obj_error = obj.error;
+            const path_error = path + '.error';
+            const referencepath_errorValidationError = validate$2(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_instance = obj.instance;
-        const path_instance = path + '.instance';
-        const referencepath_instanceValidationError = validate$a(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);
+        if (obj.result !== undefined) {
+            const obj_result = obj.result;
+            const path_result = path + '.result';
+            if (obj_result === undefined) {
+                return new TypeError('Expected "defined" but received "' + typeof obj_result + '" (at "' + path_result + '")');
+            }
         }
-        const obj_metric = obj.metric;
-        const path_metric = path + '.metric';
-        const referencepath_metricValidationError = validate$6(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_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_representationOptions = obj.representationOptions;
-        const path_representationOptions = path + '.representationOptions';
-        const referencepath_representationOptionsValidationError = validate$4(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);
+        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;
 }
-
-function validate$2(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 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$3 = function GenerateInsightBundleResponseSelect() {
+    const { selections: Error__selections, opaque: Error__opaque, } = select$4();
+    return {
+        kind: 'Fragment',
+        version: VERSION$1,
+        private: [],
+        selections: [
+            {
+                name: 'error',
+                kind: 'Object',
+                selections: Error__selections,
+                required: false
+            },
+            {
+                name: 'result',
+                kind: 'Object',
+                // any
+            },
+            {
+                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;
         }
-        const obj_metadata = obj.metadata;
-        const path_metadata = path + '.metadata';
-        const referencepath_metadataValidationError = validate$f(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);
+        if (!(equals$2(existing_error, incoming_error))) {
+            return false;
         }
-        const obj_metric = obj.metric;
-        const path_metric = path + '.metric';
-        const referencepath_metricValidationError = validate$3(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);
+    }
+    const existing_result = existing.result;
+    const incoming_result = incoming.result;
+    // if at least one of these optionals is defined
+    if (existing_result !== undefined || incoming_result !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_result === undefined || incoming_result === undefined) {
+            return false;
+        }
+        if (JSONStringify(incoming_result) !== JSONStringify(existing_result)) {
+            return false;
+        }
+    }
+    return true;
+}
+const ingest$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$2(luvio, params) {
+    return select$3();
+}
+function getResponseCacheKeys$1(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$1(storeKeyMap, luvio, response);
+}
+function ingestSuccess$1(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$1(luvio, body);
+    luvio.storeIngest(key, ingest$1, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$2(),
+        variables: {},
+    });
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
         }
-    })();
-    return v_error === undefined ? null : v_error;
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
+}
+function createResourceRequest$1(config) {
+    const headers = {};
+    return {
+        baseUri: 'api.salesforce.com',
+        basePath: '/analytics/insights/v1/generateBundle',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
 }
 
-function validate$1(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$2(obj_bundleInput, path_bundleInput);
-            if (referencepath_bundleInputValidationError !== null) {
-                let message = 'Object doesn\'t match InsightBundleInput (at "' + path_bundleInput + '")\n';
-                message += referencepath_bundleInputValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
-                return new TypeError(message);
-            }
-        }
-        if (obj.metricInstanceId !== undefined) {
-            const obj_metricInstanceId = obj.metricInstanceId;
-            const path_metricInstanceId = path + '.metricInstanceId';
-            if (typeof obj_metricInstanceId !== 'string') {
-                return new TypeError('Expected "string" but received "' + typeof obj_metricInstanceId + '" (at "' + path_metricInstanceId + '")');
-            }
-        }
-    })();
-    return v_error === undefined ? null : v_error;
+const adapterName$1 = 'generateInsights';
+const generateInsights_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('type', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('version', false, 2 /* Body */, 3 /* Integer */),
+    generateParamConfigMetadata('input', false, 2 /* Body */, 4 /* Unsupported */),
+    generateParamConfigMetadata('options', false, 2 /* Body */, 4 /* Unsupported */),
+];
+const generateInsights_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, generateInsights_ConfigPropertyMetadata);
+const createResourceParams$1 = /*#__PURE__*/ createResourceParams$4(generateInsights_ConfigPropertyMetadata);
+function typeCheckConfig$1(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$4(untrustedConfig, config, generateInsights_ConfigPropertyMetadata);
+    const untrustedConfig_input = untrustedConfig.input;
+    config.input = untrustedConfig_input;
+    const untrustedConfig_options = untrustedConfig.options;
+    config.options = untrustedConfig_options;
+    return config;
+}
+function validateAdapterConfig$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 generateInsightsAdapterFactory = (luvio) => {
+    return function generateInsights(untrustedConfig) {
+        const config = validateAdapterConfig$1(untrustedConfig, generateInsights_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "generateInsights"');
+        }
+        return buildNetworkSnapshot$1(luvio, config);
+    };
+};
 
-const VERSION = "a8b8e8e21e2dc1b5b067efa90209dce3";
-function validate(obj, path = 'GenerateInsightBatchResponse') {
+const VERSION = "94ce8446612f6dc54775a9c8489b1b52";
+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 + '")');
@@ -2526,11 +1711,32 @@ function validate(obj, path = 'GenerateInsightBatchResponse') {
         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.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') {
+                    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) {
@@ -2540,30 +1746,41 @@ function validate(obj, path = 'GenerateInsightBatchResponse') {
                 return new TypeError('Expected "defined" but received "' + typeof obj_summary + '" (at "' + path_summary + '")');
             }
         }
-        if (obj.timestamp !== undefined) {
-            const obj_timestamp = obj.timestamp;
-            const path_timestamp = path + '.timestamp';
-            if (typeof obj_timestamp !== 'string') {
-                return new TypeError('Expected "string" but received "' + typeof obj_timestamp + '" (at "' + path_timestamp + '")');
-            }
-        }
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType = 'GenerateInsightBatchResponse';
-function keyBuilder(luvio, config) {
+const RepresentationType = 'GetInsightBatchResponse';
+function keyBuilder$2(luvio, config) {
     return keyPrefix + '::' + RepresentationType + ':' + config.batchid;
 }
 function keyBuilderFromType(luvio, object) {
     const keyParams = {
         batchid: object.batchId
     };
-    return keyBuilder(luvio, keyParams);
+    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 GenerateInsightBatchResponseSelect() {
+const select$1 = function GetInsightBatchResponseSelect() {
     return {
         kind: 'Fragment',
         version: VERSION,
@@ -2574,7 +1791,19 @@ const select$1 = function GenerateInsightBatchResponseSelect() {
                 kind: 'Scalar'
             },
             {
-                name: 'generatingSummary',
+                name: 'bundles',
+                kind: 'Link',
+                plural: true,
+                required: false,
+                fragment: select$3()
+            },
+            {
+                name: 'hasErrors',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'status',
                 kind: 'Scalar',
                 required: false
             },
@@ -2582,26 +1811,21 @@ const select$1 = function GenerateInsightBatchResponseSelect() {
                 name: 'summary',
                 kind: 'Object',
                 // any
-            },
-            {
-                name: 'timestamp',
-                kind: 'Scalar',
-                required: false
             }
         ]
     };
 };
 function equals(existing, incoming) {
-    const existing_generatingSummary = existing.generatingSummary;
-    const incoming_generatingSummary = incoming.generatingSummary;
+    const existing_hasErrors = existing.hasErrors;
+    const incoming_hasErrors = incoming.hasErrors;
     // if at least one of these optionals is defined
-    if (existing_generatingSummary !== undefined || incoming_generatingSummary !== undefined) {
+    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_generatingSummary === undefined || incoming_generatingSummary === undefined) {
+        if (existing_hasErrors === undefined || incoming_hasErrors === undefined) {
             return false;
         }
-        if (!(existing_generatingSummary === incoming_generatingSummary)) {
+        if (!(existing_hasErrors === incoming_hasErrors)) {
             return false;
         }
     }
@@ -2610,16 +1834,34 @@ function equals(existing, incoming) {
     if (!(existing_batchId === incoming_batchId)) {
         return false;
     }
-    const existing_timestamp = existing.timestamp;
-    const incoming_timestamp = incoming.timestamp;
+    const existing_status = existing.status;
+    const incoming_status = incoming.status;
     // if at least one of these optionals is defined
-    if (existing_timestamp !== undefined || incoming_timestamp !== undefined) {
+    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_timestamp === undefined || incoming_timestamp === undefined) {
+        if (existing_status === undefined || incoming_status === undefined) {
             return false;
         }
-        if (!(existing_timestamp === incoming_timestamp)) {
+        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;
         }
     }
@@ -2638,7 +1880,7 @@ function equals(existing, incoming) {
     }
     return true;
 }
-const ingest = function GenerateInsightBatchResponseIngest(input, path, luvio, store, timestamp) {
+const ingest = function GetInsightBatchResponseIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate(input);
         if (validateError !== null) {
@@ -2658,23 +1900,34 @@ function getTypeCacheKeys(rootKeySet, luvio, input, fullPathFactory) {
         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) {
+function ingestSuccess(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilderFromType(luvio, body);
+    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');
@@ -2683,43 +1936,39 @@ function ingestSuccess(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
+function ingestError(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$1(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    luvio.storeIngestError(key, errorSnapshot);
+    return errorSnapshot;
+}
 function createResourceRequest(config) {
     const headers = {};
     return {
         baseUri: 'api.salesforce.com',
-        basePath: '/analytics/tua-insights-service/v1/batches',
-        method: 'post',
-        body: config.body,
-        urlParams: {},
+        basePath: '/analytics/insights/v1/batches/' + config.urlParams.batchId + '',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
         queryParams: {},
         headers,
         priority: 'normal',
     };
 }
 
-const adapterName = 'createInsightsBatch';
-const createInsightsBatch_ConfigPropertyMetadata = [
-    generateParamConfigMetadata('batchInput', false, 2 /* Body */, 4 /* Unsupported */, true),
-    generateParamConfigMetadata('options', false, 2 /* Body */, 4 /* Unsupported */),
+const adapterName = 'getInsightsBatch';
+const getInsightsBatch_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('batchId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const createInsightsBatch_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, createInsightsBatch_ConfigPropertyMetadata);
-const createResourceParams = /*#__PURE__*/ createResourceParams$4(createInsightsBatch_ConfigPropertyMetadata);
+const getInsightsBatch_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, getInsightsBatch_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$4(getInsightsBatch_ConfigPropertyMetadata);
+function keyBuilder(luvio, config) {
+    const resourceParams = createResourceParams(config);
+    return keyBuilder$1(luvio, resourceParams);
+}
 function typeCheckConfig(untrustedConfig) {
     const config = {};
-    const untrustedConfig_batchInput = untrustedConfig.batchInput;
-    if (ArrayIsArray$1(untrustedConfig_batchInput)) {
-        const untrustedConfig_batchInput_array = [];
-        for (let i = 0, arrayLength = untrustedConfig_batchInput.length; i < arrayLength; i++) {
-            const untrustedConfig_batchInput_item = untrustedConfig_batchInput[i];
-            const referenceBatchInputValidationError = validate$1(untrustedConfig_batchInput_item);
-            if (referenceBatchInputValidationError === null) {
-                untrustedConfig_batchInput_array.push(untrustedConfig_batchInput_item);
-            }
-        }
-        config.batchInput = untrustedConfig_batchInput_array;
-    }
-    const untrustedConfig_options = untrustedConfig.options;
-    config.options = untrustedConfig_options;
+    typeCheckConfig$4(untrustedConfig, config, getInsightsBatch_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig(untrustedConfig, configPropertyNames) {
@@ -2735,33 +1984,62 @@ function validateAdapterConfig(untrustedConfig, configPropertyNames) {
     }
     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(() => {
-            const snapshot = ingestSuccess(luvio, resourceParams, response);
-            return luvio.storeBroadcast().then(() => snapshot);
-        }, () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
             getResponseCacheKeys(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        deepFreeze(response);
-        throw response;
+        return luvio.handleErrorResponse(() => onFetchResponseError(luvio, config, resourceParams, response));
     });
 }
-const createInsightsBatchAdapterFactory = (luvio) => {
-    return function createInsightsBatch(untrustedConfig) {
-        const config = validateAdapterConfig(untrustedConfig, createInsightsBatch_ConfigPropertyNames);
-        // Invalid or incomplete config
-        if (config === null) {
-            throw new Error('Invalid config for "createInsightsBatch"');
-        }
-        return buildNetworkSnapshot(luvio, config);
+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, getInsightsBatchAdapterFactory, getMetricFilterValuesAdapterFactory };