@salesforce/lds-adapters-platform-external-services 1.100.2

package/dist/umd/es5/platform-external-services.js

@@ -0,0 +1,2245 @@
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@luvio/engine')) :
+    typeof define === 'function' && define.amd ? define(['exports', '@luvio/engine'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.platformExternalServices = {}, global.engine));
+})(this, (function (exports, engine) { 'use strict';
+
+    var ObjectPrototypeHasOwnProperty = Object.prototype.hasOwnProperty;
+    var ObjectKeys$1 = Object.keys;
+    var ArrayIsArray$1 = Array.isArray;
+    /**
+     * Validates an adapter config is well-formed.
+     * @param config The config to validate.
+     * @param adapter The adapter validation configuration.
+     * @param oneOf The keys the config must contain at least one of.
+     * @throws A TypeError if config doesn't satisfy the adapter's config validation.
+     */
+    function validateConfig(config, adapter, oneOf) {
+        var displayName = adapter.displayName;
+        var _a = adapter.parameters, required = _a.required, optional = _a.optional, unsupported = _a.unsupported;
+        if (config === undefined ||
+            required.every(function (req) { return ObjectPrototypeHasOwnProperty.call(config, req); }) === false) {
+            throw new TypeError("adapter ".concat(displayName, " configuration must specify ").concat(required.sort().join(', ')));
+        }
+        if (oneOf && oneOf.some(function (req) { return ObjectPrototypeHasOwnProperty.call(config, req); }) === false) {
+            throw new TypeError("adapter ".concat(displayName, " configuration must specify one of ").concat(oneOf.sort().join(', ')));
+        }
+        if (unsupported !== undefined &&
+            unsupported.some(function (req) { return ObjectPrototypeHasOwnProperty.call(config, req); })) {
+            throw new TypeError("adapter ".concat(displayName, " does not yet support ").concat(unsupported.sort().join(', ')));
+        }
+        var supported = required.concat(optional);
+        if (ObjectKeys$1(config).some(function (key) { return !supported.includes(key); })) {
+            throw new TypeError("adapter ".concat(displayName, " configuration supports only ").concat(supported.sort().join(', ')));
+        }
+    }
+    function untrustedIsObject(untrusted) {
+        return typeof untrusted === 'object' && untrusted !== null && ArrayIsArray$1(untrusted) === false;
+    }
+    function areRequiredParametersPresent(config, configPropertyNames) {
+        return configPropertyNames.parameters.required.every(function (req) { return req in config; });
+    }
+    var snapshotRefreshOptions = {
+        overrides: {
+            headers: {
+                'Cache-Control': 'no-cache',
+            },
+        }
+    };
+    var keyPrefix = 'external-services';
+
+    var ObjectFreeze = Object.freeze, ObjectKeys = Object.keys;
+    var ArrayIsArray = Array.isArray;
+    var JSONStringify = JSON.stringify;
+    function equalsArray(a, b, equalsItem) {
+        var aLength = a.length;
+        var bLength = b.length;
+        if (aLength !== bLength) {
+            return false;
+        }
+        for (var i = 0; i < aLength; i++) {
+            if (equalsItem(a[i], b[i]) === false) {
+                return false;
+            }
+        }
+        return true;
+    }
+    function deepFreeze$2(value) {
+        // No need to freeze primitives
+        if (typeof value !== 'object' || value === null) {
+            return;
+        }
+        if (ArrayIsArray(value)) {
+            for (var i = 0, len = value.length; i < len; i += 1) {
+                deepFreeze$2(value[i]);
+            }
+        }
+        else {
+            var keys = ObjectKeys(value);
+            for (var i = 0, len = keys.length; i < len; i += 1) {
+                deepFreeze$2(value[keys[i]]);
+            }
+        }
+        ObjectFreeze(value);
+    }
+    function createLink(ref) {
+        return {
+            __ref: engine.serializeStructuredKey(ref),
+        };
+    }
+
+    var VERSION$8 = "68601d043a553523b207d5fcc707e053";
+    function validate$b(obj, path) {
+        if (path === void 0) { path = 'InferenceErrorMessageRepresentation'; }
+        var v_error = (function () {
+            if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+            }
+            var obj_message = obj.message;
+            var path_message = path + '.message';
+            if (typeof obj_message !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_message + '" (at "' + path_message + '")');
+            }
+            var obj_severityLevel = obj.severityLevel;
+            var path_severityLevel = path + '.severityLevel';
+            if (typeof obj_severityLevel !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_severityLevel + '" (at "' + path_severityLevel + '")');
+            }
+        })();
+        return v_error === undefined ? null : v_error;
+    }
+    var select$d = function InferenceErrorMessageRepresentationSelect() {
+        return {
+            kind: 'Fragment',
+            version: VERSION$8,
+            private: [],
+            selections: [
+                {
+                    name: 'message',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'severityLevel',
+                    kind: 'Scalar'
+                }
+            ]
+        };
+    };
+    function equals$8(existing, incoming) {
+        var existing_message = existing.message;
+        var incoming_message = incoming.message;
+        if (!(existing_message === incoming_message)) {
+            return false;
+        }
+        var existing_severityLevel = existing.severityLevel;
+        var incoming_severityLevel = incoming.severityLevel;
+        if (!(existing_severityLevel === incoming_severityLevel)) {
+            return false;
+        }
+        return true;
+    }
+    function deepFreeze$1(input) {
+        ObjectFreeze(input);
+    }
+
+    var VERSION$7 = "d45a6a39072862479f5c25fe921c0926";
+    function validate$a(obj, path) {
+        if (path === void 0) { path = 'DataShapeInferenceOutputRepresentation'; }
+        var v_error = (function () {
+            if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+            }
+            var obj_errorMessages = obj.errorMessages;
+            var path_errorMessages = path + '.errorMessages';
+            if (!ArrayIsArray(obj_errorMessages)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_errorMessages + '" (at "' + path_errorMessages + '")');
+            }
+            for (var i = 0; i < obj_errorMessages.length; i++) {
+                var obj_errorMessages_item = obj_errorMessages[i];
+                var path_errorMessages_item = path_errorMessages + '[' + i + ']';
+                var referencepath_errorMessages_itemValidationError = validate$b(obj_errorMessages_item, path_errorMessages_item);
+                if (referencepath_errorMessages_itemValidationError !== null) {
+                    var message = 'Object doesn\'t match InferenceErrorMessageRepresentation (at "' + path_errorMessages_item + '")\n';
+                    message += referencepath_errorMessages_itemValidationError.message.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                    return new TypeError(message);
+                }
+            }
+            if (obj.example !== undefined) {
+                var obj_example = obj.example;
+                var path_example = path + '.example';
+                if (typeof obj_example !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_example + '" (at "' + path_example + '")');
+                }
+            }
+            var obj_items = obj.items;
+            var path_items = path + '.items';
+            if (!ArrayIsArray(obj_items)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_items + '" (at "' + path_items + '")');
+            }
+            for (var i = 0; i < obj_items.length; i++) {
+                var obj_items_item = obj_items[i];
+                var path_items_item = path_items + '[' + i + ']';
+                var referencepath_items_itemValidationError = validate$a(obj_items_item, path_items_item);
+                if (referencepath_items_itemValidationError !== null) {
+                    var message = 'Object doesn\'t match DataShapeInferenceOutputRepresentation (at "' + path_items_item + '")\n';
+                    message += referencepath_items_itemValidationError.message.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                    return new TypeError(message);
+                }
+            }
+            var obj_properties = obj.properties;
+            var path_properties = path + '.properties';
+            if (typeof obj_properties !== 'object' || ArrayIsArray(obj_properties) || obj_properties === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj_properties + '" (at "' + path_properties + '")');
+            }
+            var obj_properties_keys = ObjectKeys(obj_properties);
+            for (var i = 0; i < obj_properties_keys.length; i++) {
+                var key = obj_properties_keys[i];
+                var obj_properties_prop = obj_properties[key];
+                var path_properties_prop = path_properties + '["' + key + '"]';
+                var referencepath_properties_propValidationError = validate$a(obj_properties_prop, path_properties_prop);
+                if (referencepath_properties_propValidationError !== null) {
+                    var message = 'Object doesn\'t match DataShapeInferenceOutputRepresentation (at "' + path_properties_prop + '")\n';
+                    message += referencepath_properties_propValidationError.message.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                    return new TypeError(message);
+                }
+            }
+            var obj_success = obj.success;
+            var path_success = path + '.success';
+            if (typeof obj_success !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_success + '" (at "' + path_success + '")');
+            }
+            if (obj.type !== undefined) {
+                var obj_type = obj.type;
+                var 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;
+    }
+    var RepresentationType$3 = 'DataShapeInferenceOutputRepresentation';
+    function normalize$3(input, existing, path, luvio, store, timestamp) {
+        return input;
+    }
+    var select$c = function DataShapeInferenceOutputRepresentationSelect() {
+        return {
+            kind: 'Fragment',
+            version: VERSION$7,
+            private: [],
+            opaque: true
+        };
+    };
+    function equals$7(existing, incoming) {
+        if (JSONStringify(incoming) !== JSONStringify(existing)) {
+            return false;
+        }
+        return true;
+    }
+    function deepFreeze(input) {
+        var input_errorMessages = input.errorMessages;
+        for (var i = 0; i < input_errorMessages.length; i++) {
+            var input_errorMessages_item = input_errorMessages[i];
+            deepFreeze$1(input_errorMessages_item);
+        }
+        ObjectFreeze(input_errorMessages);
+        var input_items = input.items;
+        for (var i = 0; i < input_items.length; i++) {
+            var input_items_item = input_items[i];
+            deepFreeze(input_items_item);
+        }
+        ObjectFreeze(input_items);
+        var input_properties = input.properties;
+        var input_properties_keys = Object.keys(input_properties);
+        var input_properties_length = input_properties_keys.length;
+        for (var i = 0; i < input_properties_length; i++) {
+            var key = input_properties_keys[i];
+            var input_properties_prop = input_properties[key];
+            deepFreeze(input_properties_prop);
+        }
+        ObjectFreeze(input_properties);
+        ObjectFreeze(input);
+    }
+    var ingest$3 = function DataShapeInferenceOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+        if (process.env.NODE_ENV !== 'production') {
+            var validateError = validate$a(input);
+            if (validateError !== null) {
+                throw validateError;
+            }
+        }
+        var key = path.fullPath;
+        var existingRecord = store.readEntry(key);
+        var ttlToUse = path.ttl !== undefined ? path.ttl : 300000;
+        var incomingRecord = normalize$3(input, store.readEntry(key), {
+            fullPath: key,
+            parent: path.parent,
+            propertyName: path.propertyName,
+            ttl: ttlToUse
+        });
+        deepFreeze(input);
+        if (existingRecord === undefined || equals$7(existingRecord, incomingRecord) === false) {
+            luvio.storePublish(key, incomingRecord);
+        }
+        if (ttlToUse !== undefined) {
+            var storeMetadataParams = {
+                ttl: ttlToUse,
+                namespace: "external-services",
+                version: VERSION$7,
+                representationName: RepresentationType$3,
+            };
+            luvio.publishStoreMetadata(key, storeMetadataParams);
+        }
+        return createLink(key);
+    };
+    function getTypeCacheKeys$3(luvio, input, fullPathFactory) {
+        var rootKeySet = new engine.StoreKeyMap();
+        // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+        var rootKey = fullPathFactory();
+        rootKeySet.set(rootKey, {
+            namespace: keyPrefix,
+            representationName: RepresentationType$3,
+            mergeable: false
+        });
+        return rootKeySet;
+    }
+
+    function select$b(luvio, params) {
+        return select$c();
+    }
+    function keyBuilder$8(luvio, params) {
+        return keyPrefix + '::DataShapeInferenceOutputRepresentation:(' + 'exampleData:' + params.queryParams.exampleData + ',' + 'mediaType:' + params.queryParams.mediaType + ',' + 'version:' + params.urlParams.version + ')';
+    }
+    function getResponseCacheKeys$4(luvio, resourceParams, response) {
+        return getTypeCacheKeys$3(luvio, response, function () { return keyBuilder$8(luvio, resourceParams); });
+    }
+    function ingestSuccess$4(luvio, resourceParams, response, snapshotRefresh) {
+        var body = response.body;
+        var key = keyBuilder$8(luvio, resourceParams);
+        luvio.storeIngest(key, ingest$3, body);
+        var snapshot = luvio.storeLookup({
+            recordId: key,
+            node: select$b(),
+            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');
+            }
+        }
+        return snapshot;
+    }
+    function ingestError$3(luvio, params, error, snapshotRefresh) {
+        var key = keyBuilder$8(luvio, params);
+        var errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+        luvio.storeIngestError(key, errorSnapshot);
+        return errorSnapshot;
+    }
+    function createResourceRequest$4(config) {
+        var headers = {};
+        return {
+            baseUri: '/services/data/v58.0',
+            basePath: '/externalservices/inference/datashape/' + config.urlParams.version + '',
+            method: 'post',
+            body: null,
+            urlParams: config.urlParams,
+            queryParams: config.queryParams,
+            headers: headers,
+            priority: 'normal',
+        };
+    }
+
+    var getDataShape_ConfigPropertyNames = {
+        displayName: 'getDataShape',
+        parameters: {
+            required: ['version'],
+            optional: ['exampleData', 'mediaType']
+        }
+    };
+    function createResourceParams$4(config) {
+        var resourceParams = {
+            urlParams: {
+                version: config.version
+            },
+            queryParams: {
+                exampleData: config.exampleData, mediaType: config.mediaType
+            }
+        };
+        return resourceParams;
+    }
+    function keyBuilder$7(luvio, config) {
+        var resourceParams = createResourceParams$4(config);
+        return keyBuilder$8(luvio, resourceParams);
+    }
+    function typeCheckConfig$4(untrustedConfig) {
+        var config = {};
+        var untrustedConfig_version = untrustedConfig.version;
+        if (typeof untrustedConfig_version === 'string') {
+            config.version = untrustedConfig_version;
+        }
+        var untrustedConfig_exampleData = untrustedConfig.exampleData;
+        if (typeof untrustedConfig_exampleData === 'string') {
+            config.exampleData = untrustedConfig_exampleData;
+        }
+        var untrustedConfig_mediaType = untrustedConfig.mediaType;
+        if (typeof untrustedConfig_mediaType === 'string') {
+            config.mediaType = untrustedConfig_mediaType;
+        }
+        return config;
+    }
+    function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
+        if (!untrustedIsObject(untrustedConfig)) {
+            return null;
+        }
+        if (process.env.NODE_ENV !== 'production') {
+            validateConfig(untrustedConfig, configPropertyNames);
+        }
+        var config = typeCheckConfig$4(untrustedConfig);
+        if (!areRequiredParametersPresent(config, configPropertyNames)) {
+            return null;
+        }
+        return config;
+    }
+    function adapterFragment$3(luvio, config) {
+        createResourceParams$4(config);
+        return select$b();
+    }
+    function onFetchResponseSuccess$3(luvio, config, resourceParams, response) {
+        var snapshot = ingestSuccess$4(luvio, resourceParams, response, {
+            config: config,
+            resolve: function () { return buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions); }
+        });
+        return luvio.storeBroadcast().then(function () { return snapshot; });
+    }
+    function onFetchResponseError$3(luvio, config, resourceParams, response) {
+        var snapshot = ingestError$3(luvio, resourceParams, response, {
+            config: config,
+            resolve: function () { return buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions); }
+        });
+        return luvio.storeBroadcast().then(function () { return snapshot; });
+    }
+    function buildNetworkSnapshot$4(luvio, config, options) {
+        var resourceParams = createResourceParams$4(config);
+        var request = createResourceRequest$4(resourceParams);
+        return luvio.dispatchResourceRequest(request, options)
+            .then(function (response) {
+            return luvio.handleSuccessResponse(function () { return onFetchResponseSuccess$3(luvio, config, resourceParams, response); }, function () { return getResponseCacheKeys$4(luvio, resourceParams, response.body); });
+        }, function (response) {
+            return luvio.handleErrorResponse(function () { return onFetchResponseError$3(luvio, config, resourceParams, response); });
+        });
+    }
+    function buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext) {
+        var luvio = context.luvio, config = context.config;
+        var networkPriority = coercedAdapterRequestContext.networkPriority, requestCorrelator = coercedAdapterRequestContext.requestCorrelator, eventObservers = coercedAdapterRequestContext.eventObservers;
+        var dispatchOptions = {
+            resourceRequestContext: {
+                requestCorrelator: requestCorrelator,
+                luvioRequestMethod: 'get',
+            },
+            eventObservers: eventObservers
+        };
+        if (networkPriority !== 'normal') {
+            dispatchOptions.overrides = {
+                priority: networkPriority
+            };
+        }
+        return buildNetworkSnapshot$4(luvio, config, dispatchOptions);
+    }
+    function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
+        var luvio = context.luvio, config = context.config;
+        var selector = {
+            recordId: keyBuilder$7(luvio, config),
+            node: adapterFragment$3(luvio, config),
+            variables: {},
+        };
+        var cacheSnapshot = storeLookup(selector, {
+            config: config,
+            resolve: function () { return buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions); }
+        });
+        return cacheSnapshot;
+    }
+    var getDataShapeAdapterFactory = function (luvio) { return function externalServices__getDataShape(untrustedConfig, requestContext) {
+        var config = validateAdapterConfig$4(untrustedConfig, getDataShape_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            return null;
+        }
+        return luvio.applyCachePolicy((requestContext || {}), { config: config, luvio: luvio }, // BuildSnapshotContext
+        buildCachedSnapshotCachePolicy$3, buildNetworkSnapshotCachePolicy$3);
+    }; };
+
+    function validate$9(obj, path) {
+        if (path === void 0) { path = 'OpenApiSpecInferenceParameterRepresentation'; }
+        var v_error = (function () {
+            if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+            }
+            if (obj.description !== undefined) {
+                var obj_description = obj.description;
+                var path_description = path + '.description';
+                if (typeof obj_description !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_description + '" (at "' + path_description + '")');
+                }
+            }
+            var obj_location = obj.location;
+            var path_location = path + '.location';
+            if (typeof obj_location !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_location + '" (at "' + path_location + '")');
+            }
+            var obj_name = obj.name;
+            var path_name = path + '.name';
+            if (typeof obj_name !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
+            }
+            var obj_required = obj.required;
+            var path_required = path + '.required';
+            if (typeof obj_required !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_required + '" (at "' + path_required + '")');
+            }
+            var obj_type = obj.type;
+            var 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$8(obj, path) {
+        if (path === void 0) { path = 'OpenApiSpecInferenceInputRepresentation'; }
+        var v_error = (function () {
+            if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+            }
+            var obj_description = obj.description;
+            var path_description = path + '.description';
+            if (typeof obj_description !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_description + '" (at "' + path_description + '")');
+            }
+            if (obj.externalServiceId !== undefined) {
+                var obj_externalServiceId = obj.externalServiceId;
+                var path_externalServiceId = path + '.externalServiceId';
+                if (typeof obj_externalServiceId !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_externalServiceId + '" (at "' + path_externalServiceId + '")');
+                }
+            }
+            var obj_method = obj.method;
+            var path_method = path + '.method';
+            if (typeof obj_method !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_method + '" (at "' + path_method + '")');
+            }
+            var obj_name = obj.name;
+            var path_name = path + '.name';
+            if (typeof obj_name !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
+            }
+            var obj_operationDescription = obj.operationDescription;
+            var path_operationDescription = path + '.operationDescription';
+            if (typeof obj_operationDescription !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_operationDescription + '" (at "' + path_operationDescription + '")');
+            }
+            var obj_operationName = obj.operationName;
+            var path_operationName = path + '.operationName';
+            if (typeof obj_operationName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_operationName + '" (at "' + path_operationName + '")');
+            }
+            var obj_parameters = obj.parameters;
+            var path_parameters = path + '.parameters';
+            if (!ArrayIsArray(obj_parameters)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_parameters + '" (at "' + path_parameters + '")');
+            }
+            for (var i = 0; i < obj_parameters.length; i++) {
+                var obj_parameters_item = obj_parameters[i];
+                var path_parameters_item = path_parameters + '[' + i + ']';
+                var referencepath_parameters_itemValidationError = validate$9(obj_parameters_item, path_parameters_item);
+                if (referencepath_parameters_itemValidationError !== null) {
+                    var message = 'Object doesn\'t match OpenApiSpecInferenceParameterRepresentation (at "' + path_parameters_item + '")\n';
+                    message += referencepath_parameters_itemValidationError.message.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                    return new TypeError(message);
+                }
+            }
+            var obj_path = obj.path;
+            var path_path = path + '.path';
+            if (typeof obj_path !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_path + '" (at "' + path_path + '")');
+            }
+            if (obj.requestBody !== undefined) {
+                var obj_requestBody = obj.requestBody;
+                var path_requestBody = path + '.requestBody';
+                if (typeof obj_requestBody !== 'object' || ArrayIsArray(obj_requestBody) || obj_requestBody === null) {
+                    return new TypeError('Expected "object" but received "' + typeof obj_requestBody + '" (at "' + path_requestBody + '")');
+                }
+            }
+            var obj_responseBody = obj.responseBody;
+            var path_responseBody = path + '.responseBody';
+            if (typeof obj_responseBody !== 'object' || ArrayIsArray(obj_responseBody) || obj_responseBody === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj_responseBody + '" (at "' + path_responseBody + '")');
+            }
+        })();
+        return v_error === undefined ? null : v_error;
+    }
+
+    var VERSION$6 = "9f5779e32b8c9e02976609db89831dbb";
+    function validate$7(obj, path) {
+        if (path === void 0) { path = 'OpenApiSpecInferenceOutputRepresentation'; }
+        var v_error = (function () {
+            if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+            }
+            var obj_errorMessages = obj.errorMessages;
+            var path_errorMessages = path + '.errorMessages';
+            if (!ArrayIsArray(obj_errorMessages)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_errorMessages + '" (at "' + path_errorMessages + '")');
+            }
+            for (var i = 0; i < obj_errorMessages.length; i++) {
+                var obj_errorMessages_item = obj_errorMessages[i];
+                var path_errorMessages_item = path_errorMessages + '[' + i + ']';
+                var referencepath_errorMessages_itemValidationError = validate$b(obj_errorMessages_item, path_errorMessages_item);
+                if (referencepath_errorMessages_itemValidationError !== null) {
+                    var message = 'Object doesn\'t match InferenceErrorMessageRepresentation (at "' + path_errorMessages_item + '")\n';
+                    message += referencepath_errorMessages_itemValidationError.message.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                    return new TypeError(message);
+                }
+            }
+            var obj_schema = obj.schema;
+            var path_schema = path + '.schema';
+            if (typeof obj_schema !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_schema + '" (at "' + path_schema + '")');
+            }
+            var obj_success = obj.success;
+            var path_success = path + '.success';
+            if (typeof obj_success !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_success + '" (at "' + path_success + '")');
+            }
+        })();
+        return v_error === undefined ? null : v_error;
+    }
+    var RepresentationType$2 = 'OpenApiSpecInferenceOutputRepresentation';
+    function normalize$2(input, existing, path, luvio, store, timestamp) {
+        return input;
+    }
+    var select$a = function OpenApiSpecInferenceOutputRepresentationSelect() {
+        var _a = select$d(), InferenceErrorMessageRepresentation__selections = _a.selections;
+        return {
+            kind: 'Fragment',
+            version: VERSION$6,
+            private: [],
+            selections: [
+                {
+                    name: 'errorMessages',
+                    kind: 'Object',
+                    plural: true,
+                    selections: InferenceErrorMessageRepresentation__selections
+                },
+                {
+                    name: 'schema',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'success',
+                    kind: 'Scalar'
+                }
+            ]
+        };
+    };
+    function equals$6(existing, incoming) {
+        var existing_success = existing.success;
+        var incoming_success = incoming.success;
+        if (!(existing_success === incoming_success)) {
+            return false;
+        }
+        var existing_schema = existing.schema;
+        var incoming_schema = incoming.schema;
+        if (!(existing_schema === incoming_schema)) {
+            return false;
+        }
+        var existing_errorMessages = existing.errorMessages;
+        var incoming_errorMessages = incoming.errorMessages;
+        var equals_errorMessages_items = equalsArray(existing_errorMessages, incoming_errorMessages, function (existing_errorMessages_item, incoming_errorMessages_item) {
+            if (!(equals$8(existing_errorMessages_item, incoming_errorMessages_item))) {
+                return false;
+            }
+        });
+        if (equals_errorMessages_items === false) {
+            return false;
+        }
+        return true;
+    }
+    var ingest$2 = function OpenApiSpecInferenceOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+        if (process.env.NODE_ENV !== 'production') {
+            var validateError = validate$7(input);
+            if (validateError !== null) {
+                throw validateError;
+            }
+        }
+        var key = path.fullPath;
+        var existingRecord = store.readEntry(key);
+        var ttlToUse = path.ttl !== undefined ? path.ttl : 300000;
+        var incomingRecord = normalize$2(input, store.readEntry(key), {
+            fullPath: key,
+            parent: path.parent,
+            propertyName: path.propertyName,
+            ttl: ttlToUse
+        });
+        if (existingRecord === undefined || equals$6(existingRecord, incomingRecord) === false) {
+            luvio.storePublish(key, incomingRecord);
+        }
+        if (ttlToUse !== undefined) {
+            var storeMetadataParams = {
+                ttl: ttlToUse,
+                namespace: "external-services",
+                version: VERSION$6,
+                representationName: RepresentationType$2,
+            };
+            luvio.publishStoreMetadata(key, storeMetadataParams);
+        }
+        return createLink(key);
+    };
+    function getTypeCacheKeys$2(luvio, input, fullPathFactory) {
+        var rootKeySet = new engine.StoreKeyMap();
+        // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+        var rootKey = fullPathFactory();
+        rootKeySet.set(rootKey, {
+            namespace: keyPrefix,
+            representationName: RepresentationType$2,
+            mergeable: false
+        });
+        return rootKeySet;
+    }
+
+    function select$9(luvio, params) {
+        return select$a();
+    }
+    function keyBuilder$6(luvio, params) {
+        return keyPrefix + '::OpenApiSpecInferenceOutputRepresentation:(' + 'version:' + params.urlParams.version + ',' + 'input.description:' + params.body.input.description + '::' + (params.body.input.externalServiceId === undefined ? 'input.externalServiceId' : 'input.externalServiceId:' + params.body.input.externalServiceId) + '::' + 'input.method:' + params.body.input.method + '::' + 'input.name:' + params.body.input.name + '::' + 'input.operationDescription:' + params.body.input.operationDescription + '::' + 'input.operationName:' + params.body.input.operationName + '::' + 'input.parameters:' + params.body.input.parameters + '::' + 'input.path:' + params.body.input.path + '::' + +'::' + +')';
+    }
+    function getResponseCacheKeys$3(luvio, resourceParams, response) {
+        return getTypeCacheKeys$2(luvio, response, function () { return keyBuilder$6(luvio, resourceParams); });
+    }
+    function ingestSuccess$3(luvio, resourceParams, response, snapshotRefresh) {
+        var body = response.body;
+        var key = keyBuilder$6(luvio, resourceParams);
+        luvio.storeIngest(key, ingest$2, body);
+        var snapshot = luvio.storeLookup({
+            recordId: key,
+            node: select$9(),
+            variables: {},
+        }, snapshotRefresh);
+        if (process.env.NODE_ENV !== 'production') {
+            if (snapshot.state !== 'Fulfilled') {
+                throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+            }
+        }
+        return snapshot;
+    }
+    function ingestError$2(luvio, params, error, snapshotRefresh) {
+        var key = keyBuilder$6(luvio, params);
+        var errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+        luvio.storeIngestError(key, errorSnapshot);
+        return errorSnapshot;
+    }
+    function createResourceRequest$3(config) {
+        var headers = {};
+        return {
+            baseUri: '/services/data/v58.0',
+            basePath: '/externalservices/inference/openapispec/' + config.urlParams.version + '',
+            method: 'post',
+            body: config.body,
+            urlParams: config.urlParams,
+            queryParams: {},
+            headers: headers,
+            priority: 'normal',
+        };
+    }
+
+    var getOpenApiSpec_ConfigPropertyNames = {
+        displayName: 'getOpenApiSpec',
+        parameters: {
+            required: ['version', 'input'],
+            optional: []
+        }
+    };
+    function createResourceParams$3(config) {
+        var resourceParams = {
+            urlParams: {
+                version: config.version
+            },
+            body: {
+                input: config.input
+            }
+        };
+        return resourceParams;
+    }
+    function keyBuilder$5(luvio, config) {
+        var resourceParams = createResourceParams$3(config);
+        return keyBuilder$6(luvio, resourceParams);
+    }
+    function typeCheckConfig$3(untrustedConfig) {
+        var config = {};
+        var untrustedConfig_version = untrustedConfig.version;
+        if (typeof untrustedConfig_version === 'string') {
+            config.version = untrustedConfig_version;
+        }
+        var untrustedConfig_input = untrustedConfig.input;
+        var referenceOpenApiSpecInferenceInputRepresentationValidationError = validate$8(untrustedConfig_input);
+        if (referenceOpenApiSpecInferenceInputRepresentationValidationError === null) {
+            config.input = untrustedConfig_input;
+        }
+        return config;
+    }
+    function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
+        if (!untrustedIsObject(untrustedConfig)) {
+            return null;
+        }
+        if (process.env.NODE_ENV !== 'production') {
+            validateConfig(untrustedConfig, configPropertyNames);
+        }
+        var config = typeCheckConfig$3(untrustedConfig);
+        if (!areRequiredParametersPresent(config, configPropertyNames)) {
+            return null;
+        }
+        return config;
+    }
+    function adapterFragment$2(luvio, config) {
+        createResourceParams$3(config);
+        return select$9();
+    }
+    function onFetchResponseSuccess$2(luvio, config, resourceParams, response) {
+        var snapshot = ingestSuccess$3(luvio, resourceParams, response, {
+            config: config,
+            resolve: function () { return buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions); }
+        });
+        return luvio.storeBroadcast().then(function () { return snapshot; });
+    }
+    function onFetchResponseError$2(luvio, config, resourceParams, response) {
+        var snapshot = ingestError$2(luvio, resourceParams, response, {
+            config: config,
+            resolve: function () { return buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions); }
+        });
+        return luvio.storeBroadcast().then(function () { return snapshot; });
+    }
+    function buildNetworkSnapshot$3(luvio, config, options) {
+        var resourceParams = createResourceParams$3(config);
+        var request = createResourceRequest$3(resourceParams);
+        return luvio.dispatchResourceRequest(request, options)
+            .then(function (response) {
+            return luvio.handleSuccessResponse(function () { return onFetchResponseSuccess$2(luvio, config, resourceParams, response); }, function () { return getResponseCacheKeys$3(luvio, resourceParams, response.body); });
+        }, function (response) {
+            return luvio.handleErrorResponse(function () { return onFetchResponseError$2(luvio, config, resourceParams, response); });
+        });
+    }
+    function buildNetworkSnapshotCachePolicy$2(context, coercedAdapterRequestContext) {
+        var luvio = context.luvio, config = context.config;
+        var networkPriority = coercedAdapterRequestContext.networkPriority, requestCorrelator = coercedAdapterRequestContext.requestCorrelator, eventObservers = coercedAdapterRequestContext.eventObservers;
+        var dispatchOptions = {
+            resourceRequestContext: {
+                requestCorrelator: requestCorrelator,
+                luvioRequestMethod: 'get',
+            },
+            eventObservers: eventObservers
+        };
+        if (networkPriority !== 'normal') {
+            dispatchOptions.overrides = {
+                priority: networkPriority
+            };
+        }
+        return buildNetworkSnapshot$3(luvio, config, dispatchOptions);
+    }
+    function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
+        var luvio = context.luvio, config = context.config;
+        var selector = {
+            recordId: keyBuilder$5(luvio, config),
+            node: adapterFragment$2(luvio, config),
+            variables: {},
+        };
+        var cacheSnapshot = storeLookup(selector, {
+            config: config,
+            resolve: function () { return buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions); }
+        });
+        return cacheSnapshot;
+    }
+    var getOpenApiSpecAdapterFactory = function (luvio) { return function externalServices__getOpenApiSpec(untrustedConfig, requestContext) {
+        var config = validateAdapterConfig$3(untrustedConfig, getOpenApiSpec_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            return null;
+        }
+        return luvio.applyCachePolicy((requestContext || {}), { config: config, luvio: luvio }, // BuildSnapshotContext
+        buildCachedSnapshotCachePolicy$2, buildNetworkSnapshotCachePolicy$2);
+    }; };
+
+    function validate$6(obj, path) {
+        if (path === void 0) { path = 'SchemaValidationInputRepresentation'; }
+        var v_error = (function () {
+            if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+            }
+            var obj_schema = obj.schema;
+            var path_schema = path + '.schema';
+            if (typeof obj_schema !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_schema + '" (at "' + path_schema + '")');
+            }
+            var obj_schemaName = obj.schemaName;
+            var path_schemaName = path + '.schemaName';
+            if (typeof obj_schemaName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_schemaName + '" (at "' + path_schemaName + '")');
+            }
+            var obj_systemVersion = obj.systemVersion;
+            var path_systemVersion = path + '.systemVersion';
+            if (typeof obj_systemVersion !== 'number' || (typeof obj_systemVersion === 'number' && Math.floor(obj_systemVersion) !== obj_systemVersion)) {
+                return new TypeError('Expected "integer" but received "' + typeof obj_systemVersion + '" (at "' + path_systemVersion + '")');
+            }
+        })();
+        return v_error === undefined ? null : v_error;
+    }
+
+    var VERSION$5 = "970029a80f127a32c6e30cda09b02a11";
+    function validate$5(obj, path) {
+        if (path === void 0) { path = 'SchemaValidationMessageRepresentation'; }
+        var v_error = (function () {
+            if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+            }
+            if (obj.endColumn !== undefined) {
+                var obj_endColumn_1 = obj.endColumn;
+                var path_endColumn_1 = path + '.endColumn';
+                var obj_endColumn_union0 = null;
+                var obj_endColumn_union0_error = (function () {
+                    if (typeof obj_endColumn_1 !== 'number' || (typeof obj_endColumn_1 === 'number' && Math.floor(obj_endColumn_1) !== obj_endColumn_1)) {
+                        return new TypeError('Expected "integer" but received "' + typeof obj_endColumn_1 + '" (at "' + path_endColumn_1 + '")');
+                    }
+                })();
+                if (obj_endColumn_union0_error != null) {
+                    obj_endColumn_union0 = obj_endColumn_union0_error.message;
+                }
+                var obj_endColumn_union1 = null;
+                var obj_endColumn_union1_error = (function () {
+                    if (obj_endColumn_1 !== null) {
+                        return new TypeError('Expected "null" but received "' + typeof obj_endColumn_1 + '" (at "' + path_endColumn_1 + '")');
+                    }
+                })();
+                if (obj_endColumn_union1_error != null) {
+                    obj_endColumn_union1 = obj_endColumn_union1_error.message;
+                }
+                if (obj_endColumn_union0 && obj_endColumn_union1) {
+                    var message = 'Object doesn\'t match union (at "' + path_endColumn_1 + '")';
+                    message += '\n' + obj_endColumn_union0.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                    message += '\n' + obj_endColumn_union1.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                    return new TypeError(message);
+                }
+            }
+            if (obj.endLine !== undefined) {
+                var obj_endLine_1 = obj.endLine;
+                var path_endLine_1 = path + '.endLine';
+                var obj_endLine_union0 = null;
+                var obj_endLine_union0_error = (function () {
+                    if (typeof obj_endLine_1 !== 'number' || (typeof obj_endLine_1 === 'number' && Math.floor(obj_endLine_1) !== obj_endLine_1)) {
+                        return new TypeError('Expected "integer" but received "' + typeof obj_endLine_1 + '" (at "' + path_endLine_1 + '")');
+                    }
+                })();
+                if (obj_endLine_union0_error != null) {
+                    obj_endLine_union0 = obj_endLine_union0_error.message;
+                }
+                var obj_endLine_union1 = null;
+                var obj_endLine_union1_error = (function () {
+                    if (obj_endLine_1 !== null) {
+                        return new TypeError('Expected "null" but received "' + typeof obj_endLine_1 + '" (at "' + path_endLine_1 + '")');
+                    }
+                })();
+                if (obj_endLine_union1_error != null) {
+                    obj_endLine_union1 = obj_endLine_union1_error.message;
+                }
+                if (obj_endLine_union0 && obj_endLine_union1) {
+                    var message = 'Object doesn\'t match union (at "' + path_endLine_1 + '")';
+                    message += '\n' + obj_endLine_union0.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                    message += '\n' + obj_endLine_union1.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                    return new TypeError(message);
+                }
+            }
+            if (obj.endPosition !== undefined) {
+                var obj_endPosition_1 = obj.endPosition;
+                var path_endPosition_1 = path + '.endPosition';
+                var obj_endPosition_union0 = null;
+                var obj_endPosition_union0_error = (function () {
+                    if (typeof obj_endPosition_1 !== 'number' || (typeof obj_endPosition_1 === 'number' && Math.floor(obj_endPosition_1) !== obj_endPosition_1)) {
+                        return new TypeError('Expected "integer" but received "' + typeof obj_endPosition_1 + '" (at "' + path_endPosition_1 + '")');
+                    }
+                })();
+                if (obj_endPosition_union0_error != null) {
+                    obj_endPosition_union0 = obj_endPosition_union0_error.message;
+                }
+                var obj_endPosition_union1 = null;
+                var obj_endPosition_union1_error = (function () {
+                    if (obj_endPosition_1 !== null) {
+                        return new TypeError('Expected "null" but received "' + typeof obj_endPosition_1 + '" (at "' + path_endPosition_1 + '")');
+                    }
+                })();
+                if (obj_endPosition_union1_error != null) {
+                    obj_endPosition_union1 = obj_endPosition_union1_error.message;
+                }
+                if (obj_endPosition_union0 && obj_endPosition_union1) {
+                    var message = 'Object doesn\'t match union (at "' + path_endPosition_1 + '")';
+                    message += '\n' + obj_endPosition_union0.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                    message += '\n' + obj_endPosition_union1.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                    return new TypeError(message);
+                }
+            }
+            var obj_message = obj.message;
+            var path_message = path + '.message';
+            if (typeof obj_message !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_message + '" (at "' + path_message + '")');
+            }
+            if (obj.startColumn !== undefined) {
+                var obj_startColumn_1 = obj.startColumn;
+                var path_startColumn_1 = path + '.startColumn';
+                var obj_startColumn_union0 = null;
+                var obj_startColumn_union0_error = (function () {
+                    if (typeof obj_startColumn_1 !== 'number' || (typeof obj_startColumn_1 === 'number' && Math.floor(obj_startColumn_1) !== obj_startColumn_1)) {
+                        return new TypeError('Expected "integer" but received "' + typeof obj_startColumn_1 + '" (at "' + path_startColumn_1 + '")');
+                    }
+                })();
+                if (obj_startColumn_union0_error != null) {
+                    obj_startColumn_union0 = obj_startColumn_union0_error.message;
+                }
+                var obj_startColumn_union1 = null;
+                var obj_startColumn_union1_error = (function () {
+                    if (obj_startColumn_1 !== null) {
+                        return new TypeError('Expected "null" but received "' + typeof obj_startColumn_1 + '" (at "' + path_startColumn_1 + '")');
+                    }
+                })();
+                if (obj_startColumn_union1_error != null) {
+                    obj_startColumn_union1 = obj_startColumn_union1_error.message;
+                }
+                if (obj_startColumn_union0 && obj_startColumn_union1) {
+                    var message = 'Object doesn\'t match union (at "' + path_startColumn_1 + '")';
+                    message += '\n' + obj_startColumn_union0.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                    message += '\n' + obj_startColumn_union1.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                    return new TypeError(message);
+                }
+            }
+            if (obj.startLine !== undefined) {
+                var obj_startLine_1 = obj.startLine;
+                var path_startLine_1 = path + '.startLine';
+                var obj_startLine_union0 = null;
+                var obj_startLine_union0_error = (function () {
+                    if (typeof obj_startLine_1 !== 'number' || (typeof obj_startLine_1 === 'number' && Math.floor(obj_startLine_1) !== obj_startLine_1)) {
+                        return new TypeError('Expected "integer" but received "' + typeof obj_startLine_1 + '" (at "' + path_startLine_1 + '")');
+                    }
+                })();
+                if (obj_startLine_union0_error != null) {
+                    obj_startLine_union0 = obj_startLine_union0_error.message;
+                }
+                var obj_startLine_union1 = null;
+                var obj_startLine_union1_error = (function () {
+                    if (obj_startLine_1 !== null) {
+                        return new TypeError('Expected "null" but received "' + typeof obj_startLine_1 + '" (at "' + path_startLine_1 + '")');
+                    }
+                })();
+                if (obj_startLine_union1_error != null) {
+                    obj_startLine_union1 = obj_startLine_union1_error.message;
+                }
+                if (obj_startLine_union0 && obj_startLine_union1) {
+                    var message = 'Object doesn\'t match union (at "' + path_startLine_1 + '")';
+                    message += '\n' + obj_startLine_union0.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                    message += '\n' + obj_startLine_union1.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                    return new TypeError(message);
+                }
+            }
+            if (obj.startPosition !== undefined) {
+                var obj_startPosition_1 = obj.startPosition;
+                var path_startPosition_1 = path + '.startPosition';
+                var obj_startPosition_union0 = null;
+                var obj_startPosition_union0_error = (function () {
+                    if (typeof obj_startPosition_1 !== 'number' || (typeof obj_startPosition_1 === 'number' && Math.floor(obj_startPosition_1) !== obj_startPosition_1)) {
+                        return new TypeError('Expected "integer" but received "' + typeof obj_startPosition_1 + '" (at "' + path_startPosition_1 + '")');
+                    }
+                })();
+                if (obj_startPosition_union0_error != null) {
+                    obj_startPosition_union0 = obj_startPosition_union0_error.message;
+                }
+                var obj_startPosition_union1 = null;
+                var obj_startPosition_union1_error = (function () {
+                    if (obj_startPosition_1 !== null) {
+                        return new TypeError('Expected "null" but received "' + typeof obj_startPosition_1 + '" (at "' + path_startPosition_1 + '")');
+                    }
+                })();
+                if (obj_startPosition_union1_error != null) {
+                    obj_startPosition_union1 = obj_startPosition_union1_error.message;
+                }
+                if (obj_startPosition_union0 && obj_startPosition_union1) {
+                    var message = 'Object doesn\'t match union (at "' + path_startPosition_1 + '")';
+                    message += '\n' + obj_startPosition_union0.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                    message += '\n' + obj_startPosition_union1.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                    return new TypeError(message);
+                }
+            }
+            var obj_validationClass = obj.validationClass;
+            var path_validationClass = path + '.validationClass';
+            if (typeof obj_validationClass !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_validationClass + '" (at "' + path_validationClass + '")');
+            }
+            var obj_validationLevel = obj.validationLevel;
+            var path_validationLevel = path + '.validationLevel';
+            if (typeof obj_validationLevel !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_validationLevel + '" (at "' + path_validationLevel + '")');
+            }
+        })();
+        return v_error === undefined ? null : v_error;
+    }
+    var select$8 = function SchemaValidationMessageRepresentationSelect() {
+        return {
+            kind: 'Fragment',
+            version: VERSION$5,
+            private: [],
+            selections: [
+                {
+                    name: 'endColumn',
+                    kind: 'Scalar',
+                    required: false
+                },
+                {
+                    name: 'endLine',
+                    kind: 'Scalar',
+                    required: false
+                },
+                {
+                    name: 'endPosition',
+                    kind: 'Scalar',
+                    required: false
+                },
+                {
+                    name: 'message',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'startColumn',
+                    kind: 'Scalar',
+                    required: false
+                },
+                {
+                    name: 'startLine',
+                    kind: 'Scalar',
+                    required: false
+                },
+                {
+                    name: 'startPosition',
+                    kind: 'Scalar',
+                    required: false
+                },
+                {
+                    name: 'validationClass',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'validationLevel',
+                    kind: 'Scalar'
+                }
+            ]
+        };
+    };
+    function equals$5(existing, incoming) {
+        var existing_message = existing.message;
+        var incoming_message = incoming.message;
+        if (!(existing_message === incoming_message)) {
+            return false;
+        }
+        var existing_validationClass = existing.validationClass;
+        var incoming_validationClass = incoming.validationClass;
+        if (!(existing_validationClass === incoming_validationClass)) {
+            return false;
+        }
+        var existing_validationLevel = existing.validationLevel;
+        var incoming_validationLevel = incoming.validationLevel;
+        if (!(existing_validationLevel === incoming_validationLevel)) {
+            return false;
+        }
+        var existing_endColumn = existing.endColumn;
+        var incoming_endColumn = incoming.endColumn;
+        // if at least one of these optionals is defined
+        if (existing_endColumn !== undefined || incoming_endColumn !== undefined) {
+            // if one of these is not defined we know the other is defined and therefore
+            // not equal
+            if (existing_endColumn === undefined || incoming_endColumn === undefined) {
+                return false;
+            }
+            if (!(existing_endColumn === incoming_endColumn)) {
+                return false;
+            }
+        }
+        var existing_endLine = existing.endLine;
+        var incoming_endLine = incoming.endLine;
+        // if at least one of these optionals is defined
+        if (existing_endLine !== undefined || incoming_endLine !== undefined) {
+            // if one of these is not defined we know the other is defined and therefore
+            // not equal
+            if (existing_endLine === undefined || incoming_endLine === undefined) {
+                return false;
+            }
+            if (!(existing_endLine === incoming_endLine)) {
+                return false;
+            }
+        }
+        var existing_endPosition = existing.endPosition;
+        var incoming_endPosition = incoming.endPosition;
+        // if at least one of these optionals is defined
+        if (existing_endPosition !== undefined || incoming_endPosition !== undefined) {
+            // if one of these is not defined we know the other is defined and therefore
+            // not equal
+            if (existing_endPosition === undefined || incoming_endPosition === undefined) {
+                return false;
+            }
+            if (!(existing_endPosition === incoming_endPosition)) {
+                return false;
+            }
+        }
+        var existing_startColumn = existing.startColumn;
+        var incoming_startColumn = incoming.startColumn;
+        // if at least one of these optionals is defined
+        if (existing_startColumn !== undefined || incoming_startColumn !== undefined) {
+            // if one of these is not defined we know the other is defined and therefore
+            // not equal
+            if (existing_startColumn === undefined || incoming_startColumn === undefined) {
+                return false;
+            }
+            if (!(existing_startColumn === incoming_startColumn)) {
+                return false;
+            }
+        }
+        var existing_startLine = existing.startLine;
+        var incoming_startLine = incoming.startLine;
+        // if at least one of these optionals is defined
+        if (existing_startLine !== undefined || incoming_startLine !== undefined) {
+            // if one of these is not defined we know the other is defined and therefore
+            // not equal
+            if (existing_startLine === undefined || incoming_startLine === undefined) {
+                return false;
+            }
+            if (!(existing_startLine === incoming_startLine)) {
+                return false;
+            }
+        }
+        var existing_startPosition = existing.startPosition;
+        var incoming_startPosition = incoming.startPosition;
+        // if at least one of these optionals is defined
+        if (existing_startPosition !== undefined || incoming_startPosition !== undefined) {
+            // if one of these is not defined we know the other is defined and therefore
+            // not equal
+            if (existing_startPosition === undefined || incoming_startPosition === undefined) {
+                return false;
+            }
+            if (!(existing_startPosition === incoming_startPosition)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    var VERSION$4 = "056d3062f884a64afdf97b374daf2e75";
+    function validate$4(obj, path) {
+        if (path === void 0) { path = 'SchemaValidationOutputRepresentation'; }
+        var v_error = (function () {
+            if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+            }
+            var obj_schemaName = obj.schemaName;
+            var path_schemaName = path + '.schemaName';
+            if (typeof obj_schemaName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_schemaName + '" (at "' + path_schemaName + '")');
+            }
+            var obj_schemaSize = obj.schemaSize;
+            var path_schemaSize = path + '.schemaSize';
+            if (typeof obj_schemaSize !== 'number' || (typeof obj_schemaSize === 'number' && Math.floor(obj_schemaSize) !== obj_schemaSize)) {
+                return new TypeError('Expected "integer" but received "' + typeof obj_schemaSize + '" (at "' + path_schemaSize + '")');
+            }
+            var obj_schemaType = obj.schemaType;
+            var path_schemaType = path + '.schemaType';
+            if (typeof obj_schemaType !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_schemaType + '" (at "' + path_schemaType + '")');
+            }
+            var obj_schemaValidation = obj.schemaValidation;
+            var path_schemaValidation = path + '.schemaValidation';
+            if (!ArrayIsArray(obj_schemaValidation)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_schemaValidation + '" (at "' + path_schemaValidation + '")');
+            }
+            for (var i = 0; i < obj_schemaValidation.length; i++) {
+                var obj_schemaValidation_item = obj_schemaValidation[i];
+                var path_schemaValidation_item = path_schemaValidation + '[' + i + ']';
+                var referencepath_schemaValidation_itemValidationError = validate$5(obj_schemaValidation_item, path_schemaValidation_item);
+                if (referencepath_schemaValidation_itemValidationError !== null) {
+                    var message = 'Object doesn\'t match SchemaValidationMessageRepresentation (at "' + path_schemaValidation_item + '")\n';
+                    message += referencepath_schemaValidation_itemValidationError.message.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                    return new TypeError(message);
+                }
+            }
+            var obj_systemVersion = obj.systemVersion;
+            var path_systemVersion = path + '.systemVersion';
+            if (typeof obj_systemVersion !== 'number' || (typeof obj_systemVersion === 'number' && Math.floor(obj_systemVersion) !== obj_systemVersion)) {
+                return new TypeError('Expected "integer" but received "' + typeof obj_systemVersion + '" (at "' + path_systemVersion + '")');
+            }
+        })();
+        return v_error === undefined ? null : v_error;
+    }
+    var RepresentationType$1 = 'SchemaValidationOutputRepresentation';
+    function keyBuilder$4(luvio, config) {
+        return keyPrefix + '::' + RepresentationType$1 + ':' + config.schemaName;
+    }
+    function keyBuilderFromType(luvio, object) {
+        var keyParams = {
+            schemaName: object.schemaName
+        };
+        return keyBuilder$4(luvio, keyParams);
+    }
+    function normalize$1(input, existing, path, luvio, store, timestamp) {
+        return input;
+    }
+    var select$7 = function SchemaValidationOutputRepresentationSelect() {
+        var _a = select$8(), SchemaValidationMessageRepresentation__selections = _a.selections;
+        return {
+            kind: 'Fragment',
+            version: VERSION$4,
+            private: [],
+            selections: [
+                {
+                    name: 'schemaName',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'schemaSize',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'schemaType',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'schemaValidation',
+                    kind: 'Object',
+                    plural: true,
+                    selections: SchemaValidationMessageRepresentation__selections
+                },
+                {
+                    name: 'systemVersion',
+                    kind: 'Scalar'
+                }
+            ]
+        };
+    };
+    function equals$4(existing, incoming) {
+        var existing_schemaSize = existing.schemaSize;
+        var incoming_schemaSize = incoming.schemaSize;
+        if (!(existing_schemaSize === incoming_schemaSize)) {
+            return false;
+        }
+        var existing_systemVersion = existing.systemVersion;
+        var incoming_systemVersion = incoming.systemVersion;
+        if (!(existing_systemVersion === incoming_systemVersion)) {
+            return false;
+        }
+        var existing_schemaName = existing.schemaName;
+        var incoming_schemaName = incoming.schemaName;
+        if (!(existing_schemaName === incoming_schemaName)) {
+            return false;
+        }
+        var existing_schemaType = existing.schemaType;
+        var incoming_schemaType = incoming.schemaType;
+        if (!(existing_schemaType === incoming_schemaType)) {
+            return false;
+        }
+        var existing_schemaValidation = existing.schemaValidation;
+        var incoming_schemaValidation = incoming.schemaValidation;
+        var equals_schemaValidation_items = equalsArray(existing_schemaValidation, incoming_schemaValidation, function (existing_schemaValidation_item, incoming_schemaValidation_item) {
+            if (!(equals$5(existing_schemaValidation_item, incoming_schemaValidation_item))) {
+                return false;
+            }
+        });
+        if (equals_schemaValidation_items === false) {
+            return false;
+        }
+        return true;
+    }
+    var ingest$1 = function SchemaValidationOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+        if (process.env.NODE_ENV !== 'production') {
+            var validateError = validate$4(input);
+            if (validateError !== null) {
+                throw validateError;
+            }
+        }
+        var key = keyBuilderFromType(luvio, input);
+        var existingRecord = store.readEntry(key);
+        var ttlToUse = path.ttl !== undefined ? path.ttl : 300000;
+        var incomingRecord = normalize$1(input, store.readEntry(key), {
+            fullPath: key,
+            parent: path.parent,
+            propertyName: path.propertyName,
+            ttl: ttlToUse
+        });
+        if (existingRecord === undefined || equals$4(existingRecord, incomingRecord) === false) {
+            luvio.storePublish(key, incomingRecord);
+        }
+        if (ttlToUse !== undefined) {
+            var storeMetadataParams = {
+                ttl: ttlToUse,
+                namespace: "external-services",
+                version: VERSION$4,
+                representationName: RepresentationType$1,
+            };
+            luvio.publishStoreMetadata(key, storeMetadataParams);
+        }
+        return createLink(key);
+    };
+    function getTypeCacheKeys$1(luvio, input, fullPathFactory) {
+        var rootKeySet = new engine.StoreKeyMap();
+        // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+        var rootKey = keyBuilderFromType(luvio, input);
+        rootKeySet.set(rootKey, {
+            namespace: keyPrefix,
+            representationName: RepresentationType$1,
+            mergeable: false
+        });
+        return rootKeySet;
+    }
+
+    function select$6(luvio, params) {
+        return select$7();
+    }
+    function getResponseCacheKeys$2(luvio, resourceParams, response) {
+        return getTypeCacheKeys$1(luvio, response);
+    }
+    function ingestSuccess$2(luvio, resourceParams, response) {
+        var body = response.body;
+        var key = keyBuilderFromType(luvio, body);
+        luvio.storeIngest(key, ingest$1, body);
+        var snapshot = luvio.storeLookup({
+            recordId: key,
+            node: select$6(),
+            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 snapshot;
+    }
+    function createResourceRequest$2(config) {
+        var headers = {};
+        return {
+            baseUri: '/services/data/v58.0',
+            basePath: '/externalservices/schemas/' + config.urlParams.schemaName + '/validation',
+            method: 'post',
+            body: config.body,
+            urlParams: config.urlParams,
+            queryParams: {},
+            headers: headers,
+            priority: 'normal',
+        };
+    }
+
+    var validateSchema_ConfigPropertyNames = {
+        displayName: 'validateSchema',
+        parameters: {
+            required: ['schemaName', 'schema'],
+            optional: []
+        }
+    };
+    function createResourceParams$2(config) {
+        var resourceParams = {
+            urlParams: {
+                schemaName: config.schemaName
+            },
+            body: {
+                schema: config.schema
+            }
+        };
+        return resourceParams;
+    }
+    function typeCheckConfig$2(untrustedConfig) {
+        var config = {};
+        var untrustedConfig_schemaName = untrustedConfig.schemaName;
+        if (typeof untrustedConfig_schemaName === 'string') {
+            config.schemaName = untrustedConfig_schemaName;
+        }
+        var untrustedConfig_schema = untrustedConfig.schema;
+        var referenceSchemaValidationInputRepresentationValidationError = validate$6(untrustedConfig_schema);
+        if (referenceSchemaValidationInputRepresentationValidationError === null) {
+            config.schema = untrustedConfig_schema;
+        }
+        return config;
+    }
+    function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
+        if (!untrustedIsObject(untrustedConfig)) {
+            return null;
+        }
+        if (process.env.NODE_ENV !== 'production') {
+            validateConfig(untrustedConfig, configPropertyNames);
+        }
+        var config = typeCheckConfig$2(untrustedConfig);
+        if (!areRequiredParametersPresent(config, configPropertyNames)) {
+            return null;
+        }
+        return config;
+    }
+    function buildNetworkSnapshot$2(luvio, config, options) {
+        var resourceParams = createResourceParams$2(config);
+        var request = createResourceRequest$2(resourceParams);
+        return luvio.dispatchResourceRequest(request, options)
+            .then(function (response) {
+            return luvio.handleSuccessResponse(function () {
+                var snapshot = ingestSuccess$2(luvio, resourceParams, response);
+                return luvio.storeBroadcast().then(function () { return snapshot; });
+            }, function () { return getResponseCacheKeys$2(luvio, resourceParams, response.body); });
+        }, function (response) {
+            deepFreeze$2(response);
+            throw response;
+        });
+    }
+    var validateSchemaAdapterFactory = function (luvio) {
+        return function validateSchema(untrustedConfig) {
+            var config = validateAdapterConfig$2(untrustedConfig, validateSchema_ConfigPropertyNames);
+            // Invalid or incomplete config
+            if (config === null) {
+                throw new Error('Invalid config for "validateSchema"');
+            }
+            return buildNetworkSnapshot$2(luvio, config);
+        };
+    };
+
+    var VERSION$3 = "7dd4168caef7cc755bcbcb7dddf11b57";
+    function validate$3(obj, path) {
+        if (path === void 0) { path = 'ExternalServiceStatisticsBreakdownRepresentation'; }
+        var v_error = (function () {
+            if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+            }
+            var obj_active = obj.active;
+            var path_active = path + '.active';
+            if (typeof obj_active !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_active + '" (at "' + path_active + '")');
+            }
+            var obj_activeCount = obj.activeCount;
+            var path_activeCount = path + '.activeCount';
+            if (typeof obj_activeCount !== 'number' || (typeof obj_activeCount === 'number' && Math.floor(obj_activeCount) !== obj_activeCount)) {
+                return new TypeError('Expected "integer" but received "' + typeof obj_activeCount + '" (at "' + path_activeCount + '")');
+            }
+            var obj_component = obj.component;
+            var path_component = path + '.component';
+            if (typeof obj_component !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_component + '" (at "' + path_component + '")');
+            }
+            var obj_componentType = obj.componentType;
+            var path_componentType = path + '.componentType';
+            if (typeof obj_componentType !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_componentType + '" (at "' + path_componentType + '")');
+            }
+            var obj_statisticFor = obj.statisticFor;
+            var path_statisticFor = path + '.statisticFor';
+            if (typeof obj_statisticFor !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_statisticFor + '" (at "' + path_statisticFor + '")');
+            }
+            var obj_totalCount = obj.totalCount;
+            var path_totalCount = path + '.totalCount';
+            if (typeof obj_totalCount !== 'number' || (typeof obj_totalCount === 'number' && Math.floor(obj_totalCount) !== obj_totalCount)) {
+                return new TypeError('Expected "integer" but received "' + typeof obj_totalCount + '" (at "' + path_totalCount + '")');
+            }
+        })();
+        return v_error === undefined ? null : v_error;
+    }
+    var select$5 = function ExternalServiceStatisticsBreakdownRepresentationSelect() {
+        return {
+            kind: 'Fragment',
+            version: VERSION$3,
+            private: [],
+            selections: [
+                {
+                    name: 'active',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'activeCount',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'component',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'componentType',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'statisticFor',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'totalCount',
+                    kind: 'Scalar'
+                }
+            ]
+        };
+    };
+    function equals$3(existing, incoming) {
+        var existing_active = existing.active;
+        var incoming_active = incoming.active;
+        if (!(existing_active === incoming_active)) {
+            return false;
+        }
+        var existing_activeCount = existing.activeCount;
+        var incoming_activeCount = incoming.activeCount;
+        if (!(existing_activeCount === incoming_activeCount)) {
+            return false;
+        }
+        var existing_totalCount = existing.totalCount;
+        var incoming_totalCount = incoming.totalCount;
+        if (!(existing_totalCount === incoming_totalCount)) {
+            return false;
+        }
+        var existing_component = existing.component;
+        var incoming_component = incoming.component;
+        if (!(existing_component === incoming_component)) {
+            return false;
+        }
+        var existing_componentType = existing.componentType;
+        var incoming_componentType = incoming.componentType;
+        if (!(existing_componentType === incoming_componentType)) {
+            return false;
+        }
+        var existing_statisticFor = existing.statisticFor;
+        var incoming_statisticFor = incoming.statisticFor;
+        if (!(existing_statisticFor === incoming_statisticFor)) {
+            return false;
+        }
+        return true;
+    }
+
+    var VERSION$2 = "6bd958289eba0fb66f626c73737f8c00";
+    function validate$2(obj, path) {
+        if (path === void 0) { path = 'ExternalServiceStatisticsForServiceRepresentation'; }
+        var v_error = (function () {
+            if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+            }
+            var obj_schemaSize = obj.schemaSize;
+            var path_schemaSize = path + '.schemaSize';
+            if (typeof obj_schemaSize !== 'number' || (typeof obj_schemaSize === 'number' && Math.floor(obj_schemaSize) !== obj_schemaSize)) {
+                return new TypeError('Expected "integer" but received "' + typeof obj_schemaSize + '" (at "' + path_schemaSize + '")');
+            }
+            var obj_schemaType = obj.schemaType;
+            var path_schemaType = path + '.schemaType';
+            if (typeof obj_schemaType !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_schemaType + '" (at "' + path_schemaType + '")');
+            }
+            var obj_serviceName = obj.serviceName;
+            var path_serviceName = path + '.serviceName';
+            if (typeof obj_serviceName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_serviceName + '" (at "' + path_serviceName + '")');
+            }
+            var obj_statistics = obj.statistics;
+            var path_statistics = path + '.statistics';
+            if (!ArrayIsArray(obj_statistics)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_statistics + '" (at "' + path_statistics + '")');
+            }
+            for (var i = 0; i < obj_statistics.length; i++) {
+                var obj_statistics_item = obj_statistics[i];
+                var path_statistics_item = path_statistics + '[' + i + ']';
+                var referencepath_statistics_itemValidationError = validate$3(obj_statistics_item, path_statistics_item);
+                if (referencepath_statistics_itemValidationError !== null) {
+                    var message = 'Object doesn\'t match ExternalServiceStatisticsBreakdownRepresentation (at "' + path_statistics_item + '")\n';
+                    message += referencepath_statistics_itemValidationError.message.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                    return new TypeError(message);
+                }
+            }
+            var obj_systemVersion = obj.systemVersion;
+            var path_systemVersion = path + '.systemVersion';
+            if (typeof obj_systemVersion !== 'number' || (typeof obj_systemVersion === 'number' && Math.floor(obj_systemVersion) !== obj_systemVersion)) {
+                return new TypeError('Expected "integer" but received "' + typeof obj_systemVersion + '" (at "' + path_systemVersion + '")');
+            }
+        })();
+        return v_error === undefined ? null : v_error;
+    }
+    var select$4 = function ExternalServiceStatisticsForServiceRepresentationSelect() {
+        var _a = select$5(), ExternalServiceStatisticsBreakdownRepresentation__selections = _a.selections;
+        return {
+            kind: 'Fragment',
+            version: VERSION$2,
+            private: [],
+            selections: [
+                {
+                    name: 'schemaSize',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'schemaType',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'serviceName',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'statistics',
+                    kind: 'Object',
+                    plural: true,
+                    selections: ExternalServiceStatisticsBreakdownRepresentation__selections
+                },
+                {
+                    name: 'systemVersion',
+                    kind: 'Scalar'
+                }
+            ]
+        };
+    };
+    function equals$2(existing, incoming) {
+        var existing_schemaSize = existing.schemaSize;
+        var incoming_schemaSize = incoming.schemaSize;
+        if (!(existing_schemaSize === incoming_schemaSize)) {
+            return false;
+        }
+        var existing_systemVersion = existing.systemVersion;
+        var incoming_systemVersion = incoming.systemVersion;
+        if (!(existing_systemVersion === incoming_systemVersion)) {
+            return false;
+        }
+        var existing_schemaType = existing.schemaType;
+        var incoming_schemaType = incoming.schemaType;
+        if (!(existing_schemaType === incoming_schemaType)) {
+            return false;
+        }
+        var existing_serviceName = existing.serviceName;
+        var incoming_serviceName = incoming.serviceName;
+        if (!(existing_serviceName === incoming_serviceName)) {
+            return false;
+        }
+        var existing_statistics = existing.statistics;
+        var incoming_statistics = incoming.statistics;
+        var equals_statistics_items = equalsArray(existing_statistics, incoming_statistics, function (existing_statistics_item, incoming_statistics_item) {
+            if (!(equals$3(existing_statistics_item, incoming_statistics_item))) {
+                return false;
+            }
+        });
+        if (equals_statistics_items === false) {
+            return false;
+        }
+        return true;
+    }
+
+    var VERSION$1 = "3ff0c02babe6583f09a09544b2c045fd";
+    function validate$1(obj, path) {
+        if (path === void 0) { path = 'ExternalServiceStatisticsOverviewRepresentation'; }
+        var v_error = (function () {
+            if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+            }
+            var obj_activeCount = obj.activeCount;
+            var path_activeCount = path + '.activeCount';
+            if (typeof obj_activeCount !== 'number' || (typeof obj_activeCount === 'number' && Math.floor(obj_activeCount) !== obj_activeCount)) {
+                return new TypeError('Expected "integer" but received "' + typeof obj_activeCount + '" (at "' + path_activeCount + '")');
+            }
+            var obj_statisticFor = obj.statisticFor;
+            var path_statisticFor = path + '.statisticFor';
+            if (typeof obj_statisticFor !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_statisticFor + '" (at "' + path_statisticFor + '")');
+            }
+            var obj_totalCount = obj.totalCount;
+            var path_totalCount = path + '.totalCount';
+            if (typeof obj_totalCount !== 'number' || (typeof obj_totalCount === 'number' && Math.floor(obj_totalCount) !== obj_totalCount)) {
+                return new TypeError('Expected "integer" but received "' + typeof obj_totalCount + '" (at "' + path_totalCount + '")');
+            }
+        })();
+        return v_error === undefined ? null : v_error;
+    }
+    var select$3 = function ExternalServiceStatisticsOverviewRepresentationSelect() {
+        return {
+            kind: 'Fragment',
+            version: VERSION$1,
+            private: [],
+            selections: [
+                {
+                    name: 'activeCount',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'statisticFor',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'totalCount',
+                    kind: 'Scalar'
+                }
+            ]
+        };
+    };
+    function equals$1(existing, incoming) {
+        var existing_activeCount = existing.activeCount;
+        var incoming_activeCount = incoming.activeCount;
+        if (!(existing_activeCount === incoming_activeCount)) {
+            return false;
+        }
+        var existing_totalCount = existing.totalCount;
+        var incoming_totalCount = incoming.totalCount;
+        if (!(existing_totalCount === incoming_totalCount)) {
+            return false;
+        }
+        var existing_statisticFor = existing.statisticFor;
+        var incoming_statisticFor = incoming.statisticFor;
+        if (!(existing_statisticFor === incoming_statisticFor)) {
+            return false;
+        }
+        return true;
+    }
+
+    var VERSION = "4246bda5c0cab4f897003ca8900ef381";
+    function validate(obj, path) {
+        if (path === void 0) { path = 'ExternalServiceStatisticsOutputRepresentation'; }
+        var v_error = (function () {
+            if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+            }
+            var obj_serviceCount = obj.serviceCount;
+            var path_serviceCount = path + '.serviceCount';
+            if (typeof obj_serviceCount !== 'number' || (typeof obj_serviceCount === 'number' && Math.floor(obj_serviceCount) !== obj_serviceCount)) {
+                return new TypeError('Expected "integer" but received "' + typeof obj_serviceCount + '" (at "' + path_serviceCount + '")');
+            }
+            var obj_services = obj.services;
+            var path_services = path + '.services';
+            if (!ArrayIsArray(obj_services)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_services + '" (at "' + path_services + '")');
+            }
+            for (var i = 0; i < obj_services.length; i++) {
+                var obj_services_item = obj_services[i];
+                var path_services_item = path_services + '[' + i + ']';
+                var referencepath_services_itemValidationError = validate$2(obj_services_item, path_services_item);
+                if (referencepath_services_itemValidationError !== null) {
+                    var message = 'Object doesn\'t match ExternalServiceStatisticsForServiceRepresentation (at "' + path_services_item + '")\n';
+                    message += referencepath_services_itemValidationError.message.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                    return new TypeError(message);
+                }
+            }
+            var obj_statistics = obj.statistics;
+            var path_statistics = path + '.statistics';
+            if (!ArrayIsArray(obj_statistics)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_statistics + '" (at "' + path_statistics + '")');
+            }
+            for (var i = 0; i < obj_statistics.length; i++) {
+                var obj_statistics_item = obj_statistics[i];
+                var path_statistics_item = path_statistics + '[' + i + ']';
+                var referencepath_statistics_itemValidationError = validate$1(obj_statistics_item, path_statistics_item);
+                if (referencepath_statistics_itemValidationError !== null) {
+                    var message = 'Object doesn\'t match ExternalServiceStatisticsOverviewRepresentation (at "' + path_statistics_item + '")\n';
+                    message += referencepath_statistics_itemValidationError.message.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        })();
+        return v_error === undefined ? null : v_error;
+    }
+    var RepresentationType = 'ExternalServiceStatisticsOutputRepresentation';
+    function normalize(input, existing, path, luvio, store, timestamp) {
+        return input;
+    }
+    var select$2 = function ExternalServiceStatisticsOutputRepresentationSelect() {
+        var _a = select$4(), ExternalServiceStatisticsForServiceRepresentation__selections = _a.selections;
+        var _b = select$3(), ExternalServiceStatisticsOverviewRepresentation__selections = _b.selections;
+        return {
+            kind: 'Fragment',
+            version: VERSION,
+            private: [],
+            selections: [
+                {
+                    name: 'serviceCount',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'services',
+                    kind: 'Object',
+                    plural: true,
+                    selections: ExternalServiceStatisticsForServiceRepresentation__selections
+                },
+                {
+                    name: 'statistics',
+                    kind: 'Object',
+                    plural: true,
+                    selections: ExternalServiceStatisticsOverviewRepresentation__selections
+                }
+            ]
+        };
+    };
+    function equals(existing, incoming) {
+        var existing_serviceCount = existing.serviceCount;
+        var incoming_serviceCount = incoming.serviceCount;
+        if (!(existing_serviceCount === incoming_serviceCount)) {
+            return false;
+        }
+        var existing_services = existing.services;
+        var incoming_services = incoming.services;
+        var equals_services_items = equalsArray(existing_services, incoming_services, function (existing_services_item, incoming_services_item) {
+            if (!(equals$2(existing_services_item, incoming_services_item))) {
+                return false;
+            }
+        });
+        if (equals_services_items === false) {
+            return false;
+        }
+        var existing_statistics = existing.statistics;
+        var incoming_statistics = incoming.statistics;
+        var equals_statistics_items = equalsArray(existing_statistics, incoming_statistics, function (existing_statistics_item, incoming_statistics_item) {
+            if (!(equals$1(existing_statistics_item, incoming_statistics_item))) {
+                return false;
+            }
+        });
+        if (equals_statistics_items === false) {
+            return false;
+        }
+        return true;
+    }
+    var ingest = function ExternalServiceStatisticsOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+        if (process.env.NODE_ENV !== 'production') {
+            var validateError = validate(input);
+            if (validateError !== null) {
+                throw validateError;
+            }
+        }
+        var key = path.fullPath;
+        var existingRecord = store.readEntry(key);
+        var ttlToUse = path.ttl !== undefined ? path.ttl : 300000;
+        var incomingRecord = normalize(input, store.readEntry(key), {
+            fullPath: key,
+            parent: path.parent,
+            propertyName: path.propertyName,
+            ttl: ttlToUse
+        });
+        if (existingRecord === undefined || equals(existingRecord, incomingRecord) === false) {
+            luvio.storePublish(key, incomingRecord);
+        }
+        if (ttlToUse !== undefined) {
+            var storeMetadataParams = {
+                ttl: ttlToUse,
+                namespace: "external-services",
+                version: VERSION,
+                representationName: RepresentationType,
+            };
+            luvio.publishStoreMetadata(key, storeMetadataParams);
+        }
+        return createLink(key);
+    };
+    function getTypeCacheKeys(luvio, input, fullPathFactory) {
+        var rootKeySet = new engine.StoreKeyMap();
+        // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+        var rootKey = fullPathFactory();
+        rootKeySet.set(rootKey, {
+            namespace: keyPrefix,
+            representationName: RepresentationType,
+            mergeable: false
+        });
+        return rootKeySet;
+    }
+
+    function select$1(luvio, params) {
+        return select$2();
+    }
+    function keyBuilder$3(luvio, params) {
+        return keyPrefix + '::ExternalServiceStatisticsOutputRepresentation:(' + ')';
+    }
+    function getResponseCacheKeys$1(luvio, resourceParams, response) {
+        return getTypeCacheKeys(luvio, response, function () { return keyBuilder$3(); });
+    }
+    function ingestSuccess$1(luvio, resourceParams, response, snapshotRefresh) {
+        var body = response.body;
+        var key = keyBuilder$3();
+        luvio.storeIngest(key, ingest, body);
+        var snapshot = luvio.storeLookup({
+            recordId: key,
+            node: select$1(),
+            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');
+            }
+        }
+        return snapshot;
+    }
+    function ingestError$1(luvio, params, error, snapshotRefresh) {
+        var key = keyBuilder$3();
+        var errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+        luvio.storeIngestError(key, errorSnapshot);
+        return errorSnapshot;
+    }
+    function createResourceRequest$1(config) {
+        var headers = {};
+        return {
+            baseUri: '/services/data/v58.0',
+            basePath: '/externalservices/statistics/services',
+            method: 'get',
+            body: null,
+            urlParams: {},
+            queryParams: {},
+            headers: headers,
+            priority: 'normal',
+        };
+    }
+
+    var getStatistics_ConfigPropertyNames = {
+        displayName: 'getStatistics',
+        parameters: {
+            required: [],
+            optional: []
+        }
+    };
+    function createResourceParams$1(config) {
+        var resourceParams = {};
+        return resourceParams;
+    }
+    function keyBuilder$2(luvio, config) {
+        return keyBuilder$3();
+    }
+    function typeCheckConfig$1(untrustedConfig) {
+        var config = {};
+        return config;
+    }
+    function validateAdapterConfig$1(untrustedConfig, configPropertyNames) {
+        if (!untrustedIsObject(untrustedConfig)) {
+            return null;
+        }
+        if (process.env.NODE_ENV !== 'production') {
+            validateConfig(untrustedConfig, configPropertyNames);
+        }
+        var config = typeCheckConfig$1();
+        if (!areRequiredParametersPresent(config, configPropertyNames)) {
+            return null;
+        }
+        return config;
+    }
+    function adapterFragment$1(luvio, config) {
+        return select$1();
+    }
+    function onFetchResponseSuccess$1(luvio, config, resourceParams, response) {
+        var snapshot = ingestSuccess$1(luvio, resourceParams, response, {
+            config: config,
+            resolve: function () { return buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions); }
+        });
+        return luvio.storeBroadcast().then(function () { return snapshot; });
+    }
+    function onFetchResponseError$1(luvio, config, resourceParams, response) {
+        var snapshot = ingestError$1(luvio, resourceParams, response, {
+            config: config,
+            resolve: function () { return buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions); }
+        });
+        return luvio.storeBroadcast().then(function () { return snapshot; });
+    }
+    function buildNetworkSnapshot$1(luvio, config, options) {
+        var resourceParams = createResourceParams$1();
+        var request = createResourceRequest$1();
+        return luvio.dispatchResourceRequest(request, options)
+            .then(function (response) {
+            return luvio.handleSuccessResponse(function () { return onFetchResponseSuccess$1(luvio, config, resourceParams, response); }, function () { return getResponseCacheKeys$1(luvio, resourceParams, response.body); });
+        }, function (response) {
+            return luvio.handleErrorResponse(function () { return onFetchResponseError$1(luvio, config, resourceParams, response); });
+        });
+    }
+    function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext) {
+        var luvio = context.luvio, config = context.config;
+        var networkPriority = coercedAdapterRequestContext.networkPriority, requestCorrelator = coercedAdapterRequestContext.requestCorrelator, eventObservers = coercedAdapterRequestContext.eventObservers;
+        var dispatchOptions = {
+            resourceRequestContext: {
+                requestCorrelator: requestCorrelator,
+                luvioRequestMethod: undefined,
+            },
+            eventObservers: eventObservers
+        };
+        if (networkPriority !== 'normal') {
+            dispatchOptions.overrides = {
+                priority: networkPriority
+            };
+        }
+        return buildNetworkSnapshot$1(luvio, config, dispatchOptions);
+    }
+    function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
+        var luvio = context.luvio, config = context.config;
+        var selector = {
+            recordId: keyBuilder$2(),
+            node: adapterFragment$1(),
+            variables: {},
+        };
+        var cacheSnapshot = storeLookup(selector, {
+            config: config,
+            resolve: function () { return buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions); }
+        });
+        return cacheSnapshot;
+    }
+    var getStatisticsAdapterFactory = function (luvio) { return function externalServices__getStatistics(untrustedConfig, requestContext) {
+        var config = validateAdapterConfig$1(untrustedConfig, getStatistics_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            return null;
+        }
+        return luvio.applyCachePolicy((requestContext || {}), { config: config, luvio: luvio }, // BuildSnapshotContext
+        buildCachedSnapshotCachePolicy$1, buildNetworkSnapshotCachePolicy$1);
+    }; };
+
+    function select(luvio, params) {
+        return select$2();
+    }
+    function keyBuilder$1(luvio, params) {
+        return keyPrefix + '::ExternalServiceStatisticsOutputRepresentation:(' + 'registrationName:' + params.urlParams.registrationName + ')';
+    }
+    function getResponseCacheKeys(luvio, resourceParams, response) {
+        return getTypeCacheKeys(luvio, response, function () { return keyBuilder$1(luvio, resourceParams); });
+    }
+    function ingestSuccess(luvio, resourceParams, response, snapshotRefresh) {
+        var body = response.body;
+        var key = keyBuilder$1(luvio, resourceParams);
+        luvio.storeIngest(key, ingest, body);
+        var 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');
+            }
+        }
+        return snapshot;
+    }
+    function ingestError(luvio, params, error, snapshotRefresh) {
+        var key = keyBuilder$1(luvio, params);
+        var errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+        luvio.storeIngestError(key, errorSnapshot);
+        return errorSnapshot;
+    }
+    function createResourceRequest(config) {
+        var headers = {};
+        return {
+            baseUri: '/services/data/v58.0',
+            basePath: '/externalservices/statistics/services/' + config.urlParams.registrationName + '',
+            method: 'get',
+            body: null,
+            urlParams: config.urlParams,
+            queryParams: {},
+            headers: headers,
+            priority: 'normal',
+        };
+    }
+
+    var getStatisticsForService_ConfigPropertyNames = {
+        displayName: 'getStatisticsForService',
+        parameters: {
+            required: ['registrationName'],
+            optional: []
+        }
+    };
+    function createResourceParams(config) {
+        var resourceParams = {
+            urlParams: {
+                registrationName: config.registrationName
+            }
+        };
+        return resourceParams;
+    }
+    function keyBuilder(luvio, config) {
+        var resourceParams = createResourceParams(config);
+        return keyBuilder$1(luvio, resourceParams);
+    }
+    function typeCheckConfig(untrustedConfig) {
+        var config = {};
+        var untrustedConfig_registrationName = untrustedConfig.registrationName;
+        if (typeof untrustedConfig_registrationName === 'string') {
+            config.registrationName = untrustedConfig_registrationName;
+        }
+        return config;
+    }
+    function validateAdapterConfig(untrustedConfig, configPropertyNames) {
+        if (!untrustedIsObject(untrustedConfig)) {
+            return null;
+        }
+        if (process.env.NODE_ENV !== 'production') {
+            validateConfig(untrustedConfig, configPropertyNames);
+        }
+        var config = typeCheckConfig(untrustedConfig);
+        if (!areRequiredParametersPresent(config, configPropertyNames)) {
+            return null;
+        }
+        return config;
+    }
+    function adapterFragment(luvio, config) {
+        createResourceParams(config);
+        return select();
+    }
+    function onFetchResponseSuccess(luvio, config, resourceParams, response) {
+        var snapshot = ingestSuccess(luvio, resourceParams, response, {
+            config: config,
+            resolve: function () { return buildNetworkSnapshot(luvio, config, snapshotRefreshOptions); }
+        });
+        return luvio.storeBroadcast().then(function () { return snapshot; });
+    }
+    function onFetchResponseError(luvio, config, resourceParams, response) {
+        var snapshot = ingestError(luvio, resourceParams, response, {
+            config: config,
+            resolve: function () { return buildNetworkSnapshot(luvio, config, snapshotRefreshOptions); }
+        });
+        return luvio.storeBroadcast().then(function () { return snapshot; });
+    }
+    function buildNetworkSnapshot(luvio, config, options) {
+        var resourceParams = createResourceParams(config);
+        var request = createResourceRequest(resourceParams);
+        return luvio.dispatchResourceRequest(request, options)
+            .then(function (response) {
+            return luvio.handleSuccessResponse(function () { return onFetchResponseSuccess(luvio, config, resourceParams, response); }, function () { return getResponseCacheKeys(luvio, resourceParams, response.body); });
+        }, function (response) {
+            return luvio.handleErrorResponse(function () { return onFetchResponseError(luvio, config, resourceParams, response); });
+        });
+    }
+    function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
+        var luvio = context.luvio, config = context.config;
+        var networkPriority = coercedAdapterRequestContext.networkPriority, requestCorrelator = coercedAdapterRequestContext.requestCorrelator, eventObservers = coercedAdapterRequestContext.eventObservers;
+        var dispatchOptions = {
+            resourceRequestContext: {
+                requestCorrelator: requestCorrelator,
+                luvioRequestMethod: undefined,
+            },
+            eventObservers: eventObservers
+        };
+        if (networkPriority !== 'normal') {
+            dispatchOptions.overrides = {
+                priority: networkPriority
+            };
+        }
+        return buildNetworkSnapshot(luvio, config, dispatchOptions);
+    }
+    function buildCachedSnapshotCachePolicy(context, storeLookup) {
+        var luvio = context.luvio, config = context.config;
+        var selector = {
+            recordId: keyBuilder(luvio, config),
+            node: adapterFragment(luvio, config),
+            variables: {},
+        };
+        var cacheSnapshot = storeLookup(selector, {
+            config: config,
+            resolve: function () { return buildNetworkSnapshot(luvio, config, snapshotRefreshOptions); }
+        });
+        return cacheSnapshot;
+    }
+    var getStatisticsForServiceAdapterFactory = function (luvio) { return function externalServices__getStatisticsForService(untrustedConfig, requestContext) {
+        var config = validateAdapterConfig(untrustedConfig, getStatisticsForService_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            return null;
+        }
+        return luvio.applyCachePolicy((requestContext || {}), { config: config, luvio: luvio }, // BuildSnapshotContext
+        buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
+    }; };
+
+    exports.getDataShapeAdapterFactory = getDataShapeAdapterFactory;
+    exports.getOpenApiSpecAdapterFactory = getOpenApiSpecAdapterFactory;
+    exports.getStatisticsAdapterFactory = getStatisticsAdapterFactory;
+    exports.getStatisticsForServiceAdapterFactory = getStatisticsForServiceAdapterFactory;
+    exports.validateSchemaAdapterFactory = validateSchemaAdapterFactory;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));