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

package/dist/es/es2018/platform-admin-success-guidance.js

@@ -0,0 +1,4189 @@
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+import { serializeStructuredKey, StoreKeyMap } from '@luvio/engine';
+
+const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
+const { keys: ObjectKeys$1, freeze: ObjectFreeze$1, create: ObjectCreate$1 } = Object;
+const { isArray: ArrayIsArray$1 } = Array;
+/**
+ * Validates an adapter config is well-formed.
+ * @param config The config to validate.
+ * @param adapter The adapter validation configuration.
+ * @param oneOf The keys the config must contain at least one of.
+ * @throws A TypeError if config doesn't satisfy the adapter's config validation.
+ */
+function validateConfig(config, adapter, oneOf) {
+    const { displayName } = adapter;
+    const { required, optional, unsupported } = adapter.parameters;
+    if (config === undefined ||
+        required.every(req => ObjectPrototypeHasOwnProperty.call(config, req)) === false) {
+        throw new TypeError(`adapter ${displayName} configuration must specify ${required.sort().join(', ')}`);
+    }
+    if (oneOf && oneOf.some(req => ObjectPrototypeHasOwnProperty.call(config, req)) === false) {
+        throw new TypeError(`adapter ${displayName} configuration must specify one of ${oneOf.sort().join(', ')}`);
+    }
+    if (unsupported !== undefined &&
+        unsupported.some(req => ObjectPrototypeHasOwnProperty.call(config, req))) {
+        throw new TypeError(`adapter ${displayName} does not yet support ${unsupported.sort().join(', ')}`);
+    }
+    const supported = required.concat(optional);
+    if (ObjectKeys$1(config).some(key => !supported.includes(key))) {
+        throw new TypeError(`adapter ${displayName} configuration supports only ${supported.sort().join(', ')}`);
+    }
+}
+function untrustedIsObject(untrusted) {
+    return typeof untrusted === 'object' && untrusted !== null && ArrayIsArray$1(untrusted) === false;
+}
+function areRequiredParametersPresent(config, configPropertyNames) {
+    return configPropertyNames.parameters.required.every(req => req in config);
+}
+const snapshotRefreshOptions = {
+    overrides: {
+        headers: {
+            'Cache-Control': 'no-cache',
+        },
+    }
+};
+const keyPrefix = 'LEAP';
+
+const { freeze: ObjectFreeze, keys: ObjectKeys, create: ObjectCreate, assign: ObjectAssign } = Object;
+const { isArray: ArrayIsArray } = Array;
+const { stringify: JSONStringify } = JSON;
+function equalsArray(a, b, equalsItem) {
+    const aLength = a.length;
+    const bLength = b.length;
+    if (aLength !== bLength) {
+        return false;
+    }
+    for (let i = 0; i < aLength; i++) {
+        if (equalsItem(a[i], b[i]) === false) {
+            return false;
+        }
+    }
+    return true;
+}
+function deepFreeze(value) {
+    // No need to freeze primitives
+    if (typeof value !== 'object' || value === null) {
+        return;
+    }
+    if (ArrayIsArray(value)) {
+        for (let i = 0, len = value.length; i < len; i += 1) {
+            deepFreeze(value[i]);
+        }
+    }
+    else {
+        const keys = ObjectKeys(value);
+        for (let i = 0, len = keys.length; i < len; i += 1) {
+            deepFreeze(value[keys[i]]);
+        }
+    }
+    ObjectFreeze(value);
+}
+function createLink(ref) {
+    return {
+        __ref: serializeStructuredKey(ref),
+    };
+}
+
+const VERSION$l = "fec1ea773d37039808d8d9e4e4d7c085";
+function validate$h(obj, path = 'LightningAssistantChoiceRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.description !== undefined) {
+            const obj_description = obj.description;
+            const path_description = path + '.description';
+            if (typeof obj_description !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_description + '" (at "' + path_description + '")');
+            }
+        }
+        const obj_developerName = obj.developerName;
+        const path_developerName = path + '.developerName';
+        if (typeof obj_developerName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_developerName + '" (at "' + path_developerName + '")');
+        }
+        const obj_next = obj.next;
+        const path_next = path + '.next';
+        if (typeof obj_next !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_next + '" (at "' + path_next + '")');
+        }
+        const obj_title = obj.title;
+        const 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;
+}
+const 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) {
+    const existing_description = existing.description;
+    const 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;
+        }
+    }
+    const existing_developerName = existing.developerName;
+    const incoming_developerName = incoming.developerName;
+    if (!(existing_developerName === incoming_developerName)) {
+        return false;
+    }
+    const existing_next = existing.next;
+    const incoming_next = incoming.next;
+    if (!(existing_next === incoming_next)) {
+        return false;
+    }
+    const existing_title = existing.title;
+    const incoming_title = incoming.title;
+    if (!(existing_title === incoming_title)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$k = "545ec40aff7b3db184e84760ae732370";
+function validate$g(obj, path = 'LightningAssistantLinkRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_label = obj.label;
+        const path_label = path + '.label';
+        if (typeof obj_label !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_label + '" (at "' + path_label + '")');
+        }
+        const obj_url = obj.url;
+        const 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;
+}
+const 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) {
+    const existing_label = existing.label;
+    const incoming_label = incoming.label;
+    if (!(existing_label === incoming_label)) {
+        return false;
+    }
+    const existing_url = existing.url;
+    const incoming_url = incoming.url;
+    if (!(existing_url === incoming_url)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$j = "33d491734169be0180f670c757b53a34";
+function validate$f(obj, path = 'LightningAssistantQuestionRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_choices = obj.choices;
+        const path_choices = path + '.choices';
+        if (!ArrayIsArray(obj_choices)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_choices + '" (at "' + path_choices + '")');
+        }
+        for (let i = 0; i < obj_choices.length; i++) {
+            const obj_choices_item = obj_choices[i];
+            const path_choices_item = path_choices + '[' + i + ']';
+            const referencepath_choices_itemValidationError = validate$h(obj_choices_item, path_choices_item);
+            if (referencepath_choices_itemValidationError !== null) {
+                let message = 'Object doesn\'t match LightningAssistantChoiceRepresentation (at "' + path_choices_item + '")\n';
+                message += referencepath_choices_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.description !== undefined) {
+            const obj_description = obj.description;
+            const path_description = path + '.description';
+            if (typeof obj_description !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_description + '" (at "' + path_description + '")');
+            }
+        }
+        const obj_developerName = obj.developerName;
+        const 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) {
+            const obj_link = obj.link;
+            const path_link = path + '.link';
+            let obj_link_union0 = null;
+            const obj_link_union0_error = (() => {
+                const referencepath_linkValidationError = validate$g(obj_link, path_link);
+                if (referencepath_linkValidationError !== null) {
+                    let message = 'Object doesn\'t match LightningAssistantLinkRepresentation (at "' + path_link + '")\n';
+                    message += referencepath_linkValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            })();
+            if (obj_link_union0_error != null) {
+                obj_link_union0 = obj_link_union0_error.message;
+            }
+            let obj_link_union1 = null;
+            const obj_link_union1_error = (() => {
+                if (obj_link !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_link + '" (at "' + path_link + '")');
+                }
+            })();
+            if (obj_link_union1_error != null) {
+                obj_link_union1 = obj_link_union1_error.message;
+            }
+            if (obj_link_union0 && obj_link_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_link + '")';
+                message += '\n' + obj_link_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_link_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_title = obj.title;
+        const 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;
+}
+const select$u = function LightningAssistantQuestionRepresentationSelect() {
+    const { selections: LightningAssistantChoiceRepresentation__selections, opaque: LightningAssistantChoiceRepresentation__opaque, } = select$w();
+    const { selections: LightningAssistantLinkRepresentation__selections, opaque: LightningAssistantLinkRepresentation__opaque, } = select$v();
+    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) {
+    const existing_description = existing.description;
+    const 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;
+        }
+    }
+    const existing_developerName = existing.developerName;
+    const incoming_developerName = incoming.developerName;
+    if (!(existing_developerName === incoming_developerName)) {
+        return false;
+    }
+    const existing_title = existing.title;
+    const incoming_title = incoming.title;
+    if (!(existing_title === incoming_title)) {
+        return false;
+    }
+    const existing_choices = existing.choices;
+    const incoming_choices = incoming.choices;
+    const equals_choices_items = equalsArray(existing_choices, incoming_choices, (existing_choices_item, incoming_choices_item) => {
+        if (!(equals$e(existing_choices_item, incoming_choices_item))) {
+            return false;
+        }
+    });
+    if (equals_choices_items === false) {
+        return false;
+    }
+    const existing_link = existing.link;
+    const 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;
+}
+
+const VERSION$i = "defc7152bc133ff8e890226cd2092bf0";
+function validate$e(obj, path = 'LightningAssistantQuestionnaireRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_assistantTarget = obj.assistantTarget;
+        const 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) {
+            const obj_description = obj.description;
+            const path_description = path + '.description';
+            if (typeof obj_description !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_description + '" (at "' + path_description + '")');
+            }
+        }
+        const obj_developerName = obj.developerName;
+        const path_developerName = path + '.developerName';
+        if (typeof obj_developerName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_developerName + '" (at "' + path_developerName + '")');
+        }
+        const obj_questions = obj.questions;
+        const path_questions = path + '.questions';
+        if (!ArrayIsArray(obj_questions)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_questions + '" (at "' + path_questions + '")');
+        }
+        for (let i = 0; i < obj_questions.length; i++) {
+            const obj_questions_item = obj_questions[i];
+            const path_questions_item = path_questions + '[' + i + ']';
+            const referencepath_questions_itemValidationError = validate$f(obj_questions_item, path_questions_item);
+            if (referencepath_questions_itemValidationError !== null) {
+                let message = 'Object doesn\'t match LightningAssistantQuestionRepresentation (at "' + path_questions_item + '")\n';
+                message += referencepath_questions_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_status = obj.status;
+        const path_status = path + '.status';
+        if (typeof obj_status !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_status + '" (at "' + path_status + '")');
+        }
+        const obj_title = obj.title;
+        const 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;
+}
+const RepresentationType$8 = 'LightningAssistantQuestionnaireRepresentation';
+function keyBuilder$j(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$8 + ':' + config.questionnaire_name;
+}
+function keyBuilderFromType$7(luvio, object) {
+    const keyParams = {
+        questionnaire_name: object.developerName
+    };
+    return keyBuilder$j(luvio, keyParams);
+}
+function normalize$8(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$t = function LightningAssistantQuestionnaireRepresentationSelect() {
+    const { selections: LightningAssistantQuestionRepresentation__selections, opaque: LightningAssistantQuestionRepresentation__opaque, } = select$u();
+    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) {
+    const existing_assistantTarget = existing.assistantTarget;
+    const incoming_assistantTarget = incoming.assistantTarget;
+    if (!(existing_assistantTarget === incoming_assistantTarget)) {
+        return false;
+    }
+    const existing_description = existing.description;
+    const 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;
+        }
+    }
+    const existing_developerName = existing.developerName;
+    const incoming_developerName = incoming.developerName;
+    if (!(existing_developerName === incoming_developerName)) {
+        return false;
+    }
+    const existing_status = existing.status;
+    const incoming_status = incoming.status;
+    if (!(existing_status === incoming_status)) {
+        return false;
+    }
+    const existing_title = existing.title;
+    const incoming_title = incoming.title;
+    if (!(existing_title === incoming_title)) {
+        return false;
+    }
+    const existing_questions = existing.questions;
+    const incoming_questions = incoming.questions;
+    const equals_questions_items = equalsArray(existing_questions, incoming_questions, (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;
+}
+const ingest$8 = function LightningAssistantQuestionnaireRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$e(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$7(luvio, input);
+    const existingRecord = store.readEntry(key);
+    const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
+    let 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) {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "LEAP",
+            version: VERSION$i,
+            representationName: RepresentationType$8,
+        };
+        luvio.publishStoreMetadata(key, storeMetadataParams);
+    }
+    return createLink(key);
+};
+function getTypeCacheKeys$8(luvio, input, fullPathFactory) {
+    const rootKeySet = new StoreKeyMap();
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const 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) {
+    const { body } = response;
+    const key = keyBuilder$i(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$8, body);
+    const 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) {
+    const key = keyBuilder$i(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    luvio.storeIngestError(key, errorSnapshot);
+    return errorSnapshot;
+}
+function createResourceRequest$a(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/assistant-platform/questionnaire/' + config.urlParams.questionnaireName + '',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const getQuestionnaire_ConfigPropertyNames = {
+    displayName: 'getQuestionnaire',
+    parameters: {
+        required: ['questionnaireName'],
+        optional: []
+    }
+};
+function createResourceParams$a(config) {
+    const resourceParams = {
+        urlParams: {
+            questionnaireName: config.questionnaireName
+        }
+    };
+    return resourceParams;
+}
+function keyBuilder$h(luvio, config) {
+    const resourceParams = createResourceParams$a(config);
+    return keyBuilder$i(luvio, resourceParams);
+}
+function typeCheckConfig$a(untrustedConfig) {
+    const config = {};
+    const 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);
+    }
+    const 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) {
+    const snapshot = ingestSuccess$a(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError$5(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$5(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$a(luvio, config, options) {
+    const resourceParams = createResourceParams$a(config);
+    const request = createResourceRequest$a(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$5(luvio, config, resourceParams, response), () => getResponseCacheKeys$a(luvio, resourceParams, response.body));
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$5(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext) {
+    const { luvio, config } = context;
+    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
+    const dispatchOptions = {
+        resourceRequestContext: {
+            requestCorrelator,
+            luvioRequestMethod: undefined,
+        },
+        eventObservers
+    };
+    if (networkPriority !== 'normal') {
+        dispatchOptions.overrides = {
+            priority: networkPriority
+        };
+    }
+    return buildNetworkSnapshot$a(luvio, config, dispatchOptions);
+}
+function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$h(luvio, config),
+        node: adapterFragment$5(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getQuestionnaireAdapterFactory = (luvio) => function LEAP__getQuestionnaire(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$a(untrustedConfig, getQuestionnaire_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$5, buildNetworkSnapshotCachePolicy$5);
+};
+
+function validate$d(obj, path = 'LightningAssistantQuestionnaireInputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_questionToAnswer = obj.questionToAnswer;
+        const 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 + '")');
+        }
+        const obj_questionToAnswer_keys = ObjectKeys(obj_questionToAnswer);
+        for (let i = 0; i < obj_questionToAnswer_keys.length; i++) {
+            const key = obj_questionToAnswer_keys[i];
+            const obj_questionToAnswer_prop = obj_questionToAnswer[key];
+            const 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 + '")');
+            }
+        }
+        const obj_status = obj.status;
+        const path_status = path + '.status';
+        if (typeof obj_status !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_status + '" (at "' + path_status + '")');
+        }
+    })();
+    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) {
+    const { body } = response;
+    const key = keyBuilderFromType$7(luvio, body);
+    luvio.storeIngest(key, ingest$8, body);
+    const 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) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/assistant-platform/questionnaire/' + config.urlParams.questionnaireName + '',
+        method: 'patch',
+        body: config.body,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const saveQuestionnaire_ConfigPropertyNames = {
+    displayName: 'saveQuestionnaire',
+    parameters: {
+        required: ['questionnaireName', 'questionnaireData'],
+        optional: []
+    }
+};
+function createResourceParams$9(config) {
+    const resourceParams = {
+        urlParams: {
+            questionnaireName: config.questionnaireName
+        },
+        body: {
+            questionnaireData: config.questionnaireData
+        }
+    };
+    return resourceParams;
+}
+function typeCheckConfig$9(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_questionnaireName = untrustedConfig.questionnaireName;
+    if (typeof untrustedConfig_questionnaireName === 'string') {
+        config.questionnaireName = untrustedConfig_questionnaireName;
+    }
+    const untrustedConfig_questionnaireData = untrustedConfig.questionnaireData;
+    const 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);
+    }
+    const config = typeCheckConfig$9(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$9(luvio, config, options) {
+    const resourceParams = createResourceParams$9(config);
+    const request = createResourceRequest$9(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$9(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => getResponseCacheKeys$9(luvio, resourceParams, response.body));
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const saveQuestionnaireAdapterFactory = (luvio) => {
+    return function saveQuestionnaire(untrustedConfig) {
+        const 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);
+    };
+};
+
+const VERSION$h = "a9a46e0cf983e314934e0703d28f75bf";
+const select$q = function LightningAssistantLinkActionRepresentationSelect() {
+    const { selections: AbstractLightningAssistantActionRepresentationSelections } = select$j();
+    return {
+        kind: 'Fragment',
+        version: VERSION$h,
+        private: [],
+        selections: [
+            ...AbstractLightningAssistantActionRepresentationSelections,
+            {
+                name: 'iconName',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'label',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'url',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+
+const VERSION$g = "c2fb7ece6f9eba9ca7b25608a670310a";
+const select$p = function LightningAssistantCustomActionRepresentationSelect() {
+    const { selections: AbstractLightningAssistantActionRepresentationSelections } = select$j();
+    return {
+        kind: 'Fragment',
+        version: VERSION$g,
+        private: [],
+        selections: [
+            ...AbstractLightningAssistantActionRepresentationSelections,
+            {
+                name: 'actionComponent',
+                kind: 'Scalar'
+            },
+            {
+                name: 'customData',
+                kind: 'Scalar',
+                map: true
+            },
+            {
+                name: 'iconName',
+                kind: 'Scalar',
+                required: false
+            }
+        ]
+    };
+};
+
+const VERSION$f = "376fdaae939e8f46021d153816e03c56";
+const select$o = function LightningAssistantNoActionRepresentationSelect() {
+    const { selections: AbstractLightningAssistantActionRepresentationSelections } = select$j();
+    return {
+        kind: 'Fragment',
+        version: VERSION$f,
+        private: [],
+        selections: [
+            ...AbstractLightningAssistantActionRepresentationSelections,
+        ]
+    };
+};
+
+const VERSION$e = "2e0cc24f5c0ab2bbf7b6dade0eecb17e";
+const select$n = function LightningAssistantLsfActionRepresentationSelect() {
+    const { selections: AbstractLightningAssistantActionRepresentationSelections } = select$j();
+    return {
+        kind: 'Fragment',
+        version: VERSION$e,
+        private: [],
+        selections: [
+            ...AbstractLightningAssistantActionRepresentationSelections,
+            {
+                name: 'customData',
+                kind: 'Scalar',
+                map: true,
+                required: false
+            },
+            {
+                name: 'iconName',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'label',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'lsf',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+
+const VERSION$d = "d7605ace66fce89a8ae0436b797d125d";
+const select$m = function LightningAssistantVideoActionRepresentationSelect() {
+    const { selections: AbstractLightningAssistantActionRepresentationSelections } = select$j();
+    return {
+        kind: 'Fragment',
+        version: VERSION$d,
+        private: [],
+        selections: [
+            ...AbstractLightningAssistantActionRepresentationSelections,
+            {
+                name: 'iconName',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'url',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+
+const VERSION$c = "fe9b2afa38e1fc9af6abd29c7fd3e307";
+const select$l = function LightningAssistantWalkthroughActionRepresentationSelect() {
+    const { selections: AbstractLightningAssistantActionRepresentationSelections } = select$j();
+    return {
+        kind: 'Fragment',
+        version: VERSION$c,
+        private: [],
+        selections: [
+            ...AbstractLightningAssistantActionRepresentationSelections,
+            {
+                name: 'iconName',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'promptId',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+
+const VERSION$b = "2abd7cd970bb200649e8944e43b72de5";
+const select$k = function LightningAssistantTrailheadActionRepresentationSelect() {
+    const { selections: AbstractLightningAssistantActionRepresentationSelections } = select$j();
+    return {
+        kind: 'Fragment',
+        version: VERSION$b,
+        private: [],
+        selections: [
+            ...AbstractLightningAssistantActionRepresentationSelections,
+            {
+                name: 'iconName',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'moduleId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'url',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+
+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 = {}));
+const VERSION$a = "ee8eb1dcdc27527e958bea3bc608ab0c";
+function validate$c(obj, path = 'AbstractLightningAssistantActionRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_actionType = obj.actionType;
+        const 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;
+}
+const selectChildren = function AbstractLightningAssistantActionRepresentationSelectChildren() {
+    const lightningAssistantLinkActionRepresentationSelections = select$q();
+    const lightningAssistantCustomActionRepresentationSelections = select$p();
+    const lightningAssistantNoActionRepresentationSelections = select$o();
+    const lightningAssistantLsfActionRepresentationSelections = select$n();
+    const lightningAssistantVideoActionRepresentationSelections = select$m();
+    const lightningAssistantWalkthroughActionRepresentationSelections = select$l();
+    const lightningAssistantTrailheadActionRepresentationSelections = select$k();
+    return {
+        kind: 'Fragment',
+        union: true,
+        discriminator: 'actionType',
+        unionSelections: {
+            [DiscriminatorValues.Link]: lightningAssistantLinkActionRepresentationSelections,
+            [DiscriminatorValues.Custom]: lightningAssistantCustomActionRepresentationSelections,
+            [DiscriminatorValues.NoAction]: lightningAssistantNoActionRepresentationSelections,
+            [DiscriminatorValues.Lsf]: lightningAssistantLsfActionRepresentationSelections,
+            [DiscriminatorValues.Video]: lightningAssistantVideoActionRepresentationSelections,
+            [DiscriminatorValues.Walkthrough]: lightningAssistantWalkthroughActionRepresentationSelections,
+            [DiscriminatorValues.TlxModule]: lightningAssistantTrailheadActionRepresentationSelections
+        }
+    };
+};
+const select$j = function AbstractLightningAssistantActionRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$a,
+        private: [],
+        selections: [
+            {
+                name: 'actionType',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$a(existing, incoming) {
+    const existing_actionType = existing.actionType;
+    const incoming_actionType = incoming.actionType;
+    if (!(existing_actionType === incoming_actionType)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$9 = "28b96e40cf73e94d0650007d61c3214a";
+function validate$b(obj, path = 'LightningAssistantStepRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_action = obj.action;
+        const path_action = path + '.action';
+        const referencepath_actionValidationError = validate$c(obj_action, path_action);
+        if (referencepath_actionValidationError !== null) {
+            let message = 'Object doesn\'t match AbstractLightningAssistantActionRepresentation (at "' + path_action + '")\n';
+            message += referencepath_actionValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        if (obj.description !== undefined) {
+            const obj_description = obj.description;
+            const 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) {
+            const obj_figureComponent = obj.figureComponent;
+            const 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) {
+            const obj_firstSeenTime = obj.firstSeenTime;
+            const path_firstSeenTime = path + '.firstSeenTime';
+            if (typeof obj_firstSeenTime !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_firstSeenTime + '" (at "' + path_firstSeenTime + '")');
+            }
+        }
+        const obj_id = obj.id;
+        const path_id = path + '.id';
+        if (typeof obj_id !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_id + '" (at "' + path_id + '")');
+        }
+        const obj_isManaged = obj.isManaged;
+        const path_isManaged = path + '.isManaged';
+        if (typeof obj_isManaged !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_isManaged + '" (at "' + path_isManaged + '")');
+        }
+        const obj_status = obj.status;
+        const path_status = path + '.status';
+        if (typeof obj_status !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_status + '" (at "' + path_status + '")');
+        }
+        if (obj.stepComponent !== undefined) {
+            const obj_stepComponent = obj.stepComponent;
+            const path_stepComponent = path + '.stepComponent';
+            if (typeof obj_stepComponent !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_stepComponent + '" (at "' + path_stepComponent + '")');
+            }
+        }
+        const obj_tags = obj.tags;
+        const path_tags = path + '.tags';
+        if (!ArrayIsArray(obj_tags)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_tags + '" (at "' + path_tags + '")');
+        }
+        for (let i = 0; i < obj_tags.length; i++) {
+            const obj_tags_item = obj_tags[i];
+            const 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 + '")');
+            }
+        }
+        const obj_title = obj.title;
+        const path_title = path + '.title';
+        if (typeof obj_title !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_title + '" (at "' + path_title + '")');
+        }
+        const obj_updateStrategy = obj.updateStrategy;
+        const 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;
+}
+const RepresentationType$7 = 'LightningAssistantStepRepresentation';
+function keyBuilder$g(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$7 + ':' + config.step_id;
+}
+function keyBuilderFromType$6(luvio, object) {
+    const keyParams = {
+        step_id: object.id
+    };
+    return keyBuilder$g(luvio, keyParams);
+}
+function normalize$7(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$i = function LightningAssistantStepRepresentationSelect() {
+    const 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) {
+    const existing_isManaged = existing.isManaged;
+    const incoming_isManaged = incoming.isManaged;
+    if (!(existing_isManaged === incoming_isManaged)) {
+        return false;
+    }
+    const existing_description = existing.description;
+    const 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;
+        }
+    }
+    const existing_figureComponent = existing.figureComponent;
+    const 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;
+        }
+    }
+    const existing_firstSeenTime = existing.firstSeenTime;
+    const 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;
+        }
+    }
+    const existing_id = existing.id;
+    const incoming_id = incoming.id;
+    if (!(existing_id === incoming_id)) {
+        return false;
+    }
+    const existing_status = existing.status;
+    const incoming_status = incoming.status;
+    if (!(existing_status === incoming_status)) {
+        return false;
+    }
+    const existing_stepComponent = existing.stepComponent;
+    const 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;
+        }
+    }
+    const existing_title = existing.title;
+    const incoming_title = incoming.title;
+    if (!(existing_title === incoming_title)) {
+        return false;
+    }
+    const existing_updateStrategy = existing.updateStrategy;
+    const incoming_updateStrategy = incoming.updateStrategy;
+    if (!(existing_updateStrategy === incoming_updateStrategy)) {
+        return false;
+    }
+    const existing_action = existing.action;
+    const incoming_action = incoming.action;
+    if (!(equals$a(existing_action, incoming_action))) {
+        return false;
+    }
+    const existing_tags = existing.tags;
+    const incoming_tags = incoming.tags;
+    const equals_tags_items = equalsArray(existing_tags, incoming_tags, (existing_tags_item, incoming_tags_item) => {
+        if (!(existing_tags_item === incoming_tags_item)) {
+            return false;
+        }
+    });
+    if (equals_tags_items === false) {
+        return false;
+    }
+    return true;
+}
+const ingest$7 = function LightningAssistantStepRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$b(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$6(luvio, input);
+    const existingRecord = store.readEntry(key);
+    const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
+    let 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) {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "LEAP",
+            version: VERSION$9,
+            representationName: RepresentationType$7,
+        };
+        luvio.publishStoreMetadata(key, storeMetadataParams);
+    }
+    return createLink(key);
+};
+function getTypeCacheKeys$7(luvio, input, fullPathFactory) {
+    const rootKeySet = new StoreKeyMap();
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const 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) {
+    const { body } = response;
+    const key = keyBuilderFromType$6(luvio, body);
+    luvio.storeIngest(key, ingest$7, body);
+    const 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) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/assistant-platform/step/' + config.urlParams.stepName + '',
+        method: 'patch',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const evaluateStep_ConfigPropertyNames = {
+    displayName: 'evaluateStep',
+    parameters: {
+        required: ['stepName'],
+        optional: []
+    }
+};
+function createResourceParams$8(config) {
+    const resourceParams = {
+        urlParams: {
+            stepName: config.stepName
+        }
+    };
+    return resourceParams;
+}
+function typeCheckConfig$8(untrustedConfig) {
+    const config = {};
+    const 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);
+    }
+    const config = typeCheckConfig$8(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$8(luvio, config, options) {
+    const resourceParams = createResourceParams$8(config);
+    const request = createResourceRequest$8(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$8(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => getResponseCacheKeys$8(luvio, resourceParams, response.body));
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const evaluateStepAdapterFactory = (luvio) => {
+    return function evaluateStep(untrustedConfig) {
+        const 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);
+    };
+};
+
+const VERSION$8 = "bc99d93cdafe8300d6f09b735c390bcd";
+function validate$a(obj, path = 'LightningAssistantLayoutNodeRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_children = obj.children;
+        const path_children = path + '.children';
+        if (!ArrayIsArray(obj_children)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_children + '" (at "' + path_children + '")');
+        }
+        for (let i = 0; i < obj_children.length; i++) {
+            const obj_children_item = obj_children[i];
+            const 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 + '")');
+            }
+        }
+        const obj_description = obj.description;
+        const path_description = path + '.description';
+        let obj_description_union0 = null;
+        const obj_description_union0_error = (() => {
+            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;
+        }
+        let obj_description_union1 = null;
+        const obj_description_union1_error = (() => {
+            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) {
+            let message = 'Object doesn\'t match union (at "' + path_description + '")';
+            message += '\n' + obj_description_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_description_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_status = obj.status;
+        const path_status = path + '.status';
+        let obj_status_union0 = null;
+        const obj_status_union0_error = (() => {
+            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;
+        }
+        let obj_status_union1 = null;
+        const obj_status_union1_error = (() => {
+            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) {
+            let message = 'Object doesn\'t match union (at "' + path_status + '")';
+            message += '\n' + obj_status_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_status_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_step = obj.step;
+        const path_step = path + '.step';
+        let obj_step_union0 = null;
+        const obj_step_union0_error = (() => {
+            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;
+        }
+        let obj_step_union1 = null;
+        const obj_step_union1_error = (() => {
+            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) {
+            let message = 'Object doesn\'t match union (at "' + path_step + '")';
+            message += '\n' + obj_step_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_step_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_tags = obj.tags;
+        const path_tags = path + '.tags';
+        if (!ArrayIsArray(obj_tags)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_tags + '" (at "' + path_tags + '")');
+        }
+        for (let i = 0; i < obj_tags.length; i++) {
+            const obj_tags_item = obj_tags[i];
+            const 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 + '")');
+            }
+        }
+        const obj_title = obj.title;
+        const path_title = path + '.title';
+        let obj_title_union0 = null;
+        const obj_title_union0_error = (() => {
+            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;
+        }
+        let obj_title_union1 = null;
+        const obj_title_union1_error = (() => {
+            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) {
+            let message = 'Object doesn\'t match union (at "' + path_title + '")';
+            message += '\n' + obj_title_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_title_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_type = obj.type;
+        const path_type = path + '.type';
+        if (typeof obj_type !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_type + '" (at "' + path_type + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$6 = 'LightningAssistantLayoutNodeRepresentation';
+function normalize$6(input, existing, path, luvio, store, timestamp) {
+    const input_step = input.step;
+    const 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;
+}
+const 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) {
+    const existing_type = existing.type;
+    const incoming_type = incoming.type;
+    if (!(existing_type === incoming_type)) {
+        return false;
+    }
+    const existing_children = existing.children;
+    const incoming_children = incoming.children;
+    const equals_children_items = equalsArray(existing_children, incoming_children, (existing_children_item, incoming_children_item) => {
+        if (JSONStringify(incoming_children_item) !== JSONStringify(existing_children_item)) {
+            return false;
+        }
+    });
+    if (equals_children_items === false) {
+        return false;
+    }
+    const existing_description = existing.description;
+    const incoming_description = incoming.description;
+    if (!(existing_description === incoming_description)) {
+        return false;
+    }
+    const existing_status = existing.status;
+    const incoming_status = incoming.status;
+    if (!(existing_status === incoming_status)) {
+        return false;
+    }
+    const existing_step = existing.step;
+    const 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;
+    }
+    const existing_tags = existing.tags;
+    const incoming_tags = incoming.tags;
+    const equals_tags_items = equalsArray(existing_tags, incoming_tags, (existing_tags_item, incoming_tags_item) => {
+        if (!(existing_tags_item === incoming_tags_item)) {
+            return false;
+        }
+    });
+    if (equals_tags_items === false) {
+        return false;
+    }
+    const existing_title = existing.title;
+    const incoming_title = incoming.title;
+    if (!(existing_title === incoming_title)) {
+        return false;
+    }
+    return true;
+}
+const ingest$6 = function LightningAssistantLayoutNodeRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$a(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = path.fullPath;
+    const existingRecord = store.readEntry(key);
+    const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
+    let 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) {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "LEAP",
+            version: VERSION$8,
+            representationName: RepresentationType$6,
+        };
+        luvio.publishStoreMetadata(key, storeMetadataParams);
+    }
+    return createLink(key);
+};
+function getTypeCacheKeys$6(luvio, input, fullPathFactory) {
+    const rootKeySet = new StoreKeyMap();
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = fullPathFactory();
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$6,
+        mergeable: false
+    });
+    if (input.step !== null && typeof input.step === 'object') {
+        const input_step = getTypeCacheKeys$7(luvio, input.step);
+        rootKeySet.merge(input_step);
+    }
+    return rootKeySet;
+}
+
+const VERSION$7 = "596a25b0bee0b1db5495fe57dd7bd025";
+function validate$9(obj, path = 'LightningAssistantRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_assistantTarget = obj.assistantTarget;
+        const 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) {
+            const obj_category = obj.category;
+            const 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) {
+            const obj_categoryName = obj.categoryName;
+            const 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) {
+            const obj_completionDate = obj.completionDate;
+            const path_completionDate = path + '.completionDate';
+            if (typeof obj_completionDate !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_completionDate + '" (at "' + path_completionDate + '")');
+            }
+        }
+        const obj_contentVersion = obj.contentVersion;
+        const path_contentVersion = path + '.contentVersion';
+        if (typeof obj_contentVersion !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contentVersion + '" (at "' + path_contentVersion + '")');
+        }
+        const obj_debugModeEnabled = obj.debugModeEnabled;
+        const 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) {
+            const obj_description = obj.description;
+            const path_description = path + '.description';
+            if (typeof obj_description !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_description + '" (at "' + path_description + '")');
+            }
+        }
+        const obj_developerName = obj.developerName;
+        const 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) {
+            const obj_estimatedMinutesToComplete = obj.estimatedMinutesToComplete;
+            const 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 + '")');
+            }
+        }
+        const obj_icon = obj.icon;
+        const path_icon = path + '.icon';
+        if (typeof obj_icon !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_icon + '" (at "' + path_icon + '")');
+        }
+        const obj_isArchived = obj.isArchived;
+        const path_isArchived = path + '.isArchived';
+        if (typeof obj_isArchived !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_isArchived + '" (at "' + path_isArchived + '")');
+        }
+        const obj_isPreview = obj.isPreview;
+        const path_isPreview = path + '.isPreview';
+        if (typeof obj_isPreview !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_isPreview + '" (at "' + path_isPreview + '")');
+        }
+        const obj_layout = obj.layout;
+        const path_layout = path + '.layout';
+        if (typeof obj_layout !== 'object') {
+            return new TypeError('Expected "object" but received "' + typeof obj_layout + '" (at "' + path_layout + '")');
+        }
+        const obj_numberOfSteps = obj.numberOfSteps;
+        const 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;
+        const obj_questionnaireIds = obj.questionnaireIds;
+        const path_questionnaireIds = path + '.questionnaireIds';
+        if (!ArrayIsArray(obj_questionnaireIds)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_questionnaireIds + '" (at "' + path_questionnaireIds + '")');
+        }
+        for (let i = 0; i < obj_questionnaireIds.length; i++) {
+            const obj_questionnaireIds_item = obj_questionnaireIds[i];
+            const 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 + '")');
+            }
+        }
+        const obj_status = obj.status;
+        const path_status = path + '.status';
+        if (typeof obj_status !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_status + '" (at "' + path_status + '")');
+        }
+        const obj_title = obj.title;
+        const 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;
+}
+const RepresentationType$5 = 'LightningAssistantRepresentation';
+function keyBuilder$f(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$5 + ':' + config.assistant_name;
+}
+function keyBuilderFromType$5(luvio, object) {
+    const keyParams = {
+        assistant_name: object.developerName
+    };
+    return keyBuilder$f(luvio, keyParams);
+}
+function normalize$5(input, existing, path, luvio, store, timestamp) {
+    const input_layout = input.layout;
+    const 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;
+}
+const 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) {
+    const existing_debugModeEnabled = existing.debugModeEnabled;
+    const incoming_debugModeEnabled = incoming.debugModeEnabled;
+    if (!(existing_debugModeEnabled === incoming_debugModeEnabled)) {
+        return false;
+    }
+    const existing_isArchived = existing.isArchived;
+    const incoming_isArchived = incoming.isArchived;
+    if (!(existing_isArchived === incoming_isArchived)) {
+        return false;
+    }
+    const existing_isPreview = existing.isPreview;
+    const incoming_isPreview = incoming.isPreview;
+    if (!(existing_isPreview === incoming_isPreview)) {
+        return false;
+    }
+    const existing_estimatedMinutesToComplete = existing.estimatedMinutesToComplete;
+    const 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;
+        }
+    }
+    const existing_numberOfSteps = existing.numberOfSteps;
+    const incoming_numberOfSteps = incoming.numberOfSteps;
+    if (!(existing_numberOfSteps === incoming_numberOfSteps)) {
+        return false;
+    }
+    const existing_assistantTarget = existing.assistantTarget;
+    const incoming_assistantTarget = incoming.assistantTarget;
+    if (!(existing_assistantTarget === incoming_assistantTarget)) {
+        return false;
+    }
+    const existing_category = existing.category;
+    const 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;
+        }
+    }
+    const existing_categoryName = existing.categoryName;
+    const 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;
+        }
+    }
+    const existing_completionDate = existing.completionDate;
+    const 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;
+        }
+    }
+    const existing_contentVersion = existing.contentVersion;
+    const incoming_contentVersion = incoming.contentVersion;
+    if (!(existing_contentVersion === incoming_contentVersion)) {
+        return false;
+    }
+    const existing_description = existing.description;
+    const 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;
+        }
+    }
+    const existing_developerName = existing.developerName;
+    const incoming_developerName = incoming.developerName;
+    if (!(existing_developerName === incoming_developerName)) {
+        return false;
+    }
+    const existing_icon = existing.icon;
+    const incoming_icon = incoming.icon;
+    if (!(existing_icon === incoming_icon)) {
+        return false;
+    }
+    const existing_status = existing.status;
+    const incoming_status = incoming.status;
+    if (!(existing_status === incoming_status)) {
+        return false;
+    }
+    const existing_title = existing.title;
+    const incoming_title = incoming.title;
+    if (!(existing_title === incoming_title)) {
+        return false;
+    }
+    const existing_progress = existing.progress;
+    const incoming_progress = incoming.progress;
+    if (!(existing_progress === incoming_progress)) {
+        return false;
+    }
+    const existing_layout = existing.layout;
+    const incoming_layout = incoming.layout;
+    if (!(existing_layout.__ref === incoming_layout.__ref)) {
+        return false;
+    }
+    const existing_questionnaireIds = existing.questionnaireIds;
+    const incoming_questionnaireIds = incoming.questionnaireIds;
+    const equals_questionnaireIds_items = equalsArray(existing_questionnaireIds, incoming_questionnaireIds, (existing_questionnaireIds_item, incoming_questionnaireIds_item) => {
+        if (!(existing_questionnaireIds_item === incoming_questionnaireIds_item)) {
+            return false;
+        }
+    });
+    if (equals_questionnaireIds_items === false) {
+        return false;
+    }
+    return true;
+}
+const ingest$5 = function LightningAssistantRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$9(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$5(luvio, input);
+    const existingRecord = store.readEntry(key);
+    const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
+    let 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) {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "LEAP",
+            version: VERSION$7,
+            representationName: RepresentationType$5,
+        };
+        luvio.publishStoreMetadata(key, storeMetadataParams);
+    }
+    return createLink(key);
+};
+function getTypeCacheKeys$5(luvio, input, fullPathFactory) {
+    const rootKeySet = new StoreKeyMap();
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$5(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$5,
+        mergeable: false
+    });
+    const input_layout = getTypeCacheKeys$6(luvio, input.layout, () => 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) {
+    const { body } = response;
+    const key = keyBuilder$e(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$5, body);
+    const 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) {
+    const key = keyBuilder$e(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    luvio.storeIngestError(key, errorSnapshot);
+    return errorSnapshot;
+}
+function createResourceRequest$7(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/assistant-platform/' + config.urlParams.assistantName + '',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const getAssistant_ConfigPropertyNames = {
+    displayName: 'getAssistant',
+    parameters: {
+        required: ['assistantName'],
+        optional: []
+    }
+};
+function createResourceParams$7(config) {
+    const resourceParams = {
+        urlParams: {
+            assistantName: config.assistantName
+        }
+    };
+    return resourceParams;
+}
+function keyBuilder$d(luvio, config) {
+    const resourceParams = createResourceParams$7(config);
+    return keyBuilder$e(luvio, resourceParams);
+}
+function typeCheckConfig$7(untrustedConfig) {
+    const config = {};
+    const 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);
+    }
+    const 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) {
+    const snapshot = ingestSuccess$7(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError$4(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$4(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$7(luvio, config, options) {
+    const resourceParams = createResourceParams$7(config);
+    const request = createResourceRequest$7(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$4(luvio, config, resourceParams, response), () => getResponseCacheKeys$7(luvio, resourceParams, response.body));
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$4(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext) {
+    const { luvio, config } = context;
+    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
+    const dispatchOptions = {
+        resourceRequestContext: {
+            requestCorrelator,
+            luvioRequestMethod: undefined,
+        },
+        eventObservers
+    };
+    if (networkPriority !== 'normal') {
+        dispatchOptions.overrides = {
+            priority: networkPriority
+        };
+    }
+    return buildNetworkSnapshot$7(luvio, config, dispatchOptions);
+}
+function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$d(luvio, config),
+        node: adapterFragment$4(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getAssistantAdapterFactory = (luvio) => function LEAP__getAssistant(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$7(untrustedConfig, getAssistant_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$4, buildNetworkSnapshotCachePolicy$4);
+};
+
+function validate$8(obj, path = 'LightningAssistantUpdateInputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_items = obj.items;
+        const 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 + '")');
+        }
+        const obj_items_keys = ObjectKeys(obj_items);
+        for (let i = 0; i < obj_items_keys.length; i++) {
+            const key = obj_items_keys[i];
+            const obj_items_prop = obj_items[key];
+            const 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) {
+    const { body } = response;
+    const key = keyBuilderFromType$5(luvio, body);
+    luvio.storeIngest(key, ingest$5, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$d(),
+        variables: {},
+    });
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    return snapshot;
+}
+function createResourceRequest$6(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/assistant-platform/' + config.urlParams.assistantName + '',
+        method: 'patch',
+        body: config.body,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const saveAssistant_ConfigPropertyNames = {
+    displayName: 'saveAssistant',
+    parameters: {
+        required: ['assistantName', 'assistantData'],
+        optional: []
+    }
+};
+function createResourceParams$6(config) {
+    const resourceParams = {
+        urlParams: {
+            assistantName: config.assistantName
+        },
+        body: {
+            assistantData: config.assistantData
+        }
+    };
+    return resourceParams;
+}
+function typeCheckConfig$6(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_assistantName = untrustedConfig.assistantName;
+    if (typeof untrustedConfig_assistantName === 'string') {
+        config.assistantName = untrustedConfig_assistantName;
+    }
+    const untrustedConfig_assistantData = untrustedConfig.assistantData;
+    const 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);
+    }
+    const config = typeCheckConfig$6(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$6(luvio, config, options) {
+    const resourceParams = createResourceParams$6(config);
+    const request = createResourceRequest$6(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$6(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => getResponseCacheKeys$6(luvio, resourceParams, response.body));
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const saveAssistantAdapterFactory = (luvio) => {
+    return function saveAssistant(untrustedConfig) {
+        const 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);
+    };
+};
+
+const VERSION$6 = "042081dc16ad8bafa711efc0ff696bde";
+function validate$7(obj, path = 'LightningAssistantQuestionnaireListRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_assistantName = obj.assistantName;
+        const path_assistantName = path + '.assistantName';
+        if (typeof obj_assistantName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_assistantName + '" (at "' + path_assistantName + '")');
+        }
+        const obj_questionnaireNames = obj.questionnaireNames;
+        const path_questionnaireNames = path + '.questionnaireNames';
+        if (!ArrayIsArray(obj_questionnaireNames)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_questionnaireNames + '" (at "' + path_questionnaireNames + '")');
+        }
+        for (let i = 0; i < obj_questionnaireNames.length; i++) {
+            const obj_questionnaireNames_item = obj_questionnaireNames[i];
+            const 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;
+}
+const RepresentationType$4 = 'LightningAssistantQuestionnaireListRepresentation';
+function keyBuilder$c(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$4 + ':' + config.assistant_name;
+}
+function keyBuilderFromType$4(luvio, object) {
+    const keyParams = {
+        assistant_name: object.assistantName
+    };
+    return keyBuilder$c(luvio, keyParams);
+}
+function normalize$4(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const 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) {
+    const existing_assistantName = existing.assistantName;
+    const incoming_assistantName = incoming.assistantName;
+    if (!(existing_assistantName === incoming_assistantName)) {
+        return false;
+    }
+    const existing_questionnaireNames = existing.questionnaireNames;
+    const incoming_questionnaireNames = incoming.questionnaireNames;
+    const equals_questionnaireNames_items = equalsArray(existing_questionnaireNames, incoming_questionnaireNames, (existing_questionnaireNames_item, incoming_questionnaireNames_item) => {
+        if (!(existing_questionnaireNames_item === incoming_questionnaireNames_item)) {
+            return false;
+        }
+    });
+    if (equals_questionnaireNames_items === false) {
+        return false;
+    }
+    return true;
+}
+const ingest$4 = function LightningAssistantQuestionnaireListRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$7(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$4(luvio, input);
+    const existingRecord = store.readEntry(key);
+    const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
+    let 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) {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "LEAP",
+            version: VERSION$6,
+            representationName: RepresentationType$4,
+        };
+        luvio.publishStoreMetadata(key, storeMetadataParams);
+    }
+    return createLink(key);
+};
+function getTypeCacheKeys$4(luvio, input, fullPathFactory) {
+    const rootKeySet = new StoreKeyMap();
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const 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) {
+    const { body } = response;
+    const key = keyBuilder$b(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$4, body);
+    const 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) {
+    const key = keyBuilder$b(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    luvio.storeIngestError(key, errorSnapshot);
+    return errorSnapshot;
+}
+function createResourceRequest$5(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/assistant-platform/' + config.urlParams.assistantName + '/questionnaires',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const getQuestionnaires_ConfigPropertyNames = {
+    displayName: 'getQuestionnaires',
+    parameters: {
+        required: ['assistantName'],
+        optional: []
+    }
+};
+function createResourceParams$5(config) {
+    const resourceParams = {
+        urlParams: {
+            assistantName: config.assistantName
+        }
+    };
+    return resourceParams;
+}
+function keyBuilder$a(luvio, config) {
+    const resourceParams = createResourceParams$5(config);
+    return keyBuilder$b(luvio, resourceParams);
+}
+function typeCheckConfig$5(untrustedConfig) {
+    const config = {};
+    const 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);
+    }
+    const 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) {
+    const snapshot = ingestSuccess$5(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError$3(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$3(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$5(luvio, config, options) {
+    const resourceParams = createResourceParams$5(config);
+    const request = createResourceRequest$5(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$3(luvio, config, resourceParams, response), () => getResponseCacheKeys$5(luvio, resourceParams, response.body));
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$3(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext) {
+    const { luvio, config } = context;
+    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
+    const dispatchOptions = {
+        resourceRequestContext: {
+            requestCorrelator,
+            luvioRequestMethod: undefined,
+        },
+        eventObservers
+    };
+    if (networkPriority !== 'normal') {
+        dispatchOptions.overrides = {
+            priority: networkPriority
+        };
+    }
+    return buildNetworkSnapshot$5(luvio, config, dispatchOptions);
+}
+function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$a(luvio, config),
+        node: adapterFragment$3(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getQuestionnairesAdapterFactory = (luvio) => function LEAP__getQuestionnaires(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$5(untrustedConfig, getQuestionnaires_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$3, buildNetworkSnapshotCachePolicy$3);
+};
+
+const VERSION$5 = "107898f86df2248eab831be29f7e7205";
+function validate$6(obj, path = 'LightningAssistantCategoryRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_developerName = obj.developerName;
+        const path_developerName = path + '.developerName';
+        if (typeof obj_developerName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_developerName + '" (at "' + path_developerName + '")');
+        }
+        const obj_recommended = obj.recommended;
+        const path_recommended = path + '.recommended';
+        if (typeof obj_recommended !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_recommended + '" (at "' + path_recommended + '")');
+        }
+        const obj_title = obj.title;
+        const 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;
+}
+const 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) {
+    const existing_recommended = existing.recommended;
+    const incoming_recommended = incoming.recommended;
+    if (!(existing_recommended === incoming_recommended)) {
+        return false;
+    }
+    const existing_developerName = existing.developerName;
+    const incoming_developerName = incoming.developerName;
+    if (!(existing_developerName === incoming_developerName)) {
+        return false;
+    }
+    const existing_title = existing.title;
+    const incoming_title = incoming.title;
+    if (!(existing_title === incoming_title)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$4 = "f629b70d652ad385840baede1ec16739";
+function validate$5(obj, path = 'LightningAssistantTargetRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_categoryList = obj.categoryList;
+        const path_categoryList = path + '.categoryList';
+        if (!ArrayIsArray(obj_categoryList)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_categoryList + '" (at "' + path_categoryList + '")');
+        }
+        for (let i = 0; i < obj_categoryList.length; i++) {
+            const obj_categoryList_item = obj_categoryList[i];
+            const path_categoryList_item = path_categoryList + '[' + i + ']';
+            const referencepath_categoryList_itemValidationError = validate$6(obj_categoryList_item, path_categoryList_item);
+            if (referencepath_categoryList_itemValidationError !== null) {
+                let message = 'Object doesn\'t match LightningAssistantCategoryRepresentation (at "' + path_categoryList_item + '")\n';
+                message += referencepath_categoryList_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_developerName = obj.developerName;
+        const 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;
+}
+const RepresentationType$3 = 'LightningAssistantTargetRepresentation';
+function keyBuilder$9(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$3 + ':' + config.assistant_target;
+}
+function keyBuilderFromType$3(luvio, object) {
+    const keyParams = {
+        assistant_target: object.developerName
+    };
+    return keyBuilder$9(luvio, keyParams);
+}
+function normalize$3(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$9 = function LightningAssistantTargetRepresentationSelect() {
+    const { selections: LightningAssistantCategoryRepresentation__selections, opaque: LightningAssistantCategoryRepresentation__opaque, } = select$a();
+    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) {
+    const existing_developerName = existing.developerName;
+    const incoming_developerName = incoming.developerName;
+    if (!(existing_developerName === incoming_developerName)) {
+        return false;
+    }
+    const existing_categoryList = existing.categoryList;
+    const incoming_categoryList = incoming.categoryList;
+    const equals_categoryList_items = equalsArray(existing_categoryList, incoming_categoryList, (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;
+}
+const ingest$3 = function LightningAssistantTargetRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$5(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$3(luvio, input);
+    const existingRecord = store.readEntry(key);
+    const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
+    let 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) {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "LEAP",
+            version: VERSION$4,
+            representationName: RepresentationType$3,
+        };
+        luvio.publishStoreMetadata(key, storeMetadataParams);
+    }
+    return createLink(key);
+};
+function getTypeCacheKeys$3(luvio, input, fullPathFactory) {
+    const rootKeySet = new StoreKeyMap();
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$3(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$3,
+        mergeable: false
+    });
+    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) {
+    const { body } = response;
+    const key = keyBuilder$8(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$3, body);
+    const 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) {
+    const key = keyBuilder$8(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    luvio.storeIngestError(key, errorSnapshot);
+    return errorSnapshot;
+}
+function createResourceRequest$4(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/assistant-platform/' + config.urlParams.assistantTarget + '/info',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const getAssistantTarget_ConfigPropertyNames = {
+    displayName: 'getAssistantTarget',
+    parameters: {
+        required: ['assistantTarget'],
+        optional: []
+    }
+};
+function createResourceParams$4(config) {
+    const resourceParams = {
+        urlParams: {
+            assistantTarget: config.assistantTarget
+        }
+    };
+    return resourceParams;
+}
+function keyBuilder$7(luvio, config) {
+    const resourceParams = createResourceParams$4(config);
+    return keyBuilder$8(luvio, resourceParams);
+}
+function typeCheckConfig$4(untrustedConfig) {
+    const config = {};
+    const 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);
+    }
+    const 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) {
+    const snapshot = ingestSuccess$4(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError$2(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$2(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$4(luvio, config, options) {
+    const resourceParams = createResourceParams$4(config);
+    const request = createResourceRequest$4(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$2(luvio, config, resourceParams, response), () => getResponseCacheKeys$4(luvio, resourceParams, response.body));
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$2(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$2(context, coercedAdapterRequestContext) {
+    const { luvio, config } = context;
+    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
+    const dispatchOptions = {
+        resourceRequestContext: {
+            requestCorrelator,
+            luvioRequestMethod: undefined,
+        },
+        eventObservers
+    };
+    if (networkPriority !== 'normal') {
+        dispatchOptions.overrides = {
+            priority: networkPriority
+        };
+    }
+    return buildNetworkSnapshot$4(luvio, config, dispatchOptions);
+}
+function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$7(luvio, config),
+        node: adapterFragment$2(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getAssistantTargetAdapterFactory = (luvio) => function LEAP__getAssistantTarget(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$4(untrustedConfig, getAssistantTarget_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$2, buildNetworkSnapshotCachePolicy$2);
+};
+
+const VERSION$3 = "f2e480ff95d6a6b46f4a4b00d2d40a04";
+function validate$4(obj, path = 'LightningAssistantInitializationRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_assistantTarget = obj.assistantTarget;
+        const path_assistantTarget = path + '.assistantTarget';
+        if (typeof obj_assistantTarget !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_assistantTarget + '" (at "' + path_assistantTarget + '")');
+        }
+        const obj_isInitialized = obj.isInitialized;
+        const 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;
+}
+const RepresentationType$2 = 'LightningAssistantInitializationRepresentation';
+function keyBuilder$6(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$2 + ':' + config.is_initialized + ':' + config.assistant_target;
+}
+function keyBuilderFromType$2(luvio, object) {
+    const 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;
+}
+const 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) {
+    const existing_isInitialized = existing.isInitialized;
+    const incoming_isInitialized = incoming.isInitialized;
+    if (!(existing_isInitialized === incoming_isInitialized)) {
+        return false;
+    }
+    const existing_assistantTarget = existing.assistantTarget;
+    const incoming_assistantTarget = incoming.assistantTarget;
+    if (!(existing_assistantTarget === incoming_assistantTarget)) {
+        return false;
+    }
+    return true;
+}
+const ingest$2 = function LightningAssistantInitializationRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$4(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$2(luvio, input);
+    const existingRecord = store.readEntry(key);
+    const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
+    let 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) {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "LEAP",
+            version: VERSION$3,
+            representationName: RepresentationType$2,
+        };
+        luvio.publishStoreMetadata(key, storeMetadataParams);
+    }
+    return createLink(key);
+};
+function getTypeCacheKeys$2(luvio, input, fullPathFactory) {
+    const rootKeySet = new StoreKeyMap();
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$2(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$2,
+        mergeable: false
+    });
+    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) {
+    const { body } = response;
+    const key = keyBuilderFromType$2(luvio, body);
+    luvio.storeIngest(key, ingest$2, body);
+    const 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) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/assistant-platform/' + config.urlParams.assistantTarget + '/initialize',
+        method: 'put',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const initialize_ConfigPropertyNames = {
+    displayName: 'initialize',
+    parameters: {
+        required: ['assistantTarget'],
+        optional: []
+    }
+};
+function createResourceParams$3(config) {
+    const resourceParams = {
+        urlParams: {
+            assistantTarget: config.assistantTarget
+        }
+    };
+    return resourceParams;
+}
+function typeCheckConfig$3(untrustedConfig) {
+    const config = {};
+    const 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);
+    }
+    const config = typeCheckConfig$3(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$3(luvio, config, options) {
+    const resourceParams = createResourceParams$3(config);
+    const request = createResourceRequest$3(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$3(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => getResponseCacheKeys$3(luvio, resourceParams, response.body));
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const initializeAdapterFactory = (luvio) => {
+    return function initialize(untrustedConfig) {
+        const 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);
+    };
+};
+
+const VERSION$2 = "86eec990f47f496e2991fb9e5ccf0802";
+function validate$3(obj, path = 'LightningAssistantListRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_assistantList = obj.assistantList;
+        const path_assistantList = path + '.assistantList';
+        if (!ArrayIsArray(obj_assistantList)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_assistantList + '" (at "' + path_assistantList + '")');
+        }
+        for (let i = 0; i < obj_assistantList.length; i++) {
+            const obj_assistantList_item = obj_assistantList[i];
+            const 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 + '")');
+            }
+        }
+        const obj_assistantTarget = obj.assistantTarget;
+        const 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;
+}
+const RepresentationType$1 = 'LightningAssistantListRepresentation';
+function keyBuilder$5(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$1 + ':' + config.assistant_target;
+}
+function keyBuilderFromType$1(luvio, object) {
+    const keyParams = {
+        assistant_target: object.assistantTarget
+    };
+    return keyBuilder$5(luvio, keyParams);
+}
+function normalize$1(input, existing, path, luvio, store, timestamp) {
+    const input_assistantList = input.assistantList;
+    const input_assistantList_id = path.fullPath + '__assistantList';
+    for (let i = 0; i < input_assistantList.length; i++) {
+        const input_assistantList_item = input_assistantList[i];
+        let 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;
+}
+const 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) {
+    const existing_assistantTarget = existing.assistantTarget;
+    const incoming_assistantTarget = incoming.assistantTarget;
+    if (!(existing_assistantTarget === incoming_assistantTarget)) {
+        return false;
+    }
+    const existing_assistantList = existing.assistantList;
+    const incoming_assistantList = incoming.assistantList;
+    const equals_assistantList_items = equalsArray(existing_assistantList, incoming_assistantList, (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;
+}
+const ingest$1 = function LightningAssistantListRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$3(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$1(luvio, input);
+    const existingRecord = store.readEntry(key);
+    const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
+    let 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) {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "LEAP",
+            version: VERSION$2,
+            representationName: RepresentationType$1,
+        };
+        luvio.publishStoreMetadata(key, storeMetadataParams);
+    }
+    return createLink(key);
+};
+function getTypeCacheKeys$1(luvio, input, fullPathFactory) {
+    const rootKeySet = new StoreKeyMap();
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$1(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$1,
+        mergeable: false
+    });
+    const input_assistantList_length = input.assistantList.length;
+    for (let 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) {
+    const { body } = response;
+    const key = keyBuilder$4(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$1, body);
+    const 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) {
+    const key = keyBuilder$4(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    luvio.storeIngestError(key, errorSnapshot);
+    return errorSnapshot;
+}
+function createResourceRequest$2(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/assistant-platform/' + config.urlParams.assistantTarget + '/list',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const getAssistantList_ConfigPropertyNames = {
+    displayName: 'getAssistantList',
+    parameters: {
+        required: ['assistantTarget'],
+        optional: []
+    }
+};
+function createResourceParams$2(config) {
+    const resourceParams = {
+        urlParams: {
+            assistantTarget: config.assistantTarget
+        }
+    };
+    return resourceParams;
+}
+function keyBuilder$3(luvio, config) {
+    const resourceParams = createResourceParams$2(config);
+    return keyBuilder$4(luvio, resourceParams);
+}
+function typeCheckConfig$2(untrustedConfig) {
+    const config = {};
+    const 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);
+    }
+    const 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) {
+    const snapshot = ingestSuccess$2(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError$1(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$1(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$2(luvio, config, options) {
+    const resourceParams = createResourceParams$2(config);
+    const request = createResourceRequest$2(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$1(luvio, config, resourceParams, response), () => getResponseCacheKeys$2(luvio, resourceParams, response.body));
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$1(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext) {
+    const { luvio, config } = context;
+    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
+    const dispatchOptions = {
+        resourceRequestContext: {
+            requestCorrelator,
+            luvioRequestMethod: undefined,
+        },
+        eventObservers
+    };
+    if (networkPriority !== 'normal') {
+        dispatchOptions.overrides = {
+            priority: networkPriority
+        };
+    }
+    return buildNetworkSnapshot$2(luvio, config, dispatchOptions);
+}
+function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$3(luvio, config),
+        node: adapterFragment$1(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getAssistantListAdapterFactory = (luvio) => function LEAP__getAssistantList(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$2(untrustedConfig, getAssistantList_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$1, buildNetworkSnapshotCachePolicy$1);
+};
+
+function validate$2(obj, path = 'LightningAssistantListInputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_assistantList = obj.assistantList;
+        const 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 + '")');
+        }
+        const obj_assistantList_keys = ObjectKeys(obj_assistantList);
+        for (let i = 0; i < obj_assistantList_keys.length; i++) {
+            const key = obj_assistantList_keys[i];
+            const obj_assistantList_prop = obj_assistantList[key];
+            const 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) {
+    const { body } = response;
+    const key = keyBuilderFromType$1(luvio, body);
+    luvio.storeIngest(key, ingest$1, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$3(),
+        variables: {},
+    });
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    return snapshot;
+}
+function createResourceRequest$1(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/assistant-platform/' + config.urlParams.assistantTarget + '/list',
+        method: 'patch',
+        body: config.body,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const saveAssistantList_ConfigPropertyNames = {
+    displayName: 'saveAssistantList',
+    parameters: {
+        required: ['assistantTarget', 'assistantData'],
+        optional: []
+    }
+};
+function createResourceParams$1(config) {
+    const resourceParams = {
+        urlParams: {
+            assistantTarget: config.assistantTarget
+        },
+        body: {
+            assistantData: config.assistantData
+        }
+    };
+    return resourceParams;
+}
+function typeCheckConfig$1(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_assistantTarget = untrustedConfig.assistantTarget;
+    if (typeof untrustedConfig_assistantTarget === 'string') {
+        config.assistantTarget = untrustedConfig_assistantTarget;
+    }
+    const untrustedConfig_assistantData = untrustedConfig.assistantData;
+    const 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);
+    }
+    const config = typeCheckConfig$1(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$1(luvio, config, options) {
+    const resourceParams = createResourceParams$1(config);
+    const request = createResourceRequest$1(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$1(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => getResponseCacheKeys$1(luvio, resourceParams, response.body));
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const saveAssistantListAdapterFactory = (luvio) => {
+    return function saveAssistantList(untrustedConfig) {
+        const 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);
+    };
+};
+
+const VERSION$1 = "60c238eb770e68fa40b048eee3d01775";
+function validate$1(obj, path = 'LightningAssistantInfoRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_assistantTarget = obj.assistantTarget;
+        const 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) {
+            const obj_category = obj.category;
+            const 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) {
+            const obj_categoryName = obj.categoryName;
+            const path_categoryName = path + '.categoryName';
+            if (typeof obj_categoryName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_categoryName + '" (at "' + path_categoryName + '")');
+            }
+        }
+        const obj_contentVersion = obj.contentVersion;
+        const path_contentVersion = path + '.contentVersion';
+        if (typeof obj_contentVersion !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_contentVersion + '" (at "' + path_contentVersion + '")');
+        }
+        const obj_debugModeEnabled = obj.debugModeEnabled;
+        const path_debugModeEnabled = path + '.debugModeEnabled';
+        if (typeof obj_debugModeEnabled !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_debugModeEnabled + '" (at "' + path_debugModeEnabled + '")');
+        }
+        const obj_description = obj.description;
+        const path_description = path + '.description';
+        if (typeof obj_description !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_description + '" (at "' + path_description + '")');
+        }
+        const obj_developerName = obj.developerName;
+        const path_developerName = path + '.developerName';
+        if (typeof obj_developerName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_developerName + '" (at "' + path_developerName + '")');
+        }
+        const obj_icon = obj.icon;
+        const path_icon = path + '.icon';
+        if (typeof obj_icon !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_icon + '" (at "' + path_icon + '")');
+        }
+        const obj_isPreview = obj.isPreview;
+        const path_isPreview = path + '.isPreview';
+        if (typeof obj_isPreview !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_isPreview + '" (at "' + path_isPreview + '")');
+        }
+        const obj_title = obj.title;
+        const 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;
+}
+const 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) {
+    const existing_debugModeEnabled = existing.debugModeEnabled;
+    const incoming_debugModeEnabled = incoming.debugModeEnabled;
+    if (!(existing_debugModeEnabled === incoming_debugModeEnabled)) {
+        return false;
+    }
+    const existing_isPreview = existing.isPreview;
+    const incoming_isPreview = incoming.isPreview;
+    if (!(existing_isPreview === incoming_isPreview)) {
+        return false;
+    }
+    const existing_assistantTarget = existing.assistantTarget;
+    const incoming_assistantTarget = incoming.assistantTarget;
+    if (!(existing_assistantTarget === incoming_assistantTarget)) {
+        return false;
+    }
+    const existing_category = existing.category;
+    const 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;
+        }
+    }
+    const existing_categoryName = existing.categoryName;
+    const 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;
+        }
+    }
+    const existing_contentVersion = existing.contentVersion;
+    const incoming_contentVersion = incoming.contentVersion;
+    if (!(existing_contentVersion === incoming_contentVersion)) {
+        return false;
+    }
+    const existing_description = existing.description;
+    const incoming_description = incoming.description;
+    if (!(existing_description === incoming_description)) {
+        return false;
+    }
+    const existing_developerName = existing.developerName;
+    const incoming_developerName = incoming.developerName;
+    if (!(existing_developerName === incoming_developerName)) {
+        return false;
+    }
+    const existing_icon = existing.icon;
+    const incoming_icon = incoming.icon;
+    if (!(existing_icon === incoming_icon)) {
+        return false;
+    }
+    const existing_title = existing.title;
+    const incoming_title = incoming.title;
+    if (!(existing_title === incoming_title)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION = "d3f2957d23e995fb380f62e85e1d26ea";
+function validate(obj, path = 'LightningAssistantInfoListRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_assistantInfoList = obj.assistantInfoList;
+        const path_assistantInfoList = path + '.assistantInfoList';
+        if (!ArrayIsArray(obj_assistantInfoList)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_assistantInfoList + '" (at "' + path_assistantInfoList + '")');
+        }
+        for (let i = 0; i < obj_assistantInfoList.length; i++) {
+            const obj_assistantInfoList_item = obj_assistantInfoList[i];
+            const path_assistantInfoList_item = path_assistantInfoList + '[' + i + ']';
+            const referencepath_assistantInfoList_itemValidationError = validate$1(obj_assistantInfoList_item, path_assistantInfoList_item);
+            if (referencepath_assistantInfoList_itemValidationError !== null) {
+                let message = 'Object doesn\'t match LightningAssistantInfoRepresentation (at "' + path_assistantInfoList_item + '")\n';
+                message += referencepath_assistantInfoList_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_assistantTarget = obj.assistantTarget;
+        const 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;
+}
+const RepresentationType = 'LightningAssistantInfoListRepresentation';
+function keyBuilder$2(luvio, config) {
+    return keyPrefix + '::' + RepresentationType + ':' + config.assistant_target;
+}
+function keyBuilderFromType(luvio, object) {
+    const keyParams = {
+        assistant_target: object.assistantTarget
+    };
+    return keyBuilder$2(luvio, keyParams);
+}
+function normalize(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$1 = function LightningAssistantInfoListRepresentationSelect() {
+    const { selections: LightningAssistantInfoRepresentation__selections, opaque: LightningAssistantInfoRepresentation__opaque, } = select$2();
+    return {
+        kind: 'Fragment',
+        version: VERSION,
+        private: [],
+        selections: [
+            {
+                name: 'assistantInfoList',
+                kind: 'Object',
+                plural: true,
+                selections: LightningAssistantInfoRepresentation__selections
+            },
+            {
+                name: 'assistantTarget',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals(existing, incoming) {
+    const existing_assistantTarget = existing.assistantTarget;
+    const incoming_assistantTarget = incoming.assistantTarget;
+    if (!(existing_assistantTarget === incoming_assistantTarget)) {
+        return false;
+    }
+    const existing_assistantInfoList = existing.assistantInfoList;
+    const incoming_assistantInfoList = incoming.assistantInfoList;
+    const equals_assistantInfoList_items = equalsArray(existing_assistantInfoList, incoming_assistantInfoList, (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;
+}
+const ingest = function LightningAssistantInfoListRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType(luvio, input);
+    const existingRecord = store.readEntry(key);
+    const ttlToUse = path.ttl !== undefined ? path.ttl : 2592000000;
+    let 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) {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "LEAP",
+            version: VERSION,
+            representationName: RepresentationType,
+        };
+        luvio.publishStoreMetadata(key, storeMetadataParams);
+    }
+    return createLink(key);
+};
+function getTypeCacheKeys(luvio, input, fullPathFactory) {
+    const rootKeySet = new StoreKeyMap();
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const 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) {
+    const { body } = response;
+    const key = keyBuilder$1(luvio, resourceParams);
+    luvio.storeIngest(key, ingest, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select(),
+        variables: {},
+    }, snapshotRefresh);
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    return snapshot;
+}
+function ingestError(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$1(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    luvio.storeIngestError(key, errorSnapshot);
+    return errorSnapshot;
+}
+function createResourceRequest(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v58.0',
+        basePath: '/assistant-platform/' + config.urlParams.assistantTarget + '/list/info',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const getAssistantInfoList_ConfigPropertyNames = {
+    displayName: 'getAssistantInfoList',
+    parameters: {
+        required: ['assistantTarget'],
+        optional: []
+    }
+};
+function createResourceParams(config) {
+    const resourceParams = {
+        urlParams: {
+            assistantTarget: config.assistantTarget
+        }
+    };
+    return resourceParams;
+}
+function keyBuilder(luvio, config) {
+    const resourceParams = createResourceParams(config);
+    return keyBuilder$1(luvio, resourceParams);
+}
+function typeCheckConfig(untrustedConfig) {
+    const config = {};
+    const 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);
+    }
+    const config = typeCheckConfig(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment(luvio, config) {
+    createResourceParams(config);
+    return select();
+}
+function onFetchResponseSuccess(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError(luvio, config, resourceParams, response) {
+    const snapshot = ingestError(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot(luvio, config, options) {
+    const resourceParams = createResourceParams(config);
+    const request = createResourceRequest(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess(luvio, config, resourceParams, response), () => getResponseCacheKeys(luvio, resourceParams, response.body));
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
+    const { luvio, config } = context;
+    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
+    const dispatchOptions = {
+        resourceRequestContext: {
+            requestCorrelator,
+            luvioRequestMethod: undefined,
+        },
+        eventObservers
+    };
+    if (networkPriority !== 'normal') {
+        dispatchOptions.overrides = {
+            priority: networkPriority
+        };
+    }
+    return buildNetworkSnapshot(luvio, config, dispatchOptions);
+}
+function buildCachedSnapshotCachePolicy(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder(luvio, config),
+        node: adapterFragment(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getAssistantInfoListAdapterFactory = (luvio) => function LEAP__getAssistantInfoList(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig(untrustedConfig, getAssistantInfoList_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
+};
+
+export { evaluateStepAdapterFactory, getAssistantAdapterFactory, getAssistantInfoListAdapterFactory, getAssistantListAdapterFactory, getAssistantTargetAdapterFactory, getQuestionnaireAdapterFactory, getQuestionnairesAdapterFactory, initializeAdapterFactory, saveAssistantAdapterFactory, saveAssistantListAdapterFactory, saveQuestionnaireAdapterFactory };