@salesforce/lds-adapters-platform-admin-success-guidance 1.100.2

package/dist/umd/es5/platform-admin-success-guidance.js

@@ -0,0 +1,4243 @@
+/**
+ * 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["platformAdmin-success-guidance"] = {}, 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 = 'LEAP';
+
+    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(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(value[i]);
+            }
+        }
+        else {
+            var keys = ObjectKeys(value);
+            for (var i = 0, len = keys.length; i < len; i += 1) {
+                deepFreeze(value[keys[i]]);
+            }
+        }
+        ObjectFreeze(value);
+    }
+    function createLink(ref) {
+        return {
+            __ref: engine.serializeStructuredKey(ref),
+        };
+    }
+
+    var VERSION$l = "fec1ea773d37039808d8d9e4e4d7c085";
+    function validate$h(obj, path) {
+        if (path === void 0) { path = 'LightningAssistantChoiceRepresentation'; }
+        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_developerName = obj.developerName;
+            var path_developerName = path + '.developerName';
+            if (typeof obj_developerName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_developerName + '" (at "' + path_developerName + '")');
+            }
+            var obj_next = obj.next;
+            var path_next = path + '.next';
+            if (typeof obj_next !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_next + '" (at "' + path_next + '")');
+            }
+            var obj_title = obj.title;
+            var path_title = path + '.title';
+            if (typeof obj_title !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_title + '" (at "' + path_title + '")');
+            }
+        })();
+        return v_error === undefined ? null : v_error;
+    }
+    var select$w = function LightningAssistantChoiceRepresentationSelect() {
+        return {
+            kind: 'Fragment',
+            version: VERSION$l,
+            private: [],
+            selections: [
+                {
+                    name: 'description',
+                    kind: 'Scalar',
+                    required: false
+                },
+                {
+                    name: 'developerName',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'next',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'title',
+                    kind: 'Scalar'
+                }
+            ]
+        };
+    };
+    function equals$e(existing, incoming) {
+        var existing_description = existing.description;
+        var incoming_description = incoming.description;
+        // if at least one of these optionals is defined
+        if (existing_description !== undefined || incoming_description !== undefined) {
+            // if one of these is not defined we know the other is defined and therefore
+            // not equal
+            if (existing_description === undefined || incoming_description === undefined) {
+                return false;
+            }
+            if (!(existing_description === incoming_description)) {
+                return false;
+            }
+        }
+        var existing_developerName = existing.developerName;
+        var incoming_developerName = incoming.developerName;
+        if (!(existing_developerName === incoming_developerName)) {
+            return false;
+        }
+        var existing_next = existing.next;
+        var incoming_next = incoming.next;
+        if (!(existing_next === incoming_next)) {
+            return false;
+        }
+        var existing_title = existing.title;
+        var incoming_title = incoming.title;
+        if (!(existing_title === incoming_title)) {
+            return false;
+        }
+        return true;
+    }
+
+    var VERSION$k = "545ec40aff7b3db184e84760ae732370";
+    function validate$g(obj, path) {
+        if (path === void 0) { path = 'LightningAssistantLinkRepresentation'; }
+        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_label = obj.label;
+            var path_label = path + '.label';
+            if (typeof obj_label !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_label + '" (at "' + path_label + '")');
+            }
+            var obj_url = obj.url;
+            var path_url = path + '.url';
+            if (typeof obj_url !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_url + '" (at "' + path_url + '")');
+            }
+        })();
+        return v_error === undefined ? null : v_error;
+    }
+    var select$v = function LightningAssistantLinkRepresentationSelect() {
+        return {
+            kind: 'Fragment',
+            version: VERSION$k,
+            private: [],
+            selections: [
+                {
+                    name: 'label',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'url',
+                    kind: 'Scalar'
+                }
+            ]
+        };
+    };
+    function equals$d(existing, incoming) {
+        var existing_label = existing.label;
+        var incoming_label = incoming.label;
+        if (!(existing_label === incoming_label)) {
+            return false;
+        }
+        var existing_url = existing.url;
+        var incoming_url = incoming.url;
+        if (!(existing_url === incoming_url)) {
+            return false;
+        }
+        return true;
+    }
+
+    var VERSION$j = "33d491734169be0180f670c757b53a34";
+    function validate$f(obj, path) {
+        if (path === void 0) { path = 'LightningAssistantQuestionRepresentation'; }
+        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_choices = obj.choices;
+            var path_choices = path + '.choices';
+            if (!ArrayIsArray(obj_choices)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_choices + '" (at "' + path_choices + '")');
+            }
+            for (var i = 0; i < obj_choices.length; i++) {
+                var obj_choices_item = obj_choices[i];
+                var path_choices_item = path_choices + '[' + i + ']';
+                var referencepath_choices_itemValidationError = validate$h(obj_choices_item, path_choices_item);
+                if (referencepath_choices_itemValidationError !== null) {
+                    var message = 'Object doesn\'t match LightningAssistantChoiceRepresentation (at "' + path_choices_item + '")\n';
+                    message += referencepath_choices_itemValidationError.message.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                    return new TypeError(message);
+                }
+            }
+            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_developerName = obj.developerName;
+            var path_developerName = path + '.developerName';
+            if (typeof obj_developerName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_developerName + '" (at "' + path_developerName + '")');
+            }
+            if (obj.link !== undefined) {
+                var obj_link_1 = obj.link;
+                var path_link_1 = path + '.link';
+                var obj_link_union0 = null;
+                var obj_link_union0_error = (function () {
+                    var referencepath_linkValidationError = validate$g(obj_link_1, path_link_1);
+                    if (referencepath_linkValidationError !== null) {
+                        var message = 'Object doesn\'t match LightningAssistantLinkRepresentation (at "' + path_link_1 + '")\n';
+                        message += referencepath_linkValidationError.message.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                        return new TypeError(message);
+                    }
+                })();
+                if (obj_link_union0_error != null) {
+                    obj_link_union0 = obj_link_union0_error.message;
+                }
+                var obj_link_union1 = null;
+                var obj_link_union1_error = (function () {
+                    if (obj_link_1 !== null) {
+                        return new TypeError('Expected "null" but received "' + typeof obj_link_1 + '" (at "' + path_link_1 + '")');
+                    }
+                })();
+                if (obj_link_union1_error != null) {
+                    obj_link_union1 = obj_link_union1_error.message;
+                }
+                if (obj_link_union0 && obj_link_union1) {
+                    var message = 'Object doesn\'t match union (at "' + path_link_1 + '")';
+                    message += '\n' + obj_link_union0.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                    message += '\n' + obj_link_union1.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                    return new TypeError(message);
+                }
+            }
+            var obj_title = obj.title;
+            var path_title = path + '.title';
+            if (typeof obj_title !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_title + '" (at "' + path_title + '")');
+            }
+        })();
+        return v_error === undefined ? null : v_error;
+    }
+    var select$u = function LightningAssistantQuestionRepresentationSelect() {
+        var _a = select$w(), LightningAssistantChoiceRepresentation__selections = _a.selections;
+        var _b = select$v(), LightningAssistantLinkRepresentation__selections = _b.selections;
+        return {
+            kind: 'Fragment',
+            version: VERSION$j,
+            private: [],
+            selections: [
+                {
+                    name: 'choices',
+                    kind: 'Object',
+                    plural: true,
+                    selections: LightningAssistantChoiceRepresentation__selections
+                },
+                {
+                    name: 'description',
+                    kind: 'Scalar',
+                    required: false
+                },
+                {
+                    name: 'developerName',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'link',
+                    kind: 'Object',
+                    nullable: true,
+                    selections: LightningAssistantLinkRepresentation__selections,
+                    required: false
+                },
+                {
+                    name: 'title',
+                    kind: 'Scalar'
+                }
+            ]
+        };
+    };
+    function equals$c(existing, incoming) {
+        var existing_description = existing.description;
+        var incoming_description = incoming.description;
+        // if at least one of these optionals is defined
+        if (existing_description !== undefined || incoming_description !== undefined) {
+            // if one of these is not defined we know the other is defined and therefore
+            // not equal
+            if (existing_description === undefined || incoming_description === undefined) {
+                return false;
+            }
+            if (!(existing_description === incoming_description)) {
+                return false;
+            }
+        }
+        var existing_developerName = existing.developerName;
+        var incoming_developerName = incoming.developerName;
+        if (!(existing_developerName === incoming_developerName)) {
+            return false;
+        }
+        var existing_title = existing.title;
+        var incoming_title = incoming.title;
+        if (!(existing_title === incoming_title)) {
+            return false;
+        }
+        var existing_choices = existing.choices;
+        var incoming_choices = incoming.choices;
+        var equals_choices_items = equalsArray(existing_choices, incoming_choices, function (existing_choices_item, incoming_choices_item) {
+            if (!(equals$e(existing_choices_item, incoming_choices_item))) {
+                return false;
+            }
+        });
+        if (equals_choices_items === false) {
+            return false;
+        }
+        var existing_link = existing.link;
+        var incoming_link = incoming.link;
+        // if at least one of these optionals is defined
+        if (existing_link !== undefined || incoming_link !== undefined) {
+            // if one of these is not defined we know the other is defined and therefore
+            // not equal
+            if (existing_link === undefined || incoming_link === undefined) {
+                return false;
+            }
+            if (!(existing_link === incoming_link
+                || (existing_link != null &&
+                    incoming_link != null &&
+                    equals$d(existing_link, incoming_link)))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    var VERSION$i = "defc7152bc133ff8e890226cd2092bf0";
+    function validate$e(obj, path) {
+        if (path === void 0) { path = 'LightningAssistantQuestionnaireRepresentation'; }
+        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_assistantTarget = obj.assistantTarget;
+            var path_assistantTarget = path + '.assistantTarget';
+            if (typeof obj_assistantTarget !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_assistantTarget + '" (at "' + path_assistantTarget + '")');
+            }
+            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_developerName = obj.developerName;
+            var path_developerName = path + '.developerName';
+            if (typeof obj_developerName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_developerName + '" (at "' + path_developerName + '")');
+            }
+            var obj_questions = obj.questions;
+            var path_questions = path + '.questions';
+            if (!ArrayIsArray(obj_questions)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_questions + '" (at "' + path_questions + '")');
+            }
+            for (var i = 0; i < obj_questions.length; i++) {
+                var obj_questions_item = obj_questions[i];
+                var path_questions_item = path_questions + '[' + i + ']';
+                var referencepath_questions_itemValidationError = validate$f(obj_questions_item, path_questions_item);
+                if (referencepath_questions_itemValidationError !== null) {
+                    var message = 'Object doesn\'t match LightningAssistantQuestionRepresentation (at "' + path_questions_item + '")\n';
+                    message += referencepath_questions_itemValidationError.message.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                    return new TypeError(message);
+                }
+            }
+            var obj_status = obj.status;
+            var path_status = path + '.status';
+            if (typeof obj_status !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_status + '" (at "' + path_status + '")');
+            }
+            var obj_title = obj.title;
+            var path_title = path + '.title';
+            if (typeof obj_title !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_title + '" (at "' + path_title + '")');
+            }
+        })();
+        return v_error === undefined ? null : v_error;
+    }
+    var RepresentationType$8 = 'LightningAssistantQuestionnaireRepresentation';
+    function keyBuilder$j(luvio, config) {
+        return keyPrefix + '::' + RepresentationType$8 + ':' + config.questionnaire_name;
+    }
+    function keyBuilderFromType$7(luvio, object) {
+        var keyParams = {
+            questionnaire_name: object.developerName
+        };
+        return keyBuilder$j(luvio, keyParams);
+    }
+    function normalize$8(input, existing, path, luvio, store, timestamp) {
+        return input;
+    }
+    var select$t = function LightningAssistantQuestionnaireRepresentationSelect() {
+        var _a = select$u(), LightningAssistantQuestionRepresentation__selections = _a.selections;
+        return {
+            kind: 'Fragment',
+            version: VERSION$i,
+            private: [],
+            selections: [
+                {
+                    name: 'assistantTarget',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'description',
+                    kind: 'Scalar',
+                    required: false
+                },
+                {
+                    name: 'developerName',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'questions',
+                    kind: 'Object',
+                    plural: true,
+                    selections: LightningAssistantQuestionRepresentation__selections
+                },
+                {
+                    name: 'status',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'title',
+                    kind: 'Scalar'
+                }
+            ]
+        };
+    };
+    function equals$b(existing, incoming) {
+        var existing_assistantTarget = existing.assistantTarget;
+        var incoming_assistantTarget = incoming.assistantTarget;
+        if (!(existing_assistantTarget === incoming_assistantTarget)) {
+            return false;
+        }
+        var existing_description = existing.description;
+        var incoming_description = incoming.description;
+        // if at least one of these optionals is defined
+        if (existing_description !== undefined || incoming_description !== undefined) {
+            // if one of these is not defined we know the other is defined and therefore
+            // not equal
+            if (existing_description === undefined || incoming_description === undefined) {
+                return false;
+            }
+            if (!(existing_description === incoming_description)) {
+                return false;
+            }
+        }
+        var existing_developerName = existing.developerName;
+        var incoming_developerName = incoming.developerName;
+        if (!(existing_developerName === incoming_developerName)) {
+            return false;
+        }
+        var existing_status = existing.status;
+        var incoming_status = incoming.status;
+        if (!(existing_status === incoming_status)) {
+            return false;
+        }
+        var existing_title = existing.title;
+        var incoming_title = incoming.title;
+        if (!(existing_title === incoming_title)) {
+            return false;
+        }
+        var existing_questions = existing.questions;
+        var incoming_questions = incoming.questions;
+        var equals_questions_items = equalsArray(existing_questions, incoming_questions, function (existing_questions_item, incoming_questions_item) {
+            if (!(equals$c(existing_questions_item, incoming_questions_item))) {
+                return false;
+            }
+        });
+        if (equals_questions_items === false) {
+            return false;
+        }
+        return true;
+    }
+    var ingest$8 = function LightningAssistantQuestionnaireRepresentationIngest(input, path, luvio, store, timestamp) {
+        if (process.env.NODE_ENV !== 'production') {
+            var validateError = validate$e(input);
+            if (validateError !== null) {
+                throw validateError;
+            }
+        }
+        var key = keyBuilderFromType$7(luvio, input);
+        var existingRecord = store.readEntry(key);
+        var ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
+        var incomingRecord = normalize$8(input, store.readEntry(key), {
+            fullPath: key,
+            parent: path.parent,
+            propertyName: path.propertyName,
+            ttl: ttlToUse
+        });
+        if (existingRecord === undefined || equals$b(existingRecord, incomingRecord) === false) {
+            luvio.storePublish(key, incomingRecord);
+        }
+        if (ttlToUse !== undefined) {
+            var storeMetadataParams = {
+                ttl: ttlToUse,
+                namespace: "LEAP",
+                version: VERSION$i,
+                representationName: RepresentationType$8,
+            };
+            luvio.publishStoreMetadata(key, storeMetadataParams);
+        }
+        return createLink(key);
+    };
+    function getTypeCacheKeys$8(luvio, input, fullPathFactory) {
+        var rootKeySet = new engine.StoreKeyMap();
+        // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+        var rootKey = keyBuilderFromType$7(luvio, input);
+        rootKeySet.set(rootKey, {
+            namespace: keyPrefix,
+            representationName: RepresentationType$8,
+            mergeable: false
+        });
+        return rootKeySet;
+    }
+
+    function select$s(luvio, params) {
+        return select$t();
+    }
+    function keyBuilder$i(luvio, params) {
+        return keyBuilder$j(luvio, {
+            questionnaire_name: params.urlParams.questionnaireName
+        });
+    }
+    function getResponseCacheKeys$a(luvio, resourceParams, response) {
+        return getTypeCacheKeys$8(luvio, response);
+    }
+    function ingestSuccess$a(luvio, resourceParams, response, snapshotRefresh) {
+        var body = response.body;
+        var key = keyBuilder$i(luvio, resourceParams);
+        luvio.storeIngest(key, ingest$8, body);
+        var snapshot = luvio.storeLookup({
+            recordId: key,
+            node: select$s(),
+            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$5(luvio, params, error, snapshotRefresh) {
+        var key = keyBuilder$i(luvio, params);
+        var errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+        luvio.storeIngestError(key, errorSnapshot);
+        return errorSnapshot;
+    }
+    function createResourceRequest$a(config) {
+        var headers = {};
+        return {
+            baseUri: '/services/data/v58.0',
+            basePath: '/assistant-platform/questionnaire/' + config.urlParams.questionnaireName + '',
+            method: 'get',
+            body: null,
+            urlParams: config.urlParams,
+            queryParams: {},
+            headers: headers,
+            priority: 'normal',
+        };
+    }
+
+    var getQuestionnaire_ConfigPropertyNames = {
+        displayName: 'getQuestionnaire',
+        parameters: {
+            required: ['questionnaireName'],
+            optional: []
+        }
+    };
+    function createResourceParams$a(config) {
+        var resourceParams = {
+            urlParams: {
+                questionnaireName: config.questionnaireName
+            }
+        };
+        return resourceParams;
+    }
+    function keyBuilder$h(luvio, config) {
+        var resourceParams = createResourceParams$a(config);
+        return keyBuilder$i(luvio, resourceParams);
+    }
+    function typeCheckConfig$a(untrustedConfig) {
+        var config = {};
+        var untrustedConfig_questionnaireName = untrustedConfig.questionnaireName;
+        if (typeof untrustedConfig_questionnaireName === 'string') {
+            config.questionnaireName = untrustedConfig_questionnaireName;
+        }
+        return config;
+    }
+    function validateAdapterConfig$a(untrustedConfig, configPropertyNames) {
+        if (!untrustedIsObject(untrustedConfig)) {
+            return null;
+        }
+        if (process.env.NODE_ENV !== 'production') {
+            validateConfig(untrustedConfig, configPropertyNames);
+        }
+        var config = typeCheckConfig$a(untrustedConfig);
+        if (!areRequiredParametersPresent(config, configPropertyNames)) {
+            return null;
+        }
+        return config;
+    }
+    function adapterFragment$5(luvio, config) {
+        createResourceParams$a(config);
+        return select$s();
+    }
+    function onFetchResponseSuccess$5(luvio, config, resourceParams, response) {
+        var snapshot = ingestSuccess$a(luvio, resourceParams, response, {
+            config: config,
+            resolve: function () { return buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions); }
+        });
+        return luvio.storeBroadcast().then(function () { return snapshot; });
+    }
+    function onFetchResponseError$5(luvio, config, resourceParams, response) {
+        var snapshot = ingestError$5(luvio, resourceParams, response, {
+            config: config,
+            resolve: function () { return buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions); }
+        });
+        return luvio.storeBroadcast().then(function () { return snapshot; });
+    }
+    function buildNetworkSnapshot$a(luvio, config, options) {
+        var resourceParams = createResourceParams$a(config);
+        var request = createResourceRequest$a(resourceParams);
+        return luvio.dispatchResourceRequest(request, options)
+            .then(function (response) {
+            return luvio.handleSuccessResponse(function () { return onFetchResponseSuccess$5(luvio, config, resourceParams, response); }, function () { return getResponseCacheKeys$a(luvio, resourceParams, response.body); });
+        }, function (response) {
+            return luvio.handleErrorResponse(function () { return onFetchResponseError$5(luvio, config, resourceParams, response); });
+        });
+    }
+    function buildNetworkSnapshotCachePolicy$5(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$a(luvio, config, dispatchOptions);
+    }
+    function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
+        var luvio = context.luvio, config = context.config;
+        var selector = {
+            recordId: keyBuilder$h(luvio, config),
+            node: adapterFragment$5(luvio, config),
+            variables: {},
+        };
+        var cacheSnapshot = storeLookup(selector, {
+            config: config,
+            resolve: function () { return buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions); }
+        });
+        return cacheSnapshot;
+    }
+    var getQuestionnaireAdapterFactory = function (luvio) { return function LEAP__getQuestionnaire(untrustedConfig, requestContext) {
+        var config = validateAdapterConfig$a(untrustedConfig, getQuestionnaire_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            return null;
+        }
+        return luvio.applyCachePolicy((requestContext || {}), { config: config, luvio: luvio }, // BuildSnapshotContext
+        buildCachedSnapshotCachePolicy$5, buildNetworkSnapshotCachePolicy$5);
+    }; };
+
+    function validate$d(obj, path) {
+        if (path === void 0) { path = 'LightningAssistantQuestionnaireInputRepresentation'; }
+        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_questionToAnswer = obj.questionToAnswer;
+            var path_questionToAnswer = path + '.questionToAnswer';
+            if (typeof obj_questionToAnswer !== 'object' || ArrayIsArray(obj_questionToAnswer) || obj_questionToAnswer === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj_questionToAnswer + '" (at "' + path_questionToAnswer + '")');
+            }
+            var obj_questionToAnswer_keys = ObjectKeys(obj_questionToAnswer);
+            for (var i = 0; i < obj_questionToAnswer_keys.length; i++) {
+                var key = obj_questionToAnswer_keys[i];
+                var obj_questionToAnswer_prop = obj_questionToAnswer[key];
+                var path_questionToAnswer_prop = path_questionToAnswer + '["' + key + '"]';
+                if (typeof obj_questionToAnswer_prop !== 'object' || ArrayIsArray(obj_questionToAnswer_prop) || obj_questionToAnswer_prop === null) {
+                    return new TypeError('Expected "object" but received "' + typeof obj_questionToAnswer_prop + '" (at "' + path_questionToAnswer_prop + '")');
+                }
+            }
+            var obj_status = obj.status;
+            var path_status = path + '.status';
+            if (typeof obj_status !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_status + '" (at "' + path_status + '")');
+            }
+        })();
+        return v_error === undefined ? null : v_error;
+    }
+
+    function select$r(luvio, params) {
+        return select$t();
+    }
+    function getResponseCacheKeys$9(luvio, resourceParams, response) {
+        return getTypeCacheKeys$8(luvio, response);
+    }
+    function ingestSuccess$9(luvio, resourceParams, response) {
+        var body = response.body;
+        var key = keyBuilderFromType$7(luvio, body);
+        luvio.storeIngest(key, ingest$8, body);
+        var snapshot = luvio.storeLookup({
+            recordId: key,
+            node: select$r(),
+            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$9(config) {
+        var headers = {};
+        return {
+            baseUri: '/services/data/v58.0',
+            basePath: '/assistant-platform/questionnaire/' + config.urlParams.questionnaireName + '',
+            method: 'patch',
+            body: config.body,
+            urlParams: config.urlParams,
+            queryParams: {},
+            headers: headers,
+            priority: 'normal',
+        };
+    }
+
+    var saveQuestionnaire_ConfigPropertyNames = {
+        displayName: 'saveQuestionnaire',
+        parameters: {
+            required: ['questionnaireName', 'questionnaireData'],
+            optional: []
+        }
+    };
+    function createResourceParams$9(config) {
+        var resourceParams = {
+            urlParams: {
+                questionnaireName: config.questionnaireName
+            },
+            body: {
+                questionnaireData: config.questionnaireData
+            }
+        };
+        return resourceParams;
+    }
+    function typeCheckConfig$9(untrustedConfig) {
+        var config = {};
+        var untrustedConfig_questionnaireName = untrustedConfig.questionnaireName;
+        if (typeof untrustedConfig_questionnaireName === 'string') {
+            config.questionnaireName = untrustedConfig_questionnaireName;
+        }
+        var untrustedConfig_questionnaireData = untrustedConfig.questionnaireData;
+        var referenceLightningAssistantQuestionnaireInputRepresentationValidationError = validate$d(untrustedConfig_questionnaireData);
+        if (referenceLightningAssistantQuestionnaireInputRepresentationValidationError === null) {
+            config.questionnaireData = untrustedConfig_questionnaireData;
+        }
+        return config;
+    }
+    function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
+        if (!untrustedIsObject(untrustedConfig)) {
+            return null;
+        }
+        if (process.env.NODE_ENV !== 'production') {
+            validateConfig(untrustedConfig, configPropertyNames);
+        }
+        var config = typeCheckConfig$9(untrustedConfig);
+        if (!areRequiredParametersPresent(config, configPropertyNames)) {
+            return null;
+        }
+        return config;
+    }
+    function buildNetworkSnapshot$9(luvio, config, options) {
+        var resourceParams = createResourceParams$9(config);
+        var request = createResourceRequest$9(resourceParams);
+        return luvio.dispatchResourceRequest(request, options)
+            .then(function (response) {
+            return luvio.handleSuccessResponse(function () {
+                var snapshot = ingestSuccess$9(luvio, resourceParams, response);
+                return luvio.storeBroadcast().then(function () { return snapshot; });
+            }, function () { return getResponseCacheKeys$9(luvio, resourceParams, response.body); });
+        }, function (response) {
+            deepFreeze(response);
+            throw response;
+        });
+    }
+    var saveQuestionnaireAdapterFactory = function (luvio) {
+        return function saveQuestionnaire(untrustedConfig) {
+            var config = validateAdapterConfig$9(untrustedConfig, saveQuestionnaire_ConfigPropertyNames);
+            // Invalid or incomplete config
+            if (config === null) {
+                throw new Error('Invalid config for "saveQuestionnaire"');
+            }
+            return buildNetworkSnapshot$9(luvio, config);
+        };
+    };
+
+    /******************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+
+    function __spreadArray(to, from, pack) {
+        if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+            if (ar || !(i in from)) {
+                if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+                ar[i] = from[i];
+            }
+        }
+        return to.concat(ar || Array.prototype.slice.call(from));
+    }
+
+    var VERSION$h = "a9a46e0cf983e314934e0703d28f75bf";
+    var select$q = function LightningAssistantLinkActionRepresentationSelect() {
+        var AbstractLightningAssistantActionRepresentationSelections = select$j().selections;
+        return {
+            kind: 'Fragment',
+            version: VERSION$h,
+            private: [],
+            selections: __spreadArray(__spreadArray([], AbstractLightningAssistantActionRepresentationSelections, true), [
+                {
+                    name: 'iconName',
+                    kind: 'Scalar',
+                    required: false
+                },
+                {
+                    name: 'label',
+                    kind: 'Scalar',
+                    required: false
+                },
+                {
+                    name: 'url',
+                    kind: 'Scalar'
+                }
+            ], false)
+        };
+    };
+
+    var VERSION$g = "c2fb7ece6f9eba9ca7b25608a670310a";
+    var select$p = function LightningAssistantCustomActionRepresentationSelect() {
+        var AbstractLightningAssistantActionRepresentationSelections = select$j().selections;
+        return {
+            kind: 'Fragment',
+            version: VERSION$g,
+            private: [],
+            selections: __spreadArray(__spreadArray([], AbstractLightningAssistantActionRepresentationSelections, true), [
+                {
+                    name: 'actionComponent',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'customData',
+                    kind: 'Scalar',
+                    map: true
+                },
+                {
+                    name: 'iconName',
+                    kind: 'Scalar',
+                    required: false
+                }
+            ], false)
+        };
+    };
+
+    var VERSION$f = "376fdaae939e8f46021d153816e03c56";
+    var select$o = function LightningAssistantNoActionRepresentationSelect() {
+        var AbstractLightningAssistantActionRepresentationSelections = select$j().selections;
+        return {
+            kind: 'Fragment',
+            version: VERSION$f,
+            private: [],
+            selections: __spreadArray([], AbstractLightningAssistantActionRepresentationSelections, true)
+        };
+    };
+
+    var VERSION$e = "2e0cc24f5c0ab2bbf7b6dade0eecb17e";
+    var select$n = function LightningAssistantLsfActionRepresentationSelect() {
+        var AbstractLightningAssistantActionRepresentationSelections = select$j().selections;
+        return {
+            kind: 'Fragment',
+            version: VERSION$e,
+            private: [],
+            selections: __spreadArray(__spreadArray([], AbstractLightningAssistantActionRepresentationSelections, true), [
+                {
+                    name: 'customData',
+                    kind: 'Scalar',
+                    map: true,
+                    required: false
+                },
+                {
+                    name: 'iconName',
+                    kind: 'Scalar',
+                    required: false
+                },
+                {
+                    name: 'label',
+                    kind: 'Scalar',
+                    required: false
+                },
+                {
+                    name: 'lsf',
+                    kind: 'Scalar'
+                }
+            ], false)
+        };
+    };
+
+    var VERSION$d = "d7605ace66fce89a8ae0436b797d125d";
+    var select$m = function LightningAssistantVideoActionRepresentationSelect() {
+        var AbstractLightningAssistantActionRepresentationSelections = select$j().selections;
+        return {
+            kind: 'Fragment',
+            version: VERSION$d,
+            private: [],
+            selections: __spreadArray(__spreadArray([], AbstractLightningAssistantActionRepresentationSelections, true), [
+                {
+                    name: 'iconName',
+                    kind: 'Scalar',
+                    required: false
+                },
+                {
+                    name: 'url',
+                    kind: 'Scalar'
+                }
+            ], false)
+        };
+    };
+
+    var VERSION$c = "fe9b2afa38e1fc9af6abd29c7fd3e307";
+    var select$l = function LightningAssistantWalkthroughActionRepresentationSelect() {
+        var AbstractLightningAssistantActionRepresentationSelections = select$j().selections;
+        return {
+            kind: 'Fragment',
+            version: VERSION$c,
+            private: [],
+            selections: __spreadArray(__spreadArray([], AbstractLightningAssistantActionRepresentationSelections, true), [
+                {
+                    name: 'iconName',
+                    kind: 'Scalar',
+                    required: false
+                },
+                {
+                    name: 'promptId',
+                    kind: 'Scalar'
+                }
+            ], false)
+        };
+    };
+
+    var VERSION$b = "2abd7cd970bb200649e8944e43b72de5";
+    var select$k = function LightningAssistantTrailheadActionRepresentationSelect() {
+        var AbstractLightningAssistantActionRepresentationSelections = select$j().selections;
+        return {
+            kind: 'Fragment',
+            version: VERSION$b,
+            private: [],
+            selections: __spreadArray(__spreadArray([], AbstractLightningAssistantActionRepresentationSelections, true), [
+                {
+                    name: 'iconName',
+                    kind: 'Scalar',
+                    required: false
+                },
+                {
+                    name: 'moduleId',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'url',
+                    kind: 'Scalar'
+                }
+            ], false)
+        };
+    };
+
+    var DiscriminatorValues;
+    (function (DiscriminatorValues) {
+        DiscriminatorValues["Link"] = "Link";
+        DiscriminatorValues["Custom"] = "Custom";
+        DiscriminatorValues["NoAction"] = "NoAction";
+        DiscriminatorValues["Lsf"] = "Lsf";
+        DiscriminatorValues["Video"] = "Video";
+        DiscriminatorValues["Walkthrough"] = "Walkthrough";
+        DiscriminatorValues["TlxModule"] = "TlxModule";
+    })(DiscriminatorValues || (DiscriminatorValues = {}));
+    var VERSION$a = "ee8eb1dcdc27527e958bea3bc608ab0c";
+    function validate$c(obj, path) {
+        if (path === void 0) { path = 'AbstractLightningAssistantActionRepresentation'; }
+        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_actionType = obj.actionType;
+            var path_actionType = path + '.actionType';
+            if (typeof obj_actionType !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_actionType + '" (at "' + path_actionType + '")');
+            }
+        })();
+        return v_error === undefined ? null : v_error;
+    }
+    var selectChildren = function AbstractLightningAssistantActionRepresentationSelectChildren() {
+        var _a;
+        var lightningAssistantLinkActionRepresentationSelections = select$q();
+        var lightningAssistantCustomActionRepresentationSelections = select$p();
+        var lightningAssistantNoActionRepresentationSelections = select$o();
+        var lightningAssistantLsfActionRepresentationSelections = select$n();
+        var lightningAssistantVideoActionRepresentationSelections = select$m();
+        var lightningAssistantWalkthroughActionRepresentationSelections = select$l();
+        var lightningAssistantTrailheadActionRepresentationSelections = select$k();
+        return {
+            kind: 'Fragment',
+            union: true,
+            discriminator: 'actionType',
+            unionSelections: (_a = {},
+                _a[DiscriminatorValues.Link] = lightningAssistantLinkActionRepresentationSelections,
+                _a[DiscriminatorValues.Custom] = lightningAssistantCustomActionRepresentationSelections,
+                _a[DiscriminatorValues.NoAction] = lightningAssistantNoActionRepresentationSelections,
+                _a[DiscriminatorValues.Lsf] = lightningAssistantLsfActionRepresentationSelections,
+                _a[DiscriminatorValues.Video] = lightningAssistantVideoActionRepresentationSelections,
+                _a[DiscriminatorValues.Walkthrough] = lightningAssistantWalkthroughActionRepresentationSelections,
+                _a[DiscriminatorValues.TlxModule] = lightningAssistantTrailheadActionRepresentationSelections,
+                _a)
+        };
+    };
+    var select$j = function AbstractLightningAssistantActionRepresentationSelect() {
+        return {
+            kind: 'Fragment',
+            version: VERSION$a,
+            private: [],
+            selections: [
+                {
+                    name: 'actionType',
+                    kind: 'Scalar'
+                }
+            ]
+        };
+    };
+    function equals$a(existing, incoming) {
+        var existing_actionType = existing.actionType;
+        var incoming_actionType = incoming.actionType;
+        if (!(existing_actionType === incoming_actionType)) {
+            return false;
+        }
+        return true;
+    }
+
+    var VERSION$9 = "28b96e40cf73e94d0650007d61c3214a";
+    function validate$b(obj, path) {
+        if (path === void 0) { path = 'LightningAssistantStepRepresentation'; }
+        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_action = obj.action;
+            var path_action = path + '.action';
+            var referencepath_actionValidationError = validate$c(obj_action, path_action);
+            if (referencepath_actionValidationError !== null) {
+                var message = 'Object doesn\'t match AbstractLightningAssistantActionRepresentation (at "' + path_action + '")\n';
+                message += referencepath_actionValidationError.message.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                return new TypeError(message);
+            }
+            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 + '")');
+                }
+            }
+            if (obj.figureComponent !== undefined) {
+                var obj_figureComponent = obj.figureComponent;
+                var path_figureComponent = path + '.figureComponent';
+                if (typeof obj_figureComponent !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_figureComponent + '" (at "' + path_figureComponent + '")');
+                }
+            }
+            if (obj.firstSeenTime !== undefined) {
+                var obj_firstSeenTime = obj.firstSeenTime;
+                var path_firstSeenTime = path + '.firstSeenTime';
+                if (typeof obj_firstSeenTime !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_firstSeenTime + '" (at "' + path_firstSeenTime + '")');
+                }
+            }
+            var obj_id = obj.id;
+            var path_id = path + '.id';
+            if (typeof obj_id !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_id + '" (at "' + path_id + '")');
+            }
+            var obj_isManaged = obj.isManaged;
+            var path_isManaged = path + '.isManaged';
+            if (typeof obj_isManaged !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isManaged + '" (at "' + path_isManaged + '")');
+            }
+            var obj_status = obj.status;
+            var path_status = path + '.status';
+            if (typeof obj_status !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_status + '" (at "' + path_status + '")');
+            }
+            if (obj.stepComponent !== undefined) {
+                var obj_stepComponent = obj.stepComponent;
+                var path_stepComponent = path + '.stepComponent';
+                if (typeof obj_stepComponent !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_stepComponent + '" (at "' + path_stepComponent + '")');
+                }
+            }
+            var obj_tags = obj.tags;
+            var path_tags = path + '.tags';
+            if (!ArrayIsArray(obj_tags)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_tags + '" (at "' + path_tags + '")');
+            }
+            for (var i = 0; i < obj_tags.length; i++) {
+                var obj_tags_item = obj_tags[i];
+                var path_tags_item = path_tags + '[' + i + ']';
+                if (typeof obj_tags_item !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_tags_item + '" (at "' + path_tags_item + '")');
+                }
+            }
+            var obj_title = obj.title;
+            var path_title = path + '.title';
+            if (typeof obj_title !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_title + '" (at "' + path_title + '")');
+            }
+            var obj_updateStrategy = obj.updateStrategy;
+            var path_updateStrategy = path + '.updateStrategy';
+            if (typeof obj_updateStrategy !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_updateStrategy + '" (at "' + path_updateStrategy + '")');
+            }
+        })();
+        return v_error === undefined ? null : v_error;
+    }
+    var RepresentationType$7 = 'LightningAssistantStepRepresentation';
+    function keyBuilder$g(luvio, config) {
+        return keyPrefix + '::' + RepresentationType$7 + ':' + config.step_id;
+    }
+    function keyBuilderFromType$6(luvio, object) {
+        var keyParams = {
+            step_id: object.id
+        };
+        return keyBuilder$g(luvio, keyParams);
+    }
+    function normalize$7(input, existing, path, luvio, store, timestamp) {
+        return input;
+    }
+    var select$i = function LightningAssistantStepRepresentationSelect() {
+        var AbstractLightningAssistantActionRepresentation__unionSelections = selectChildren();
+        return {
+            kind: 'Fragment',
+            version: VERSION$9,
+            private: [],
+            selections: [
+                {
+                    kind: 'Object',
+                    name: 'action',
+                    discriminator: AbstractLightningAssistantActionRepresentation__unionSelections.discriminator,
+                    union: true,
+                    nullable: false,
+                    unionSelections: AbstractLightningAssistantActionRepresentation__unionSelections.unionSelections
+                },
+                {
+                    name: 'description',
+                    kind: 'Scalar',
+                    required: false
+                },
+                {
+                    name: 'figureComponent',
+                    kind: 'Scalar',
+                    required: false
+                },
+                {
+                    name: 'firstSeenTime',
+                    kind: 'Scalar',
+                    required: false
+                },
+                {
+                    name: 'id',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'isManaged',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'status',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'stepComponent',
+                    kind: 'Scalar',
+                    required: false
+                },
+                {
+                    name: 'tags',
+                    kind: 'Scalar',
+                    plural: true
+                },
+                {
+                    name: 'title',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'updateStrategy',
+                    kind: 'Scalar'
+                }
+            ]
+        };
+    };
+    function equals$9(existing, incoming) {
+        var existing_isManaged = existing.isManaged;
+        var incoming_isManaged = incoming.isManaged;
+        if (!(existing_isManaged === incoming_isManaged)) {
+            return false;
+        }
+        var existing_description = existing.description;
+        var incoming_description = incoming.description;
+        // if at least one of these optionals is defined
+        if (existing_description !== undefined || incoming_description !== undefined) {
+            // if one of these is not defined we know the other is defined and therefore
+            // not equal
+            if (existing_description === undefined || incoming_description === undefined) {
+                return false;
+            }
+            if (!(existing_description === incoming_description)) {
+                return false;
+            }
+        }
+        var existing_figureComponent = existing.figureComponent;
+        var incoming_figureComponent = incoming.figureComponent;
+        // if at least one of these optionals is defined
+        if (existing_figureComponent !== undefined || incoming_figureComponent !== undefined) {
+            // if one of these is not defined we know the other is defined and therefore
+            // not equal
+            if (existing_figureComponent === undefined || incoming_figureComponent === undefined) {
+                return false;
+            }
+            if (!(existing_figureComponent === incoming_figureComponent)) {
+                return false;
+            }
+        }
+        var existing_firstSeenTime = existing.firstSeenTime;
+        var incoming_firstSeenTime = incoming.firstSeenTime;
+        // if at least one of these optionals is defined
+        if (existing_firstSeenTime !== undefined || incoming_firstSeenTime !== undefined) {
+            // if one of these is not defined we know the other is defined and therefore
+            // not equal
+            if (existing_firstSeenTime === undefined || incoming_firstSeenTime === undefined) {
+                return false;
+            }
+            if (!(existing_firstSeenTime === incoming_firstSeenTime)) {
+                return false;
+            }
+        }
+        var existing_id = existing.id;
+        var incoming_id = incoming.id;
+        if (!(existing_id === incoming_id)) {
+            return false;
+        }
+        var existing_status = existing.status;
+        var incoming_status = incoming.status;
+        if (!(existing_status === incoming_status)) {
+            return false;
+        }
+        var existing_stepComponent = existing.stepComponent;
+        var incoming_stepComponent = incoming.stepComponent;
+        // if at least one of these optionals is defined
+        if (existing_stepComponent !== undefined || incoming_stepComponent !== undefined) {
+            // if one of these is not defined we know the other is defined and therefore
+            // not equal
+            if (existing_stepComponent === undefined || incoming_stepComponent === undefined) {
+                return false;
+            }
+            if (!(existing_stepComponent === incoming_stepComponent)) {
+                return false;
+            }
+        }
+        var existing_title = existing.title;
+        var incoming_title = incoming.title;
+        if (!(existing_title === incoming_title)) {
+            return false;
+        }
+        var existing_updateStrategy = existing.updateStrategy;
+        var incoming_updateStrategy = incoming.updateStrategy;
+        if (!(existing_updateStrategy === incoming_updateStrategy)) {
+            return false;
+        }
+        var existing_action = existing.action;
+        var incoming_action = incoming.action;
+        if (!(equals$a(existing_action, incoming_action))) {
+            return false;
+        }
+        var existing_tags = existing.tags;
+        var incoming_tags = incoming.tags;
+        var equals_tags_items = equalsArray(existing_tags, incoming_tags, function (existing_tags_item, incoming_tags_item) {
+            if (!(existing_tags_item === incoming_tags_item)) {
+                return false;
+            }
+        });
+        if (equals_tags_items === false) {
+            return false;
+        }
+        return true;
+    }
+    var ingest$7 = function LightningAssistantStepRepresentationIngest(input, path, luvio, store, timestamp) {
+        if (process.env.NODE_ENV !== 'production') {
+            var validateError = validate$b(input);
+            if (validateError !== null) {
+                throw validateError;
+            }
+        }
+        var key = keyBuilderFromType$6(luvio, input);
+        var existingRecord = store.readEntry(key);
+        var ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
+        var incomingRecord = normalize$7(input, store.readEntry(key), {
+            fullPath: key,
+            parent: path.parent,
+            propertyName: path.propertyName,
+            ttl: ttlToUse
+        });
+        if (existingRecord === undefined || equals$9(existingRecord, incomingRecord) === false) {
+            luvio.storePublish(key, incomingRecord);
+        }
+        if (ttlToUse !== undefined) {
+            var storeMetadataParams = {
+                ttl: ttlToUse,
+                namespace: "LEAP",
+                version: VERSION$9,
+                representationName: RepresentationType$7,
+            };
+            luvio.publishStoreMetadata(key, storeMetadataParams);
+        }
+        return createLink(key);
+    };
+    function getTypeCacheKeys$7(luvio, input, fullPathFactory) {
+        var rootKeySet = new engine.StoreKeyMap();
+        // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+        var rootKey = keyBuilderFromType$6(luvio, input);
+        rootKeySet.set(rootKey, {
+            namespace: keyPrefix,
+            representationName: RepresentationType$7,
+            mergeable: false
+        });
+        return rootKeySet;
+    }
+
+    function select$h(luvio, params) {
+        return select$i();
+    }
+    function getResponseCacheKeys$8(luvio, resourceParams, response) {
+        return getTypeCacheKeys$7(luvio, response);
+    }
+    function ingestSuccess$8(luvio, resourceParams, response) {
+        var body = response.body;
+        var key = keyBuilderFromType$6(luvio, body);
+        luvio.storeIngest(key, ingest$7, body);
+        var snapshot = luvio.storeLookup({
+            recordId: key,
+            node: select$h(),
+            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$8(config) {
+        var headers = {};
+        return {
+            baseUri: '/services/data/v58.0',
+            basePath: '/assistant-platform/step/' + config.urlParams.stepName + '',
+            method: 'patch',
+            body: null,
+            urlParams: config.urlParams,
+            queryParams: {},
+            headers: headers,
+            priority: 'normal',
+        };
+    }
+
+    var evaluateStep_ConfigPropertyNames = {
+        displayName: 'evaluateStep',
+        parameters: {
+            required: ['stepName'],
+            optional: []
+        }
+    };
+    function createResourceParams$8(config) {
+        var resourceParams = {
+            urlParams: {
+                stepName: config.stepName
+            }
+        };
+        return resourceParams;
+    }
+    function typeCheckConfig$8(untrustedConfig) {
+        var config = {};
+        var untrustedConfig_stepName = untrustedConfig.stepName;
+        if (typeof untrustedConfig_stepName === 'string') {
+            config.stepName = untrustedConfig_stepName;
+        }
+        return config;
+    }
+    function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
+        if (!untrustedIsObject(untrustedConfig)) {
+            return null;
+        }
+        if (process.env.NODE_ENV !== 'production') {
+            validateConfig(untrustedConfig, configPropertyNames);
+        }
+        var config = typeCheckConfig$8(untrustedConfig);
+        if (!areRequiredParametersPresent(config, configPropertyNames)) {
+            return null;
+        }
+        return config;
+    }
+    function buildNetworkSnapshot$8(luvio, config, options) {
+        var resourceParams = createResourceParams$8(config);
+        var request = createResourceRequest$8(resourceParams);
+        return luvio.dispatchResourceRequest(request, options)
+            .then(function (response) {
+            return luvio.handleSuccessResponse(function () {
+                var snapshot = ingestSuccess$8(luvio, resourceParams, response);
+                return luvio.storeBroadcast().then(function () { return snapshot; });
+            }, function () { return getResponseCacheKeys$8(luvio, resourceParams, response.body); });
+        }, function (response) {
+            deepFreeze(response);
+            throw response;
+        });
+    }
+    var evaluateStepAdapterFactory = function (luvio) {
+        return function evaluateStep(untrustedConfig) {
+            var config = validateAdapterConfig$8(untrustedConfig, evaluateStep_ConfigPropertyNames);
+            // Invalid or incomplete config
+            if (config === null) {
+                throw new Error('Invalid config for "evaluateStep"');
+            }
+            return buildNetworkSnapshot$8(luvio, config);
+        };
+    };
+
+    var VERSION$8 = "bc99d93cdafe8300d6f09b735c390bcd";
+    function validate$a(obj, path) {
+        if (path === void 0) { path = 'LightningAssistantLayoutNodeRepresentation'; }
+        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_children = obj.children;
+            var path_children = path + '.children';
+            if (!ArrayIsArray(obj_children)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_children + '" (at "' + path_children + '")');
+            }
+            for (var i = 0; i < obj_children.length; i++) {
+                var obj_children_item = obj_children[i];
+                var path_children_item = path_children + '[' + i + ']';
+                if (obj_children_item === undefined) {
+                    return new TypeError('Expected "defined" but received "' + typeof obj_children_item + '" (at "' + path_children_item + '")');
+                }
+            }
+            var obj_description = obj.description;
+            var path_description = path + '.description';
+            var obj_description_union0 = null;
+            var obj_description_union0_error = (function () {
+                if (typeof obj_description !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_description + '" (at "' + path_description + '")');
+                }
+            })();
+            if (obj_description_union0_error != null) {
+                obj_description_union0 = obj_description_union0_error.message;
+            }
+            var obj_description_union1 = null;
+            var obj_description_union1_error = (function () {
+                if (obj_description !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_description + '" (at "' + path_description + '")');
+                }
+            })();
+            if (obj_description_union1_error != null) {
+                obj_description_union1 = obj_description_union1_error.message;
+            }
+            if (obj_description_union0 && obj_description_union1) {
+                var message = 'Object doesn\'t match union (at "' + path_description + '")';
+                message += '\n' + obj_description_union0.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                message += '\n' + obj_description_union1.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                return new TypeError(message);
+            }
+            var obj_status = obj.status;
+            var path_status = path + '.status';
+            var obj_status_union0 = null;
+            var obj_status_union0_error = (function () {
+                if (typeof obj_status !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_status + '" (at "' + path_status + '")');
+                }
+            })();
+            if (obj_status_union0_error != null) {
+                obj_status_union0 = obj_status_union0_error.message;
+            }
+            var obj_status_union1 = null;
+            var obj_status_union1_error = (function () {
+                if (obj_status !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_status + '" (at "' + path_status + '")');
+                }
+            })();
+            if (obj_status_union1_error != null) {
+                obj_status_union1 = obj_status_union1_error.message;
+            }
+            if (obj_status_union0 && obj_status_union1) {
+                var message = 'Object doesn\'t match union (at "' + path_status + '")';
+                message += '\n' + obj_status_union0.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                message += '\n' + obj_status_union1.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                return new TypeError(message);
+            }
+            var obj_step = obj.step;
+            var path_step = path + '.step';
+            var obj_step_union0 = null;
+            var obj_step_union0_error = (function () {
+                if (typeof obj_step !== 'object') {
+                    return new TypeError('Expected "object" but received "' + typeof obj_step + '" (at "' + path_step + '")');
+                }
+            })();
+            if (obj_step_union0_error != null) {
+                obj_step_union0 = obj_step_union0_error.message;
+            }
+            var obj_step_union1 = null;
+            var obj_step_union1_error = (function () {
+                if (obj_step !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_step + '" (at "' + path_step + '")');
+                }
+            })();
+            if (obj_step_union1_error != null) {
+                obj_step_union1 = obj_step_union1_error.message;
+            }
+            if (obj_step_union0 && obj_step_union1) {
+                var message = 'Object doesn\'t match union (at "' + path_step + '")';
+                message += '\n' + obj_step_union0.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                message += '\n' + obj_step_union1.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                return new TypeError(message);
+            }
+            var obj_tags = obj.tags;
+            var path_tags = path + '.tags';
+            if (!ArrayIsArray(obj_tags)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_tags + '" (at "' + path_tags + '")');
+            }
+            for (var i = 0; i < obj_tags.length; i++) {
+                var obj_tags_item = obj_tags[i];
+                var path_tags_item = path_tags + '[' + i + ']';
+                if (typeof obj_tags_item !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_tags_item + '" (at "' + path_tags_item + '")');
+                }
+            }
+            var obj_title = obj.title;
+            var path_title = path + '.title';
+            var obj_title_union0 = null;
+            var obj_title_union0_error = (function () {
+                if (typeof obj_title !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_title + '" (at "' + path_title + '")');
+                }
+            })();
+            if (obj_title_union0_error != null) {
+                obj_title_union0 = obj_title_union0_error.message;
+            }
+            var obj_title_union1 = null;
+            var obj_title_union1_error = (function () {
+                if (obj_title !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_title + '" (at "' + path_title + '")');
+                }
+            })();
+            if (obj_title_union1_error != null) {
+                obj_title_union1 = obj_title_union1_error.message;
+            }
+            if (obj_title_union0 && obj_title_union1) {
+                var message = 'Object doesn\'t match union (at "' + path_title + '")';
+                message += '\n' + obj_title_union0.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                message += '\n' + obj_title_union1.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                return new TypeError(message);
+            }
+            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$6 = 'LightningAssistantLayoutNodeRepresentation';
+    function normalize$6(input, existing, path, luvio, store, timestamp) {
+        var input_step = input.step;
+        var input_step_id = path.fullPath + '__step';
+        if (input_step !== null && typeof input_step === 'object') {
+            input.step = ingest$7(input_step, {
+                fullPath: input_step_id,
+                propertyName: 'step',
+                parent: {
+                    data: input,
+                    key: path.fullPath,
+                    existing: existing,
+                },
+                ttl: path.ttl
+            }, luvio, store);
+        }
+        return input;
+    }
+    var select$g = function LightningAssistantLayoutNodeRepresentationSelect() {
+        return {
+            kind: 'Fragment',
+            version: VERSION$8,
+            private: [],
+            selections: [
+                {
+                    name: 'children',
+                    kind: 'Object',
+                    // any
+                },
+                {
+                    name: 'description',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'status',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'step',
+                    kind: 'Link',
+                    nullable: true,
+                    fragment: select$i()
+                },
+                {
+                    name: 'tags',
+                    kind: 'Scalar',
+                    plural: true
+                },
+                {
+                    name: 'title',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'type',
+                    kind: 'Scalar'
+                }
+            ]
+        };
+    };
+    function equals$8(existing, incoming) {
+        var existing_type = existing.type;
+        var incoming_type = incoming.type;
+        if (!(existing_type === incoming_type)) {
+            return false;
+        }
+        var existing_children = existing.children;
+        var incoming_children = incoming.children;
+        var equals_children_items = equalsArray(existing_children, incoming_children, function (existing_children_item, incoming_children_item) {
+            if (JSONStringify(incoming_children_item) !== JSONStringify(existing_children_item)) {
+                return false;
+            }
+        });
+        if (equals_children_items === false) {
+            return false;
+        }
+        var existing_description = existing.description;
+        var incoming_description = incoming.description;
+        if (!(existing_description === incoming_description)) {
+            return false;
+        }
+        var existing_status = existing.status;
+        var incoming_status = incoming.status;
+        if (!(existing_status === incoming_status)) {
+            return false;
+        }
+        var existing_step = existing.step;
+        var incoming_step = incoming.step;
+        if (!(existing_step === incoming_step
+            || (existing_step != null &&
+                incoming_step != null &&
+                existing_step.__ref != null &&
+                incoming_step.__ref != null &&
+                existing_step.__ref === incoming_step.__ref))) {
+            return false;
+        }
+        var existing_tags = existing.tags;
+        var incoming_tags = incoming.tags;
+        var equals_tags_items = equalsArray(existing_tags, incoming_tags, function (existing_tags_item, incoming_tags_item) {
+            if (!(existing_tags_item === incoming_tags_item)) {
+                return false;
+            }
+        });
+        if (equals_tags_items === false) {
+            return false;
+        }
+        var existing_title = existing.title;
+        var incoming_title = incoming.title;
+        if (!(existing_title === incoming_title)) {
+            return false;
+        }
+        return true;
+    }
+    var ingest$6 = function LightningAssistantLayoutNodeRepresentationIngest(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 : 2592000000;
+        var incomingRecord = normalize$6(input, store.readEntry(key), {
+            fullPath: key,
+            parent: path.parent,
+            propertyName: path.propertyName,
+            ttl: ttlToUse
+        }, luvio, store);
+        if (existingRecord === undefined || equals$8(existingRecord, incomingRecord) === false) {
+            luvio.storePublish(key, incomingRecord);
+        }
+        if (ttlToUse !== undefined) {
+            var storeMetadataParams = {
+                ttl: ttlToUse,
+                namespace: "LEAP",
+                version: VERSION$8,
+                representationName: RepresentationType$6,
+            };
+            luvio.publishStoreMetadata(key, storeMetadataParams);
+        }
+        return createLink(key);
+    };
+    function getTypeCacheKeys$6(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$6,
+            mergeable: false
+        });
+        if (input.step !== null && typeof input.step === 'object') {
+            var input_step = getTypeCacheKeys$7(luvio, input.step);
+            rootKeySet.merge(input_step);
+        }
+        return rootKeySet;
+    }
+
+    var VERSION$7 = "596a25b0bee0b1db5495fe57dd7bd025";
+    function validate$9(obj, path) {
+        if (path === void 0) { path = 'LightningAssistantRepresentation'; }
+        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_assistantTarget = obj.assistantTarget;
+            var path_assistantTarget = path + '.assistantTarget';
+            if (typeof obj_assistantTarget !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_assistantTarget + '" (at "' + path_assistantTarget + '")');
+            }
+            if (obj.category !== undefined) {
+                var obj_category = obj.category;
+                var path_category = path + '.category';
+                if (typeof obj_category !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_category + '" (at "' + path_category + '")');
+                }
+            }
+            if (obj.categoryName !== undefined) {
+                var obj_categoryName = obj.categoryName;
+                var path_categoryName = path + '.categoryName';
+                if (typeof obj_categoryName !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_categoryName + '" (at "' + path_categoryName + '")');
+                }
+            }
+            if (obj.completionDate !== undefined) {
+                var obj_completionDate = obj.completionDate;
+                var path_completionDate = path + '.completionDate';
+                if (typeof obj_completionDate !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_completionDate + '" (at "' + path_completionDate + '")');
+                }
+            }
+            var obj_contentVersion = obj.contentVersion;
+            var path_contentVersion = path + '.contentVersion';
+            if (typeof obj_contentVersion !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_contentVersion + '" (at "' + path_contentVersion + '")');
+            }
+            var obj_debugModeEnabled = obj.debugModeEnabled;
+            var path_debugModeEnabled = path + '.debugModeEnabled';
+            if (typeof obj_debugModeEnabled !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_debugModeEnabled + '" (at "' + path_debugModeEnabled + '")');
+            }
+            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_developerName = obj.developerName;
+            var path_developerName = path + '.developerName';
+            if (typeof obj_developerName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_developerName + '" (at "' + path_developerName + '")');
+            }
+            if (obj.estimatedMinutesToComplete !== undefined) {
+                var obj_estimatedMinutesToComplete = obj.estimatedMinutesToComplete;
+                var path_estimatedMinutesToComplete = path + '.estimatedMinutesToComplete';
+                if (typeof obj_estimatedMinutesToComplete !== 'number' || (typeof obj_estimatedMinutesToComplete === 'number' && Math.floor(obj_estimatedMinutesToComplete) !== obj_estimatedMinutesToComplete)) {
+                    return new TypeError('Expected "integer" but received "' + typeof obj_estimatedMinutesToComplete + '" (at "' + path_estimatedMinutesToComplete + '")');
+                }
+            }
+            var obj_icon = obj.icon;
+            var path_icon = path + '.icon';
+            if (typeof obj_icon !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_icon + '" (at "' + path_icon + '")');
+            }
+            var obj_isArchived = obj.isArchived;
+            var path_isArchived = path + '.isArchived';
+            if (typeof obj_isArchived !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isArchived + '" (at "' + path_isArchived + '")');
+            }
+            var obj_isPreview = obj.isPreview;
+            var path_isPreview = path + '.isPreview';
+            if (typeof obj_isPreview !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isPreview + '" (at "' + path_isPreview + '")');
+            }
+            var obj_layout = obj.layout;
+            var path_layout = path + '.layout';
+            if (typeof obj_layout !== 'object') {
+                return new TypeError('Expected "object" but received "' + typeof obj_layout + '" (at "' + path_layout + '")');
+            }
+            var obj_numberOfSteps = obj.numberOfSteps;
+            var path_numberOfSteps = path + '.numberOfSteps';
+            if (typeof obj_numberOfSteps !== 'number' || (typeof obj_numberOfSteps === 'number' && Math.floor(obj_numberOfSteps) !== obj_numberOfSteps)) {
+                return new TypeError('Expected "integer" but received "' + typeof obj_numberOfSteps + '" (at "' + path_numberOfSteps + '")');
+            }
+            obj.progress;
+            var obj_questionnaireIds = obj.questionnaireIds;
+            var path_questionnaireIds = path + '.questionnaireIds';
+            if (!ArrayIsArray(obj_questionnaireIds)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_questionnaireIds + '" (at "' + path_questionnaireIds + '")');
+            }
+            for (var i = 0; i < obj_questionnaireIds.length; i++) {
+                var obj_questionnaireIds_item = obj_questionnaireIds[i];
+                var path_questionnaireIds_item = path_questionnaireIds + '[' + i + ']';
+                if (typeof obj_questionnaireIds_item !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_questionnaireIds_item + '" (at "' + path_questionnaireIds_item + '")');
+                }
+            }
+            var obj_status = obj.status;
+            var path_status = path + '.status';
+            if (typeof obj_status !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_status + '" (at "' + path_status + '")');
+            }
+            var obj_title = obj.title;
+            var path_title = path + '.title';
+            if (typeof obj_title !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_title + '" (at "' + path_title + '")');
+            }
+        })();
+        return v_error === undefined ? null : v_error;
+    }
+    var RepresentationType$5 = 'LightningAssistantRepresentation';
+    function keyBuilder$f(luvio, config) {
+        return keyPrefix + '::' + RepresentationType$5 + ':' + config.assistant_name;
+    }
+    function keyBuilderFromType$5(luvio, object) {
+        var keyParams = {
+            assistant_name: object.developerName
+        };
+        return keyBuilder$f(luvio, keyParams);
+    }
+    function normalize$5(input, existing, path, luvio, store, timestamp) {
+        var input_layout = input.layout;
+        var input_layout_id = path.fullPath + '__layout';
+        input.layout = ingest$6(input_layout, {
+            fullPath: input_layout_id,
+            propertyName: 'layout',
+            parent: {
+                data: input,
+                key: path.fullPath,
+                existing: existing,
+            },
+            ttl: path.ttl
+        }, luvio, store);
+        return input;
+    }
+    var select$f = function LightningAssistantRepresentationSelect() {
+        return {
+            kind: 'Fragment',
+            version: VERSION$7,
+            private: [],
+            selections: [
+                {
+                    name: 'assistantTarget',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'category',
+                    kind: 'Scalar',
+                    required: false
+                },
+                {
+                    name: 'categoryName',
+                    kind: 'Scalar',
+                    required: false
+                },
+                {
+                    name: 'completionDate',
+                    kind: 'Scalar',
+                    required: false
+                },
+                {
+                    name: 'contentVersion',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'debugModeEnabled',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'description',
+                    kind: 'Scalar',
+                    required: false
+                },
+                {
+                    name: 'developerName',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'estimatedMinutesToComplete',
+                    kind: 'Scalar',
+                    required: false
+                },
+                {
+                    name: 'icon',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'isArchived',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'isPreview',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'layout',
+                    kind: 'Link',
+                    fragment: select$g()
+                },
+                {
+                    name: 'numberOfSteps',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'progress',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'questionnaireIds',
+                    kind: 'Scalar',
+                    plural: true
+                },
+                {
+                    name: 'status',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'title',
+                    kind: 'Scalar'
+                }
+            ]
+        };
+    };
+    function equals$7(existing, incoming) {
+        var existing_debugModeEnabled = existing.debugModeEnabled;
+        var incoming_debugModeEnabled = incoming.debugModeEnabled;
+        if (!(existing_debugModeEnabled === incoming_debugModeEnabled)) {
+            return false;
+        }
+        var existing_isArchived = existing.isArchived;
+        var incoming_isArchived = incoming.isArchived;
+        if (!(existing_isArchived === incoming_isArchived)) {
+            return false;
+        }
+        var existing_isPreview = existing.isPreview;
+        var incoming_isPreview = incoming.isPreview;
+        if (!(existing_isPreview === incoming_isPreview)) {
+            return false;
+        }
+        var existing_estimatedMinutesToComplete = existing.estimatedMinutesToComplete;
+        var incoming_estimatedMinutesToComplete = incoming.estimatedMinutesToComplete;
+        // if at least one of these optionals is defined
+        if (existing_estimatedMinutesToComplete !== undefined || incoming_estimatedMinutesToComplete !== undefined) {
+            // if one of these is not defined we know the other is defined and therefore
+            // not equal
+            if (existing_estimatedMinutesToComplete === undefined || incoming_estimatedMinutesToComplete === undefined) {
+                return false;
+            }
+            if (!(existing_estimatedMinutesToComplete === incoming_estimatedMinutesToComplete)) {
+                return false;
+            }
+        }
+        var existing_numberOfSteps = existing.numberOfSteps;
+        var incoming_numberOfSteps = incoming.numberOfSteps;
+        if (!(existing_numberOfSteps === incoming_numberOfSteps)) {
+            return false;
+        }
+        var existing_assistantTarget = existing.assistantTarget;
+        var incoming_assistantTarget = incoming.assistantTarget;
+        if (!(existing_assistantTarget === incoming_assistantTarget)) {
+            return false;
+        }
+        var existing_category = existing.category;
+        var incoming_category = incoming.category;
+        // if at least one of these optionals is defined
+        if (existing_category !== undefined || incoming_category !== undefined) {
+            // if one of these is not defined we know the other is defined and therefore
+            // not equal
+            if (existing_category === undefined || incoming_category === undefined) {
+                return false;
+            }
+            if (!(existing_category === incoming_category)) {
+                return false;
+            }
+        }
+        var existing_categoryName = existing.categoryName;
+        var incoming_categoryName = incoming.categoryName;
+        // if at least one of these optionals is defined
+        if (existing_categoryName !== undefined || incoming_categoryName !== undefined) {
+            // if one of these is not defined we know the other is defined and therefore
+            // not equal
+            if (existing_categoryName === undefined || incoming_categoryName === undefined) {
+                return false;
+            }
+            if (!(existing_categoryName === incoming_categoryName)) {
+                return false;
+            }
+        }
+        var existing_completionDate = existing.completionDate;
+        var incoming_completionDate = incoming.completionDate;
+        // if at least one of these optionals is defined
+        if (existing_completionDate !== undefined || incoming_completionDate !== undefined) {
+            // if one of these is not defined we know the other is defined and therefore
+            // not equal
+            if (existing_completionDate === undefined || incoming_completionDate === undefined) {
+                return false;
+            }
+            if (!(existing_completionDate === incoming_completionDate)) {
+                return false;
+            }
+        }
+        var existing_contentVersion = existing.contentVersion;
+        var incoming_contentVersion = incoming.contentVersion;
+        if (!(existing_contentVersion === incoming_contentVersion)) {
+            return false;
+        }
+        var existing_description = existing.description;
+        var incoming_description = incoming.description;
+        // if at least one of these optionals is defined
+        if (existing_description !== undefined || incoming_description !== undefined) {
+            // if one of these is not defined we know the other is defined and therefore
+            // not equal
+            if (existing_description === undefined || incoming_description === undefined) {
+                return false;
+            }
+            if (!(existing_description === incoming_description)) {
+                return false;
+            }
+        }
+        var existing_developerName = existing.developerName;
+        var incoming_developerName = incoming.developerName;
+        if (!(existing_developerName === incoming_developerName)) {
+            return false;
+        }
+        var existing_icon = existing.icon;
+        var incoming_icon = incoming.icon;
+        if (!(existing_icon === incoming_icon)) {
+            return false;
+        }
+        var existing_status = existing.status;
+        var incoming_status = incoming.status;
+        if (!(existing_status === incoming_status)) {
+            return false;
+        }
+        var existing_title = existing.title;
+        var incoming_title = incoming.title;
+        if (!(existing_title === incoming_title)) {
+            return false;
+        }
+        var existing_progress = existing.progress;
+        var incoming_progress = incoming.progress;
+        if (!(existing_progress === incoming_progress)) {
+            return false;
+        }
+        var existing_layout = existing.layout;
+        var incoming_layout = incoming.layout;
+        if (!(existing_layout.__ref === incoming_layout.__ref)) {
+            return false;
+        }
+        var existing_questionnaireIds = existing.questionnaireIds;
+        var incoming_questionnaireIds = incoming.questionnaireIds;
+        var equals_questionnaireIds_items = equalsArray(existing_questionnaireIds, incoming_questionnaireIds, function (existing_questionnaireIds_item, incoming_questionnaireIds_item) {
+            if (!(existing_questionnaireIds_item === incoming_questionnaireIds_item)) {
+                return false;
+            }
+        });
+        if (equals_questionnaireIds_items === false) {
+            return false;
+        }
+        return true;
+    }
+    var ingest$5 = function LightningAssistantRepresentationIngest(input, path, luvio, store, timestamp) {
+        if (process.env.NODE_ENV !== 'production') {
+            var validateError = validate$9(input);
+            if (validateError !== null) {
+                throw validateError;
+            }
+        }
+        var key = keyBuilderFromType$5(luvio, input);
+        var existingRecord = store.readEntry(key);
+        var ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
+        var incomingRecord = normalize$5(input, store.readEntry(key), {
+            fullPath: key,
+            parent: path.parent,
+            propertyName: path.propertyName,
+            ttl: ttlToUse
+        }, luvio, store);
+        if (existingRecord === undefined || equals$7(existingRecord, incomingRecord) === false) {
+            luvio.storePublish(key, incomingRecord);
+        }
+        if (ttlToUse !== undefined) {
+            var storeMetadataParams = {
+                ttl: ttlToUse,
+                namespace: "LEAP",
+                version: VERSION$7,
+                representationName: RepresentationType$5,
+            };
+            luvio.publishStoreMetadata(key, storeMetadataParams);
+        }
+        return createLink(key);
+    };
+    function getTypeCacheKeys$5(luvio, input, fullPathFactory) {
+        var rootKeySet = new engine.StoreKeyMap();
+        // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+        var rootKey = keyBuilderFromType$5(luvio, input);
+        rootKeySet.set(rootKey, {
+            namespace: keyPrefix,
+            representationName: RepresentationType$5,
+            mergeable: false
+        });
+        var input_layout = getTypeCacheKeys$6(luvio, input.layout, function () { return rootKey + "__" + "layout"; });
+        rootKeySet.merge(input_layout);
+        return rootKeySet;
+    }
+
+    function select$e(luvio, params) {
+        return select$f();
+    }
+    function keyBuilder$e(luvio, params) {
+        return keyBuilder$f(luvio, {
+            assistant_name: params.urlParams.assistantName
+        });
+    }
+    function getResponseCacheKeys$7(luvio, resourceParams, response) {
+        return getTypeCacheKeys$5(luvio, response);
+    }
+    function ingestSuccess$7(luvio, resourceParams, response, snapshotRefresh) {
+        var body = response.body;
+        var key = keyBuilder$e(luvio, resourceParams);
+        luvio.storeIngest(key, ingest$5, body);
+        var snapshot = luvio.storeLookup({
+            recordId: key,
+            node: select$e(),
+            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$4(luvio, params, error, snapshotRefresh) {
+        var key = keyBuilder$e(luvio, params);
+        var errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+        luvio.storeIngestError(key, errorSnapshot);
+        return errorSnapshot;
+    }
+    function createResourceRequest$7(config) {
+        var headers = {};
+        return {
+            baseUri: '/services/data/v58.0',
+            basePath: '/assistant-platform/' + config.urlParams.assistantName + '',
+            method: 'get',
+            body: null,
+            urlParams: config.urlParams,
+            queryParams: {},
+            headers: headers,
+            priority: 'normal',
+        };
+    }
+
+    var getAssistant_ConfigPropertyNames = {
+        displayName: 'getAssistant',
+        parameters: {
+            required: ['assistantName'],
+            optional: []
+        }
+    };
+    function createResourceParams$7(config) {
+        var resourceParams = {
+            urlParams: {
+                assistantName: config.assistantName
+            }
+        };
+        return resourceParams;
+    }
+    function keyBuilder$d(luvio, config) {
+        var resourceParams = createResourceParams$7(config);
+        return keyBuilder$e(luvio, resourceParams);
+    }
+    function typeCheckConfig$7(untrustedConfig) {
+        var config = {};
+        var untrustedConfig_assistantName = untrustedConfig.assistantName;
+        if (typeof untrustedConfig_assistantName === 'string') {
+            config.assistantName = untrustedConfig_assistantName;
+        }
+        return config;
+    }
+    function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
+        if (!untrustedIsObject(untrustedConfig)) {
+            return null;
+        }
+        if (process.env.NODE_ENV !== 'production') {
+            validateConfig(untrustedConfig, configPropertyNames);
+        }
+        var config = typeCheckConfig$7(untrustedConfig);
+        if (!areRequiredParametersPresent(config, configPropertyNames)) {
+            return null;
+        }
+        return config;
+    }
+    function adapterFragment$4(luvio, config) {
+        createResourceParams$7(config);
+        return select$e();
+    }
+    function onFetchResponseSuccess$4(luvio, config, resourceParams, response) {
+        var snapshot = ingestSuccess$7(luvio, resourceParams, response, {
+            config: config,
+            resolve: function () { return buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions); }
+        });
+        return luvio.storeBroadcast().then(function () { return snapshot; });
+    }
+    function onFetchResponseError$4(luvio, config, resourceParams, response) {
+        var snapshot = ingestError$4(luvio, resourceParams, response, {
+            config: config,
+            resolve: function () { return buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions); }
+        });
+        return luvio.storeBroadcast().then(function () { return snapshot; });
+    }
+    function buildNetworkSnapshot$7(luvio, config, options) {
+        var resourceParams = createResourceParams$7(config);
+        var request = createResourceRequest$7(resourceParams);
+        return luvio.dispatchResourceRequest(request, options)
+            .then(function (response) {
+            return luvio.handleSuccessResponse(function () { return onFetchResponseSuccess$4(luvio, config, resourceParams, response); }, function () { return getResponseCacheKeys$7(luvio, resourceParams, response.body); });
+        }, function (response) {
+            return luvio.handleErrorResponse(function () { return onFetchResponseError$4(luvio, config, resourceParams, response); });
+        });
+    }
+    function buildNetworkSnapshotCachePolicy$4(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$7(luvio, config, dispatchOptions);
+    }
+    function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
+        var luvio = context.luvio, config = context.config;
+        var selector = {
+            recordId: keyBuilder$d(luvio, config),
+            node: adapterFragment$4(luvio, config),
+            variables: {},
+        };
+        var cacheSnapshot = storeLookup(selector, {
+            config: config,
+            resolve: function () { return buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions); }
+        });
+        return cacheSnapshot;
+    }
+    var getAssistantAdapterFactory = function (luvio) { return function LEAP__getAssistant(untrustedConfig, requestContext) {
+        var config = validateAdapterConfig$7(untrustedConfig, getAssistant_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            return null;
+        }
+        return luvio.applyCachePolicy((requestContext || {}), { config: config, luvio: luvio }, // BuildSnapshotContext
+        buildCachedSnapshotCachePolicy$4, buildNetworkSnapshotCachePolicy$4);
+    }; };
+
+    function validate$8(obj, path) {
+        if (path === void 0) { path = 'LightningAssistantUpdateInputRepresentation'; }
+        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_items = obj.items;
+            var path_items = path + '.items';
+            if (typeof obj_items !== 'object' || ArrayIsArray(obj_items) || obj_items === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj_items + '" (at "' + path_items + '")');
+            }
+            var obj_items_keys = ObjectKeys(obj_items);
+            for (var i = 0; i < obj_items_keys.length; i++) {
+                var key = obj_items_keys[i];
+                var obj_items_prop = obj_items[key];
+                var path_items_prop = path_items + '["' + key + '"]';
+                if (typeof obj_items_prop !== 'object' || ArrayIsArray(obj_items_prop) || obj_items_prop === null) {
+                    return new TypeError('Expected "object" but received "' + typeof obj_items_prop + '" (at "' + path_items_prop + '")');
+                }
+            }
+        })();
+        return v_error === undefined ? null : v_error;
+    }
+
+    function select$d(luvio, params) {
+        return select$f();
+    }
+    function getResponseCacheKeys$6(luvio, resourceParams, response) {
+        return getTypeCacheKeys$5(luvio, response);
+    }
+    function ingestSuccess$6(luvio, resourceParams, response) {
+        var body = response.body;
+        var key = keyBuilderFromType$5(luvio, body);
+        luvio.storeIngest(key, ingest$5, body);
+        var snapshot = luvio.storeLookup({
+            recordId: key,
+            node: select$d(),
+            variables: {},
+        });
+        if (process.env.NODE_ENV !== 'production') {
+            if (snapshot.state !== 'Fulfilled') {
+                throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+            }
+        }
+        return snapshot;
+    }
+    function createResourceRequest$6(config) {
+        var headers = {};
+        return {
+            baseUri: '/services/data/v58.0',
+            basePath: '/assistant-platform/' + config.urlParams.assistantName + '',
+            method: 'patch',
+            body: config.body,
+            urlParams: config.urlParams,
+            queryParams: {},
+            headers: headers,
+            priority: 'normal',
+        };
+    }
+
+    var saveAssistant_ConfigPropertyNames = {
+        displayName: 'saveAssistant',
+        parameters: {
+            required: ['assistantName', 'assistantData'],
+            optional: []
+        }
+    };
+    function createResourceParams$6(config) {
+        var resourceParams = {
+            urlParams: {
+                assistantName: config.assistantName
+            },
+            body: {
+                assistantData: config.assistantData
+            }
+        };
+        return resourceParams;
+    }
+    function typeCheckConfig$6(untrustedConfig) {
+        var config = {};
+        var untrustedConfig_assistantName = untrustedConfig.assistantName;
+        if (typeof untrustedConfig_assistantName === 'string') {
+            config.assistantName = untrustedConfig_assistantName;
+        }
+        var untrustedConfig_assistantData = untrustedConfig.assistantData;
+        var referenceLightningAssistantUpdateInputRepresentationValidationError = validate$8(untrustedConfig_assistantData);
+        if (referenceLightningAssistantUpdateInputRepresentationValidationError === null) {
+            config.assistantData = untrustedConfig_assistantData;
+        }
+        return config;
+    }
+    function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
+        if (!untrustedIsObject(untrustedConfig)) {
+            return null;
+        }
+        if (process.env.NODE_ENV !== 'production') {
+            validateConfig(untrustedConfig, configPropertyNames);
+        }
+        var config = typeCheckConfig$6(untrustedConfig);
+        if (!areRequiredParametersPresent(config, configPropertyNames)) {
+            return null;
+        }
+        return config;
+    }
+    function buildNetworkSnapshot$6(luvio, config, options) {
+        var resourceParams = createResourceParams$6(config);
+        var request = createResourceRequest$6(resourceParams);
+        return luvio.dispatchResourceRequest(request, options)
+            .then(function (response) {
+            return luvio.handleSuccessResponse(function () {
+                var snapshot = ingestSuccess$6(luvio, resourceParams, response);
+                return luvio.storeBroadcast().then(function () { return snapshot; });
+            }, function () { return getResponseCacheKeys$6(luvio, resourceParams, response.body); });
+        }, function (response) {
+            deepFreeze(response);
+            throw response;
+        });
+    }
+    var saveAssistantAdapterFactory = function (luvio) {
+        return function saveAssistant(untrustedConfig) {
+            var config = validateAdapterConfig$6(untrustedConfig, saveAssistant_ConfigPropertyNames);
+            // Invalid or incomplete config
+            if (config === null) {
+                throw new Error('Invalid config for "saveAssistant"');
+            }
+            return buildNetworkSnapshot$6(luvio, config);
+        };
+    };
+
+    var VERSION$6 = "042081dc16ad8bafa711efc0ff696bde";
+    function validate$7(obj, path) {
+        if (path === void 0) { path = 'LightningAssistantQuestionnaireListRepresentation'; }
+        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_assistantName = obj.assistantName;
+            var path_assistantName = path + '.assistantName';
+            if (typeof obj_assistantName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_assistantName + '" (at "' + path_assistantName + '")');
+            }
+            var obj_questionnaireNames = obj.questionnaireNames;
+            var path_questionnaireNames = path + '.questionnaireNames';
+            if (!ArrayIsArray(obj_questionnaireNames)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_questionnaireNames + '" (at "' + path_questionnaireNames + '")');
+            }
+            for (var i = 0; i < obj_questionnaireNames.length; i++) {
+                var obj_questionnaireNames_item = obj_questionnaireNames[i];
+                var path_questionnaireNames_item = path_questionnaireNames + '[' + i + ']';
+                if (typeof obj_questionnaireNames_item !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_questionnaireNames_item + '" (at "' + path_questionnaireNames_item + '")');
+                }
+            }
+        })();
+        return v_error === undefined ? null : v_error;
+    }
+    var RepresentationType$4 = 'LightningAssistantQuestionnaireListRepresentation';
+    function keyBuilder$c(luvio, config) {
+        return keyPrefix + '::' + RepresentationType$4 + ':' + config.assistant_name;
+    }
+    function keyBuilderFromType$4(luvio, object) {
+        var keyParams = {
+            assistant_name: object.assistantName
+        };
+        return keyBuilder$c(luvio, keyParams);
+    }
+    function normalize$4(input, existing, path, luvio, store, timestamp) {
+        return input;
+    }
+    var select$c = function LightningAssistantQuestionnaireListRepresentationSelect() {
+        return {
+            kind: 'Fragment',
+            version: VERSION$6,
+            private: [],
+            selections: [
+                {
+                    name: 'assistantName',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'questionnaireNames',
+                    kind: 'Scalar',
+                    plural: true
+                }
+            ]
+        };
+    };
+    function equals$6(existing, incoming) {
+        var existing_assistantName = existing.assistantName;
+        var incoming_assistantName = incoming.assistantName;
+        if (!(existing_assistantName === incoming_assistantName)) {
+            return false;
+        }
+        var existing_questionnaireNames = existing.questionnaireNames;
+        var incoming_questionnaireNames = incoming.questionnaireNames;
+        var equals_questionnaireNames_items = equalsArray(existing_questionnaireNames, incoming_questionnaireNames, function (existing_questionnaireNames_item, incoming_questionnaireNames_item) {
+            if (!(existing_questionnaireNames_item === incoming_questionnaireNames_item)) {
+                return false;
+            }
+        });
+        if (equals_questionnaireNames_items === false) {
+            return false;
+        }
+        return true;
+    }
+    var ingest$4 = function LightningAssistantQuestionnaireListRepresentationIngest(input, path, luvio, store, timestamp) {
+        if (process.env.NODE_ENV !== 'production') {
+            var validateError = validate$7(input);
+            if (validateError !== null) {
+                throw validateError;
+            }
+        }
+        var key = keyBuilderFromType$4(luvio, input);
+        var existingRecord = store.readEntry(key);
+        var ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
+        var incomingRecord = normalize$4(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: "LEAP",
+                version: VERSION$6,
+                representationName: RepresentationType$4,
+            };
+            luvio.publishStoreMetadata(key, storeMetadataParams);
+        }
+        return createLink(key);
+    };
+    function getTypeCacheKeys$4(luvio, input, fullPathFactory) {
+        var rootKeySet = new engine.StoreKeyMap();
+        // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+        var rootKey = keyBuilderFromType$4(luvio, input);
+        rootKeySet.set(rootKey, {
+            namespace: keyPrefix,
+            representationName: RepresentationType$4,
+            mergeable: false
+        });
+        return rootKeySet;
+    }
+
+    function select$b(luvio, params) {
+        return select$c();
+    }
+    function keyBuilder$b(luvio, params) {
+        return keyBuilder$c(luvio, {
+            assistant_name: params.urlParams.assistantName
+        });
+    }
+    function getResponseCacheKeys$5(luvio, resourceParams, response) {
+        return getTypeCacheKeys$4(luvio, response);
+    }
+    function ingestSuccess$5(luvio, resourceParams, response, snapshotRefresh) {
+        var body = response.body;
+        var key = keyBuilder$b(luvio, resourceParams);
+        luvio.storeIngest(key, ingest$4, 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$b(luvio, params);
+        var errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+        luvio.storeIngestError(key, errorSnapshot);
+        return errorSnapshot;
+    }
+    function createResourceRequest$5(config) {
+        var headers = {};
+        return {
+            baseUri: '/services/data/v58.0',
+            basePath: '/assistant-platform/' + config.urlParams.assistantName + '/questionnaires',
+            method: 'get',
+            body: null,
+            urlParams: config.urlParams,
+            queryParams: {},
+            headers: headers,
+            priority: 'normal',
+        };
+    }
+
+    var getQuestionnaires_ConfigPropertyNames = {
+        displayName: 'getQuestionnaires',
+        parameters: {
+            required: ['assistantName'],
+            optional: []
+        }
+    };
+    function createResourceParams$5(config) {
+        var resourceParams = {
+            urlParams: {
+                assistantName: config.assistantName
+            }
+        };
+        return resourceParams;
+    }
+    function keyBuilder$a(luvio, config) {
+        var resourceParams = createResourceParams$5(config);
+        return keyBuilder$b(luvio, resourceParams);
+    }
+    function typeCheckConfig$5(untrustedConfig) {
+        var config = {};
+        var untrustedConfig_assistantName = untrustedConfig.assistantName;
+        if (typeof untrustedConfig_assistantName === 'string') {
+            config.assistantName = untrustedConfig_assistantName;
+        }
+        return config;
+    }
+    function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
+        if (!untrustedIsObject(untrustedConfig)) {
+            return null;
+        }
+        if (process.env.NODE_ENV !== 'production') {
+            validateConfig(untrustedConfig, configPropertyNames);
+        }
+        var config = typeCheckConfig$5(untrustedConfig);
+        if (!areRequiredParametersPresent(config, configPropertyNames)) {
+            return null;
+        }
+        return config;
+    }
+    function adapterFragment$3(luvio, config) {
+        createResourceParams$5(config);
+        return select$b();
+    }
+    function onFetchResponseSuccess$3(luvio, config, resourceParams, response) {
+        var snapshot = ingestSuccess$5(luvio, resourceParams, response, {
+            config: config,
+            resolve: function () { return buildNetworkSnapshot$5(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$5(luvio, config, snapshotRefreshOptions); }
+        });
+        return luvio.storeBroadcast().then(function () { return snapshot; });
+    }
+    function buildNetworkSnapshot$5(luvio, config, options) {
+        var resourceParams = createResourceParams$5(config);
+        var request = createResourceRequest$5(resourceParams);
+        return luvio.dispatchResourceRequest(request, options)
+            .then(function (response) {
+            return luvio.handleSuccessResponse(function () { return onFetchResponseSuccess$3(luvio, config, resourceParams, response); }, function () { return getResponseCacheKeys$5(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: undefined,
+            },
+            eventObservers: eventObservers
+        };
+        if (networkPriority !== 'normal') {
+            dispatchOptions.overrides = {
+                priority: networkPriority
+            };
+        }
+        return buildNetworkSnapshot$5(luvio, config, dispatchOptions);
+    }
+    function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
+        var luvio = context.luvio, config = context.config;
+        var selector = {
+            recordId: keyBuilder$a(luvio, config),
+            node: adapterFragment$3(luvio, config),
+            variables: {},
+        };
+        var cacheSnapshot = storeLookup(selector, {
+            config: config,
+            resolve: function () { return buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions); }
+        });
+        return cacheSnapshot;
+    }
+    var getQuestionnairesAdapterFactory = function (luvio) { return function LEAP__getQuestionnaires(untrustedConfig, requestContext) {
+        var config = validateAdapterConfig$5(untrustedConfig, getQuestionnaires_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            return null;
+        }
+        return luvio.applyCachePolicy((requestContext || {}), { config: config, luvio: luvio }, // BuildSnapshotContext
+        buildCachedSnapshotCachePolicy$3, buildNetworkSnapshotCachePolicy$3);
+    }; };
+
+    var VERSION$5 = "107898f86df2248eab831be29f7e7205";
+    function validate$6(obj, path) {
+        if (path === void 0) { path = 'LightningAssistantCategoryRepresentation'; }
+        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_developerName = obj.developerName;
+            var path_developerName = path + '.developerName';
+            if (typeof obj_developerName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_developerName + '" (at "' + path_developerName + '")');
+            }
+            var obj_recommended = obj.recommended;
+            var path_recommended = path + '.recommended';
+            if (typeof obj_recommended !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_recommended + '" (at "' + path_recommended + '")');
+            }
+            var obj_title = obj.title;
+            var path_title = path + '.title';
+            if (typeof obj_title !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_title + '" (at "' + path_title + '")');
+            }
+        })();
+        return v_error === undefined ? null : v_error;
+    }
+    var select$a = function LightningAssistantCategoryRepresentationSelect() {
+        return {
+            kind: 'Fragment',
+            version: VERSION$5,
+            private: [],
+            selections: [
+                {
+                    name: 'developerName',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'recommended',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'title',
+                    kind: 'Scalar'
+                }
+            ]
+        };
+    };
+    function equals$5(existing, incoming) {
+        var existing_recommended = existing.recommended;
+        var incoming_recommended = incoming.recommended;
+        if (!(existing_recommended === incoming_recommended)) {
+            return false;
+        }
+        var existing_developerName = existing.developerName;
+        var incoming_developerName = incoming.developerName;
+        if (!(existing_developerName === incoming_developerName)) {
+            return false;
+        }
+        var existing_title = existing.title;
+        var incoming_title = incoming.title;
+        if (!(existing_title === incoming_title)) {
+            return false;
+        }
+        return true;
+    }
+
+    var VERSION$4 = "f629b70d652ad385840baede1ec16739";
+    function validate$5(obj, path) {
+        if (path === void 0) { path = 'LightningAssistantTargetRepresentation'; }
+        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_categoryList = obj.categoryList;
+            var path_categoryList = path + '.categoryList';
+            if (!ArrayIsArray(obj_categoryList)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_categoryList + '" (at "' + path_categoryList + '")');
+            }
+            for (var i = 0; i < obj_categoryList.length; i++) {
+                var obj_categoryList_item = obj_categoryList[i];
+                var path_categoryList_item = path_categoryList + '[' + i + ']';
+                var referencepath_categoryList_itemValidationError = validate$6(obj_categoryList_item, path_categoryList_item);
+                if (referencepath_categoryList_itemValidationError !== null) {
+                    var message = 'Object doesn\'t match LightningAssistantCategoryRepresentation (at "' + path_categoryList_item + '")\n';
+                    message += referencepath_categoryList_itemValidationError.message.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                    return new TypeError(message);
+                }
+            }
+            var obj_developerName = obj.developerName;
+            var path_developerName = path + '.developerName';
+            if (typeof obj_developerName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_developerName + '" (at "' + path_developerName + '")');
+            }
+        })();
+        return v_error === undefined ? null : v_error;
+    }
+    var RepresentationType$3 = 'LightningAssistantTargetRepresentation';
+    function keyBuilder$9(luvio, config) {
+        return keyPrefix + '::' + RepresentationType$3 + ':' + config.assistant_target;
+    }
+    function keyBuilderFromType$3(luvio, object) {
+        var keyParams = {
+            assistant_target: object.developerName
+        };
+        return keyBuilder$9(luvio, keyParams);
+    }
+    function normalize$3(input, existing, path, luvio, store, timestamp) {
+        return input;
+    }
+    var select$9 = function LightningAssistantTargetRepresentationSelect() {
+        var _a = select$a(), LightningAssistantCategoryRepresentation__selections = _a.selections;
+        return {
+            kind: 'Fragment',
+            version: VERSION$4,
+            private: [],
+            selections: [
+                {
+                    name: 'categoryList',
+                    kind: 'Object',
+                    plural: true,
+                    selections: LightningAssistantCategoryRepresentation__selections
+                },
+                {
+                    name: 'developerName',
+                    kind: 'Scalar'
+                }
+            ]
+        };
+    };
+    function equals$4(existing, incoming) {
+        var existing_developerName = existing.developerName;
+        var incoming_developerName = incoming.developerName;
+        if (!(existing_developerName === incoming_developerName)) {
+            return false;
+        }
+        var existing_categoryList = existing.categoryList;
+        var incoming_categoryList = incoming.categoryList;
+        var equals_categoryList_items = equalsArray(existing_categoryList, incoming_categoryList, function (existing_categoryList_item, incoming_categoryList_item) {
+            if (!(equals$5(existing_categoryList_item, incoming_categoryList_item))) {
+                return false;
+            }
+        });
+        if (equals_categoryList_items === false) {
+            return false;
+        }
+        return true;
+    }
+    var ingest$3 = function LightningAssistantTargetRepresentationIngest(input, path, luvio, store, timestamp) {
+        if (process.env.NODE_ENV !== 'production') {
+            var validateError = validate$5(input);
+            if (validateError !== null) {
+                throw validateError;
+            }
+        }
+        var key = keyBuilderFromType$3(luvio, input);
+        var existingRecord = store.readEntry(key);
+        var ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
+        var incomingRecord = normalize$3(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: "LEAP",
+                version: VERSION$4,
+                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 = keyBuilderFromType$3(luvio, input);
+        rootKeySet.set(rootKey, {
+            namespace: keyPrefix,
+            representationName: RepresentationType$3,
+            mergeable: false
+        });
+        return rootKeySet;
+    }
+
+    function select$8(luvio, params) {
+        return select$9();
+    }
+    function keyBuilder$8(luvio, params) {
+        return keyBuilder$9(luvio, {
+            assistant_target: params.urlParams.assistantTarget
+        });
+    }
+    function getResponseCacheKeys$4(luvio, resourceParams, response) {
+        return getTypeCacheKeys$3(luvio, response);
+    }
+    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$8(),
+            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$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: '/assistant-platform/' + config.urlParams.assistantTarget + '/info',
+            method: 'get',
+            body: null,
+            urlParams: config.urlParams,
+            queryParams: {},
+            headers: headers,
+            priority: 'normal',
+        };
+    }
+
+    var getAssistantTarget_ConfigPropertyNames = {
+        displayName: 'getAssistantTarget',
+        parameters: {
+            required: ['assistantTarget'],
+            optional: []
+        }
+    };
+    function createResourceParams$4(config) {
+        var resourceParams = {
+            urlParams: {
+                assistantTarget: config.assistantTarget
+            }
+        };
+        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_assistantTarget = untrustedConfig.assistantTarget;
+        if (typeof untrustedConfig_assistantTarget === 'string') {
+            config.assistantTarget = untrustedConfig_assistantTarget;
+        }
+        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$2(luvio, config) {
+        createResourceParams$4(config);
+        return select$8();
+    }
+    function onFetchResponseSuccess$2(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$2(luvio, config, resourceParams, response) {
+        var snapshot = ingestError$2(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$2(luvio, config, resourceParams, response); }, function () { return getResponseCacheKeys$4(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: undefined,
+            },
+            eventObservers: eventObservers
+        };
+        if (networkPriority !== 'normal') {
+            dispatchOptions.overrides = {
+                priority: networkPriority
+            };
+        }
+        return buildNetworkSnapshot$4(luvio, config, dispatchOptions);
+    }
+    function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
+        var luvio = context.luvio, config = context.config;
+        var selector = {
+            recordId: keyBuilder$7(luvio, config),
+            node: adapterFragment$2(luvio, config),
+            variables: {},
+        };
+        var cacheSnapshot = storeLookup(selector, {
+            config: config,
+            resolve: function () { return buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions); }
+        });
+        return cacheSnapshot;
+    }
+    var getAssistantTargetAdapterFactory = function (luvio) { return function LEAP__getAssistantTarget(untrustedConfig, requestContext) {
+        var config = validateAdapterConfig$4(untrustedConfig, getAssistantTarget_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            return null;
+        }
+        return luvio.applyCachePolicy((requestContext || {}), { config: config, luvio: luvio }, // BuildSnapshotContext
+        buildCachedSnapshotCachePolicy$2, buildNetworkSnapshotCachePolicy$2);
+    }; };
+
+    var VERSION$3 = "f2e480ff95d6a6b46f4a4b00d2d40a04";
+    function validate$4(obj, path) {
+        if (path === void 0) { path = 'LightningAssistantInitializationRepresentation'; }
+        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_assistantTarget = obj.assistantTarget;
+            var path_assistantTarget = path + '.assistantTarget';
+            if (typeof obj_assistantTarget !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_assistantTarget + '" (at "' + path_assistantTarget + '")');
+            }
+            var obj_isInitialized = obj.isInitialized;
+            var path_isInitialized = path + '.isInitialized';
+            if (typeof obj_isInitialized !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isInitialized + '" (at "' + path_isInitialized + '")');
+            }
+        })();
+        return v_error === undefined ? null : v_error;
+    }
+    var RepresentationType$2 = 'LightningAssistantInitializationRepresentation';
+    function keyBuilder$6(luvio, config) {
+        return keyPrefix + '::' + RepresentationType$2 + ':' + config.is_initialized + ':' + config.assistant_target;
+    }
+    function keyBuilderFromType$2(luvio, object) {
+        var keyParams = {
+            is_initialized: object.isInitialized,
+            assistant_target: object.assistantTarget
+        };
+        return keyBuilder$6(luvio, keyParams);
+    }
+    function normalize$2(input, existing, path, luvio, store, timestamp) {
+        return input;
+    }
+    var select$7 = function LightningAssistantInitializationRepresentationSelect() {
+        return {
+            kind: 'Fragment',
+            version: VERSION$3,
+            private: [],
+            selections: [
+                {
+                    name: 'assistantTarget',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'isInitialized',
+                    kind: 'Scalar'
+                }
+            ]
+        };
+    };
+    function equals$3(existing, incoming) {
+        var existing_isInitialized = existing.isInitialized;
+        var incoming_isInitialized = incoming.isInitialized;
+        if (!(existing_isInitialized === incoming_isInitialized)) {
+            return false;
+        }
+        var existing_assistantTarget = existing.assistantTarget;
+        var incoming_assistantTarget = incoming.assistantTarget;
+        if (!(existing_assistantTarget === incoming_assistantTarget)) {
+            return false;
+        }
+        return true;
+    }
+    var ingest$2 = function LightningAssistantInitializationRepresentationIngest(input, path, luvio, store, timestamp) {
+        if (process.env.NODE_ENV !== 'production') {
+            var validateError = validate$4(input);
+            if (validateError !== null) {
+                throw validateError;
+            }
+        }
+        var key = keyBuilderFromType$2(luvio, input);
+        var existingRecord = store.readEntry(key);
+        var ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
+        var incomingRecord = normalize$2(input, store.readEntry(key), {
+            fullPath: key,
+            parent: path.parent,
+            propertyName: path.propertyName,
+            ttl: ttlToUse
+        });
+        if (existingRecord === undefined || equals$3(existingRecord, incomingRecord) === false) {
+            luvio.storePublish(key, incomingRecord);
+        }
+        if (ttlToUse !== undefined) {
+            var storeMetadataParams = {
+                ttl: ttlToUse,
+                namespace: "LEAP",
+                version: VERSION$3,
+                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 = keyBuilderFromType$2(luvio, input);
+        rootKeySet.set(rootKey, {
+            namespace: keyPrefix,
+            representationName: RepresentationType$2,
+            mergeable: false
+        });
+        return rootKeySet;
+    }
+
+    function select$6(luvio, params) {
+        return select$7();
+    }
+    function getResponseCacheKeys$3(luvio, resourceParams, response) {
+        return getTypeCacheKeys$2(luvio, response);
+    }
+    function ingestSuccess$3(luvio, resourceParams, response) {
+        var body = response.body;
+        var key = keyBuilderFromType$2(luvio, body);
+        luvio.storeIngest(key, ingest$2, 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$3(config) {
+        var headers = {};
+        return {
+            baseUri: '/services/data/v58.0',
+            basePath: '/assistant-platform/' + config.urlParams.assistantTarget + '/initialize',
+            method: 'put',
+            body: null,
+            urlParams: config.urlParams,
+            queryParams: {},
+            headers: headers,
+            priority: 'normal',
+        };
+    }
+
+    var initialize_ConfigPropertyNames = {
+        displayName: 'initialize',
+        parameters: {
+            required: ['assistantTarget'],
+            optional: []
+        }
+    };
+    function createResourceParams$3(config) {
+        var resourceParams = {
+            urlParams: {
+                assistantTarget: config.assistantTarget
+            }
+        };
+        return resourceParams;
+    }
+    function typeCheckConfig$3(untrustedConfig) {
+        var config = {};
+        var untrustedConfig_assistantTarget = untrustedConfig.assistantTarget;
+        if (typeof untrustedConfig_assistantTarget === 'string') {
+            config.assistantTarget = untrustedConfig_assistantTarget;
+        }
+        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 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 () {
+                var snapshot = ingestSuccess$3(luvio, resourceParams, response);
+                return luvio.storeBroadcast().then(function () { return snapshot; });
+            }, function () { return getResponseCacheKeys$3(luvio, resourceParams, response.body); });
+        }, function (response) {
+            deepFreeze(response);
+            throw response;
+        });
+    }
+    var initializeAdapterFactory = function (luvio) {
+        return function initialize(untrustedConfig) {
+            var config = validateAdapterConfig$3(untrustedConfig, initialize_ConfigPropertyNames);
+            // Invalid or incomplete config
+            if (config === null) {
+                throw new Error('Invalid config for "initialize"');
+            }
+            return buildNetworkSnapshot$3(luvio, config);
+        };
+    };
+
+    var VERSION$2 = "86eec990f47f496e2991fb9e5ccf0802";
+    function validate$3(obj, path) {
+        if (path === void 0) { path = 'LightningAssistantListRepresentation'; }
+        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_assistantList = obj.assistantList;
+            var path_assistantList = path + '.assistantList';
+            if (!ArrayIsArray(obj_assistantList)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_assistantList + '" (at "' + path_assistantList + '")');
+            }
+            for (var i = 0; i < obj_assistantList.length; i++) {
+                var obj_assistantList_item = obj_assistantList[i];
+                var path_assistantList_item = path_assistantList + '[' + i + ']';
+                if (typeof obj_assistantList_item !== 'object') {
+                    return new TypeError('Expected "object" but received "' + typeof obj_assistantList_item + '" (at "' + path_assistantList_item + '")');
+                }
+            }
+            var obj_assistantTarget = obj.assistantTarget;
+            var path_assistantTarget = path + '.assistantTarget';
+            if (typeof obj_assistantTarget !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_assistantTarget + '" (at "' + path_assistantTarget + '")');
+            }
+        })();
+        return v_error === undefined ? null : v_error;
+    }
+    var RepresentationType$1 = 'LightningAssistantListRepresentation';
+    function keyBuilder$5(luvio, config) {
+        return keyPrefix + '::' + RepresentationType$1 + ':' + config.assistant_target;
+    }
+    function keyBuilderFromType$1(luvio, object) {
+        var keyParams = {
+            assistant_target: object.assistantTarget
+        };
+        return keyBuilder$5(luvio, keyParams);
+    }
+    function normalize$1(input, existing, path, luvio, store, timestamp) {
+        var input_assistantList = input.assistantList;
+        var input_assistantList_id = path.fullPath + '__assistantList';
+        for (var i = 0; i < input_assistantList.length; i++) {
+            var input_assistantList_item = input_assistantList[i];
+            var input_assistantList_item_id = input_assistantList_id + '__' + i;
+            input_assistantList[i] = ingest$5(input_assistantList_item, {
+                fullPath: input_assistantList_item_id,
+                propertyName: i,
+                parent: {
+                    data: input,
+                    key: path.fullPath,
+                    existing: existing,
+                },
+                ttl: path.ttl
+            }, luvio, store);
+        }
+        return input;
+    }
+    var select$5 = function LightningAssistantListRepresentationSelect() {
+        return {
+            kind: 'Fragment',
+            version: VERSION$2,
+            private: [],
+            selections: [
+                {
+                    name: 'assistantList',
+                    kind: 'Link',
+                    plural: true,
+                    fragment: select$f()
+                },
+                {
+                    name: 'assistantTarget',
+                    kind: 'Scalar'
+                }
+            ]
+        };
+    };
+    function equals$2(existing, incoming) {
+        var existing_assistantTarget = existing.assistantTarget;
+        var incoming_assistantTarget = incoming.assistantTarget;
+        if (!(existing_assistantTarget === incoming_assistantTarget)) {
+            return false;
+        }
+        var existing_assistantList = existing.assistantList;
+        var incoming_assistantList = incoming.assistantList;
+        var equals_assistantList_items = equalsArray(existing_assistantList, incoming_assistantList, function (existing_assistantList_item, incoming_assistantList_item) {
+            if (!(existing_assistantList_item.__ref === incoming_assistantList_item.__ref)) {
+                return false;
+            }
+        });
+        if (equals_assistantList_items === false) {
+            return false;
+        }
+        return true;
+    }
+    var ingest$1 = function LightningAssistantListRepresentationIngest(input, path, luvio, store, timestamp) {
+        if (process.env.NODE_ENV !== 'production') {
+            var validateError = validate$3(input);
+            if (validateError !== null) {
+                throw validateError;
+            }
+        }
+        var key = keyBuilderFromType$1(luvio, input);
+        var existingRecord = store.readEntry(key);
+        var ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
+        var incomingRecord = normalize$1(input, store.readEntry(key), {
+            fullPath: key,
+            parent: path.parent,
+            propertyName: path.propertyName,
+            ttl: ttlToUse
+        }, luvio, store);
+        if (existingRecord === undefined || equals$2(existingRecord, incomingRecord) === false) {
+            luvio.storePublish(key, incomingRecord);
+        }
+        if (ttlToUse !== undefined) {
+            var storeMetadataParams = {
+                ttl: ttlToUse,
+                namespace: "LEAP",
+                version: VERSION$2,
+                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$1(luvio, input);
+        rootKeySet.set(rootKey, {
+            namespace: keyPrefix,
+            representationName: RepresentationType$1,
+            mergeable: false
+        });
+        var input_assistantList_length = input.assistantList.length;
+        for (var i = 0; i < input_assistantList_length; i++) {
+            rootKeySet.merge(getTypeCacheKeys$5(luvio, input.assistantList[i]));
+        }
+        return rootKeySet;
+    }
+
+    function select$4(luvio, params) {
+        return select$5();
+    }
+    function keyBuilder$4(luvio, params) {
+        return keyBuilder$5(luvio, {
+            assistant_target: params.urlParams.assistantTarget
+        });
+    }
+    function getResponseCacheKeys$2(luvio, resourceParams, response) {
+        return getTypeCacheKeys$1(luvio, response);
+    }
+    function ingestSuccess$2(luvio, resourceParams, response, snapshotRefresh) {
+        var body = response.body;
+        var key = keyBuilder$4(luvio, resourceParams);
+        luvio.storeIngest(key, ingest$1, body);
+        var snapshot = luvio.storeLookup({
+            recordId: key,
+            node: select$4(),
+            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$4(luvio, params);
+        var errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+        luvio.storeIngestError(key, errorSnapshot);
+        return errorSnapshot;
+    }
+    function createResourceRequest$2(config) {
+        var headers = {};
+        return {
+            baseUri: '/services/data/v58.0',
+            basePath: '/assistant-platform/' + config.urlParams.assistantTarget + '/list',
+            method: 'get',
+            body: null,
+            urlParams: config.urlParams,
+            queryParams: {},
+            headers: headers,
+            priority: 'normal',
+        };
+    }
+
+    var getAssistantList_ConfigPropertyNames = {
+        displayName: 'getAssistantList',
+        parameters: {
+            required: ['assistantTarget'],
+            optional: []
+        }
+    };
+    function createResourceParams$2(config) {
+        var resourceParams = {
+            urlParams: {
+                assistantTarget: config.assistantTarget
+            }
+        };
+        return resourceParams;
+    }
+    function keyBuilder$3(luvio, config) {
+        var resourceParams = createResourceParams$2(config);
+        return keyBuilder$4(luvio, resourceParams);
+    }
+    function typeCheckConfig$2(untrustedConfig) {
+        var config = {};
+        var untrustedConfig_assistantTarget = untrustedConfig.assistantTarget;
+        if (typeof untrustedConfig_assistantTarget === 'string') {
+            config.assistantTarget = untrustedConfig_assistantTarget;
+        }
+        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 adapterFragment$1(luvio, config) {
+        createResourceParams$2(config);
+        return select$4();
+    }
+    function onFetchResponseSuccess$1(luvio, config, resourceParams, response) {
+        var snapshot = ingestSuccess$2(luvio, resourceParams, response, {
+            config: config,
+            resolve: function () { return buildNetworkSnapshot$2(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$2(luvio, config, snapshotRefreshOptions); }
+        });
+        return luvio.storeBroadcast().then(function () { return snapshot; });
+    }
+    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 () { return onFetchResponseSuccess$1(luvio, config, resourceParams, response); }, function () { return getResponseCacheKeys$2(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$2(luvio, config, dispatchOptions);
+    }
+    function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
+        var luvio = context.luvio, config = context.config;
+        var selector = {
+            recordId: keyBuilder$3(luvio, config),
+            node: adapterFragment$1(luvio, config),
+            variables: {},
+        };
+        var cacheSnapshot = storeLookup(selector, {
+            config: config,
+            resolve: function () { return buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions); }
+        });
+        return cacheSnapshot;
+    }
+    var getAssistantListAdapterFactory = function (luvio) { return function LEAP__getAssistantList(untrustedConfig, requestContext) {
+        var config = validateAdapterConfig$2(untrustedConfig, getAssistantList_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            return null;
+        }
+        return luvio.applyCachePolicy((requestContext || {}), { config: config, luvio: luvio }, // BuildSnapshotContext
+        buildCachedSnapshotCachePolicy$1, buildNetworkSnapshotCachePolicy$1);
+    }; };
+
+    function validate$2(obj, path) {
+        if (path === void 0) { path = 'LightningAssistantListInputRepresentation'; }
+        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_assistantList = obj.assistantList;
+            var path_assistantList = path + '.assistantList';
+            if (typeof obj_assistantList !== 'object' || ArrayIsArray(obj_assistantList) || obj_assistantList === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj_assistantList + '" (at "' + path_assistantList + '")');
+            }
+            var obj_assistantList_keys = ObjectKeys(obj_assistantList);
+            for (var i = 0; i < obj_assistantList_keys.length; i++) {
+                var key = obj_assistantList_keys[i];
+                var obj_assistantList_prop = obj_assistantList[key];
+                var path_assistantList_prop = path_assistantList + '["' + key + '"]';
+                if (typeof obj_assistantList_prop !== 'object' || ArrayIsArray(obj_assistantList_prop) || obj_assistantList_prop === null) {
+                    return new TypeError('Expected "object" but received "' + typeof obj_assistantList_prop + '" (at "' + path_assistantList_prop + '")');
+                }
+            }
+        })();
+        return v_error === undefined ? null : v_error;
+    }
+
+    function select$3(luvio, params) {
+        return select$5();
+    }
+    function getResponseCacheKeys$1(luvio, resourceParams, response) {
+        return getTypeCacheKeys$1(luvio, response);
+    }
+    function ingestSuccess$1(luvio, resourceParams, response) {
+        var body = response.body;
+        var key = keyBuilderFromType$1(luvio, body);
+        luvio.storeIngest(key, ingest$1, body);
+        var snapshot = luvio.storeLookup({
+            recordId: key,
+            node: select$3(),
+            variables: {},
+        });
+        if (process.env.NODE_ENV !== 'production') {
+            if (snapshot.state !== 'Fulfilled') {
+                throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+            }
+        }
+        return snapshot;
+    }
+    function createResourceRequest$1(config) {
+        var headers = {};
+        return {
+            baseUri: '/services/data/v58.0',
+            basePath: '/assistant-platform/' + config.urlParams.assistantTarget + '/list',
+            method: 'patch',
+            body: config.body,
+            urlParams: config.urlParams,
+            queryParams: {},
+            headers: headers,
+            priority: 'normal',
+        };
+    }
+
+    var saveAssistantList_ConfigPropertyNames = {
+        displayName: 'saveAssistantList',
+        parameters: {
+            required: ['assistantTarget', 'assistantData'],
+            optional: []
+        }
+    };
+    function createResourceParams$1(config) {
+        var resourceParams = {
+            urlParams: {
+                assistantTarget: config.assistantTarget
+            },
+            body: {
+                assistantData: config.assistantData
+            }
+        };
+        return resourceParams;
+    }
+    function typeCheckConfig$1(untrustedConfig) {
+        var config = {};
+        var untrustedConfig_assistantTarget = untrustedConfig.assistantTarget;
+        if (typeof untrustedConfig_assistantTarget === 'string') {
+            config.assistantTarget = untrustedConfig_assistantTarget;
+        }
+        var untrustedConfig_assistantData = untrustedConfig.assistantData;
+        var referenceLightningAssistantListInputRepresentationValidationError = validate$2(untrustedConfig_assistantData);
+        if (referenceLightningAssistantListInputRepresentationValidationError === null) {
+            config.assistantData = untrustedConfig_assistantData;
+        }
+        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(untrustedConfig);
+        if (!areRequiredParametersPresent(config, configPropertyNames)) {
+            return null;
+        }
+        return config;
+    }
+    function buildNetworkSnapshot$1(luvio, config, options) {
+        var resourceParams = createResourceParams$1(config);
+        var request = createResourceRequest$1(resourceParams);
+        return luvio.dispatchResourceRequest(request, options)
+            .then(function (response) {
+            return luvio.handleSuccessResponse(function () {
+                var snapshot = ingestSuccess$1(luvio, resourceParams, response);
+                return luvio.storeBroadcast().then(function () { return snapshot; });
+            }, function () { return getResponseCacheKeys$1(luvio, resourceParams, response.body); });
+        }, function (response) {
+            deepFreeze(response);
+            throw response;
+        });
+    }
+    var saveAssistantListAdapterFactory = function (luvio) {
+        return function saveAssistantList(untrustedConfig) {
+            var config = validateAdapterConfig$1(untrustedConfig, saveAssistantList_ConfigPropertyNames);
+            // Invalid or incomplete config
+            if (config === null) {
+                throw new Error('Invalid config for "saveAssistantList"');
+            }
+            return buildNetworkSnapshot$1(luvio, config);
+        };
+    };
+
+    var VERSION$1 = "60c238eb770e68fa40b048eee3d01775";
+    function validate$1(obj, path) {
+        if (path === void 0) { path = 'LightningAssistantInfoRepresentation'; }
+        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_assistantTarget = obj.assistantTarget;
+            var path_assistantTarget = path + '.assistantTarget';
+            if (typeof obj_assistantTarget !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_assistantTarget + '" (at "' + path_assistantTarget + '")');
+            }
+            if (obj.category !== undefined) {
+                var obj_category = obj.category;
+                var path_category = path + '.category';
+                if (typeof obj_category !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_category + '" (at "' + path_category + '")');
+                }
+            }
+            if (obj.categoryName !== undefined) {
+                var obj_categoryName = obj.categoryName;
+                var path_categoryName = path + '.categoryName';
+                if (typeof obj_categoryName !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_categoryName + '" (at "' + path_categoryName + '")');
+                }
+            }
+            var obj_contentVersion = obj.contentVersion;
+            var path_contentVersion = path + '.contentVersion';
+            if (typeof obj_contentVersion !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_contentVersion + '" (at "' + path_contentVersion + '")');
+            }
+            var obj_debugModeEnabled = obj.debugModeEnabled;
+            var path_debugModeEnabled = path + '.debugModeEnabled';
+            if (typeof obj_debugModeEnabled !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_debugModeEnabled + '" (at "' + path_debugModeEnabled + '")');
+            }
+            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_developerName = obj.developerName;
+            var path_developerName = path + '.developerName';
+            if (typeof obj_developerName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_developerName + '" (at "' + path_developerName + '")');
+            }
+            var obj_icon = obj.icon;
+            var path_icon = path + '.icon';
+            if (typeof obj_icon !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_icon + '" (at "' + path_icon + '")');
+            }
+            var obj_isPreview = obj.isPreview;
+            var path_isPreview = path + '.isPreview';
+            if (typeof obj_isPreview !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isPreview + '" (at "' + path_isPreview + '")');
+            }
+            var obj_title = obj.title;
+            var path_title = path + '.title';
+            if (typeof obj_title !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_title + '" (at "' + path_title + '")');
+            }
+        })();
+        return v_error === undefined ? null : v_error;
+    }
+    var select$2 = function LightningAssistantInfoRepresentationSelect() {
+        return {
+            kind: 'Fragment',
+            version: VERSION$1,
+            private: [],
+            selections: [
+                {
+                    name: 'assistantTarget',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'category',
+                    kind: 'Scalar',
+                    required: false
+                },
+                {
+                    name: 'categoryName',
+                    kind: 'Scalar',
+                    required: false
+                },
+                {
+                    name: 'contentVersion',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'debugModeEnabled',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'description',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'developerName',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'icon',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'isPreview',
+                    kind: 'Scalar'
+                },
+                {
+                    name: 'title',
+                    kind: 'Scalar'
+                }
+            ]
+        };
+    };
+    function equals$1(existing, incoming) {
+        var existing_debugModeEnabled = existing.debugModeEnabled;
+        var incoming_debugModeEnabled = incoming.debugModeEnabled;
+        if (!(existing_debugModeEnabled === incoming_debugModeEnabled)) {
+            return false;
+        }
+        var existing_isPreview = existing.isPreview;
+        var incoming_isPreview = incoming.isPreview;
+        if (!(existing_isPreview === incoming_isPreview)) {
+            return false;
+        }
+        var existing_assistantTarget = existing.assistantTarget;
+        var incoming_assistantTarget = incoming.assistantTarget;
+        if (!(existing_assistantTarget === incoming_assistantTarget)) {
+            return false;
+        }
+        var existing_category = existing.category;
+        var incoming_category = incoming.category;
+        // if at least one of these optionals is defined
+        if (existing_category !== undefined || incoming_category !== undefined) {
+            // if one of these is not defined we know the other is defined and therefore
+            // not equal
+            if (existing_category === undefined || incoming_category === undefined) {
+                return false;
+            }
+            if (!(existing_category === incoming_category)) {
+                return false;
+            }
+        }
+        var existing_categoryName = existing.categoryName;
+        var incoming_categoryName = incoming.categoryName;
+        // if at least one of these optionals is defined
+        if (existing_categoryName !== undefined || incoming_categoryName !== undefined) {
+            // if one of these is not defined we know the other is defined and therefore
+            // not equal
+            if (existing_categoryName === undefined || incoming_categoryName === undefined) {
+                return false;
+            }
+            if (!(existing_categoryName === incoming_categoryName)) {
+                return false;
+            }
+        }
+        var existing_contentVersion = existing.contentVersion;
+        var incoming_contentVersion = incoming.contentVersion;
+        if (!(existing_contentVersion === incoming_contentVersion)) {
+            return false;
+        }
+        var existing_description = existing.description;
+        var incoming_description = incoming.description;
+        if (!(existing_description === incoming_description)) {
+            return false;
+        }
+        var existing_developerName = existing.developerName;
+        var incoming_developerName = incoming.developerName;
+        if (!(existing_developerName === incoming_developerName)) {
+            return false;
+        }
+        var existing_icon = existing.icon;
+        var incoming_icon = incoming.icon;
+        if (!(existing_icon === incoming_icon)) {
+            return false;
+        }
+        var existing_title = existing.title;
+        var incoming_title = incoming.title;
+        if (!(existing_title === incoming_title)) {
+            return false;
+        }
+        return true;
+    }
+
+    var VERSION = "d3f2957d23e995fb380f62e85e1d26ea";
+    function validate(obj, path) {
+        if (path === void 0) { path = 'LightningAssistantInfoListRepresentation'; }
+        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_assistantInfoList = obj.assistantInfoList;
+            var path_assistantInfoList = path + '.assistantInfoList';
+            if (!ArrayIsArray(obj_assistantInfoList)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_assistantInfoList + '" (at "' + path_assistantInfoList + '")');
+            }
+            for (var i = 0; i < obj_assistantInfoList.length; i++) {
+                var obj_assistantInfoList_item = obj_assistantInfoList[i];
+                var path_assistantInfoList_item = path_assistantInfoList + '[' + i + ']';
+                var referencepath_assistantInfoList_itemValidationError = validate$1(obj_assistantInfoList_item, path_assistantInfoList_item);
+                if (referencepath_assistantInfoList_itemValidationError !== null) {
+                    var message = 'Object doesn\'t match LightningAssistantInfoRepresentation (at "' + path_assistantInfoList_item + '")\n';
+                    message += referencepath_assistantInfoList_itemValidationError.message.split('\n').map(function (line) { return '\t' + line; }).join('\n');
+                    return new TypeError(message);
+                }
+            }
+            var obj_assistantTarget = obj.assistantTarget;
+            var path_assistantTarget = path + '.assistantTarget';
+            if (typeof obj_assistantTarget !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_assistantTarget + '" (at "' + path_assistantTarget + '")');
+            }
+        })();
+        return v_error === undefined ? null : v_error;
+    }
+    var RepresentationType = 'LightningAssistantInfoListRepresentation';
+    function keyBuilder$2(luvio, config) {
+        return keyPrefix + '::' + RepresentationType + ':' + config.assistant_target;
+    }
+    function keyBuilderFromType(luvio, object) {
+        var keyParams = {
+            assistant_target: object.assistantTarget
+        };
+        return keyBuilder$2(luvio, keyParams);
+    }
+    function normalize(input, existing, path, luvio, store, timestamp) {
+        return input;
+    }
+    var select$1 = function LightningAssistantInfoListRepresentationSelect() {
+        var _a = select$2(), LightningAssistantInfoRepresentation__selections = _a.selections;
+        return {
+            kind: 'Fragment',
+            version: VERSION,
+            private: [],
+            selections: [
+                {
+                    name: 'assistantInfoList',
+                    kind: 'Object',
+                    plural: true,
+                    selections: LightningAssistantInfoRepresentation__selections
+                },
+                {
+                    name: 'assistantTarget',
+                    kind: 'Scalar'
+                }
+            ]
+        };
+    };
+    function equals(existing, incoming) {
+        var existing_assistantTarget = existing.assistantTarget;
+        var incoming_assistantTarget = incoming.assistantTarget;
+        if (!(existing_assistantTarget === incoming_assistantTarget)) {
+            return false;
+        }
+        var existing_assistantInfoList = existing.assistantInfoList;
+        var incoming_assistantInfoList = incoming.assistantInfoList;
+        var equals_assistantInfoList_items = equalsArray(existing_assistantInfoList, incoming_assistantInfoList, function (existing_assistantInfoList_item, incoming_assistantInfoList_item) {
+            if (!(equals$1(existing_assistantInfoList_item, incoming_assistantInfoList_item))) {
+                return false;
+            }
+        });
+        if (equals_assistantInfoList_items === false) {
+            return false;
+        }
+        return true;
+    }
+    var ingest = function LightningAssistantInfoListRepresentationIngest(input, path, luvio, store, timestamp) {
+        if (process.env.NODE_ENV !== 'production') {
+            var validateError = validate(input);
+            if (validateError !== null) {
+                throw validateError;
+            }
+        }
+        var key = keyBuilderFromType(luvio, input);
+        var existingRecord = store.readEntry(key);
+        var ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
+        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: "LEAP",
+                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 = keyBuilderFromType(luvio, input);
+        rootKeySet.set(rootKey, {
+            namespace: keyPrefix,
+            representationName: RepresentationType,
+            mergeable: false
+        });
+        return rootKeySet;
+    }
+
+    function select(luvio, params) {
+        return select$1();
+    }
+    function keyBuilder$1(luvio, params) {
+        return keyBuilder$2(luvio, {
+            assistant_target: params.urlParams.assistantTarget
+        });
+    }
+    function getResponseCacheKeys(luvio, resourceParams, response) {
+        return getTypeCacheKeys(luvio, response);
+    }
+    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: '/assistant-platform/' + config.urlParams.assistantTarget + '/list/info',
+            method: 'get',
+            body: null,
+            urlParams: config.urlParams,
+            queryParams: {},
+            headers: headers,
+            priority: 'normal',
+        };
+    }
+
+    var getAssistantInfoList_ConfigPropertyNames = {
+        displayName: 'getAssistantInfoList',
+        parameters: {
+            required: ['assistantTarget'],
+            optional: []
+        }
+    };
+    function createResourceParams(config) {
+        var resourceParams = {
+            urlParams: {
+                assistantTarget: config.assistantTarget
+            }
+        };
+        return resourceParams;
+    }
+    function keyBuilder(luvio, config) {
+        var resourceParams = createResourceParams(config);
+        return keyBuilder$1(luvio, resourceParams);
+    }
+    function typeCheckConfig(untrustedConfig) {
+        var config = {};
+        var untrustedConfig_assistantTarget = untrustedConfig.assistantTarget;
+        if (typeof untrustedConfig_assistantTarget === 'string') {
+            config.assistantTarget = untrustedConfig_assistantTarget;
+        }
+        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 getAssistantInfoListAdapterFactory = function (luvio) { return function LEAP__getAssistantInfoList(untrustedConfig, requestContext) {
+        var config = validateAdapterConfig(untrustedConfig, getAssistantInfoList_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            return null;
+        }
+        return luvio.applyCachePolicy((requestContext || {}), { config: config, luvio: luvio }, // BuildSnapshotContext
+        buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
+    }; };
+
+    exports.evaluateStepAdapterFactory = evaluateStepAdapterFactory;
+    exports.getAssistantAdapterFactory = getAssistantAdapterFactory;
+    exports.getAssistantInfoListAdapterFactory = getAssistantInfoListAdapterFactory;
+    exports.getAssistantListAdapterFactory = getAssistantListAdapterFactory;
+    exports.getAssistantTargetAdapterFactory = getAssistantTargetAdapterFactory;
+    exports.getQuestionnaireAdapterFactory = getQuestionnaireAdapterFactory;
+    exports.getQuestionnairesAdapterFactory = getQuestionnairesAdapterFactory;
+    exports.initializeAdapterFactory = initializeAdapterFactory;
+    exports.saveAssistantAdapterFactory = saveAssistantAdapterFactory;
+    exports.saveAssistantListAdapterFactory = saveAssistantListAdapterFactory;
+    exports.saveQuestionnaireAdapterFactory = saveQuestionnaireAdapterFactory;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));