@salesforce/lds-adapters-industries-education 1.294.0 → 1.296.0

package/dist/es/es2018/industries-education.js

@@ -4,7 +4,7 @@
  * For full license text, see the LICENSE.txt file
  */
 
-import { serializeStructuredKey, ingestShape, deepFreeze, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$f, StoreKeyMap, createResourceParams as createResourceParams$n, typeCheckConfig as typeCheckConfig$n } from '@luvio/engine';
+import { serializeStructuredKey, ingestShape, deepFreeze, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$g, StoreKeyMap, createResourceParams as createResourceParams$o, typeCheckConfig as typeCheckConfig$o } from '@luvio/engine';
 
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
 const { keys: ObjectKeys$1, create: ObjectCreate$1 } = Object;
@@ -112,8 +112,8 @@ function createLink(ref) {
     };
 }
 
-const VERSION$J = "25644bb9c14397ee2eee2a59a6de4b8c";
-function validate$1a(obj, path = 'Applicant') {
+const VERSION$K = "25644bb9c14397ee2eee2a59a6de4b8c";
+function validate$1c(obj, path = 'Applicant') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -142,10 +142,10 @@ function validate$1a(obj, path = 'Applicant') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$14 = function ApplicantSelect() {
+const select$16 = function ApplicantSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$J,
+        version: VERSION$K,
         private: [],
         selections: [
             {
@@ -166,7 +166,7 @@ const select$14 = function ApplicantSelect() {
         ]
     };
 };
-function equals$H(existing, incoming) {
+function equals$I(existing, incoming) {
     const existing_contactId = existing.contactId;
     const incoming_contactId = incoming.contactId;
     // if at least one of these optionals is defined
@@ -209,7 +209,7 @@ function equals$H(existing, incoming) {
     return true;
 }
 
-function validate$19(obj, path = 'Submitter') {
+function validate$1b(obj, path = 'Submitter') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -232,7 +232,7 @@ function validate$19(obj, path = 'Submitter') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$18(obj, path = 'Application') {
+function validate$1a(obj, path = 'Application') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -247,7 +247,7 @@ function validate$18(obj, path = 'Application') {
         if (obj.applicant !== undefined) {
             const obj_applicant = obj.applicant;
             const path_applicant = path + '.applicant';
-            const referencepath_applicantValidationError = validate$1a(obj_applicant, path_applicant);
+            const referencepath_applicantValidationError = validate$1c(obj_applicant, path_applicant);
             if (referencepath_applicantValidationError !== null) {
                 let message = 'Object doesn\'t match Applicant (at "' + path_applicant + '")\n';
                 message += referencepath_applicantValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -306,7 +306,7 @@ function validate$18(obj, path = 'Application') {
         if (obj.submitter !== undefined) {
             const obj_submitter = obj.submitter;
             const path_submitter = path + '.submitter';
-            const referencepath_submitterValidationError = validate$19(obj_submitter, path_submitter);
+            const referencepath_submitterValidationError = validate$1b(obj_submitter, path_submitter);
             if (referencepath_submitterValidationError !== null) {
                 let message = 'Object doesn\'t match Submitter (at "' + path_submitter + '")\n';
                 message += referencepath_submitterValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -331,7 +331,7 @@ function validate$18(obj, path = 'Application') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$17(obj, path = 'GetApplicationsResult') {
+function validate$19(obj, path = 'GetApplicationsResult') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -345,7 +345,7 @@ function validate$17(obj, path = 'GetApplicationsResult') {
             for (let i = 0; i < obj_applications.length; i++) {
                 const obj_applications_item = obj_applications[i];
                 const path_applications_item = path_applications + '[' + i + ']';
-                const referencepath_applications_itemValidationError = validate$18(obj_applications_item, path_applications_item);
+                const referencepath_applications_itemValidationError = validate$1a(obj_applications_item, path_applications_item);
                 if (referencepath_applications_itemValidationError !== null) {
                     let message = 'Object doesn\'t match Application (at "' + path_applications_item + '")\n';
                     message += referencepath_applications_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -357,9 +357,9 @@ function validate$17(obj, path = 'GetApplicationsResult') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$7 = 100;
-const VERSION$I = "1947ca622740f63d1812cfa7d4dd5989";
-function validate$16(obj, path = 'ApplicationsOutputRepresentation') {
+const TTL$8 = 100;
+const VERSION$J = "1947ca622740f63d1812cfa7d4dd5989";
+function validate$18(obj, path = 'ApplicationsOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -367,7 +367,7 @@ function validate$16(obj, path = 'ApplicationsOutputRepresentation') {
         if (obj.result !== undefined) {
             const obj_result = obj.result;
             const path_result = path + '.result';
-            const referencepath_resultValidationError = validate$17(obj_result, path_result);
+            const referencepath_resultValidationError = validate$19(obj_result, path_result);
             if (referencepath_resultValidationError !== null) {
                 let message = 'Object doesn\'t match GetApplicationsResult (at "' + path_result + '")\n';
                 message += referencepath_resultValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -377,62 +377,62 @@ function validate$16(obj, path = 'ApplicationsOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$k = 'ApplicationsOutputRepresentation';
-function normalize$k(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$l = 'ApplicationsOutputRepresentation';
+function normalize$l(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$13 = function ApplicationsOutputRepresentationSelect() {
+const select$15 = function ApplicationsOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$I,
+        version: VERSION$J,
         private: [],
         opaque: true
     };
 };
-function equals$G(existing, incoming) {
+function equals$H(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$k = function ApplicationsOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$l = function ApplicationsOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$16(input);
+        const validateError = validate$18(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = path.fullPath;
-    const ttlToUse = TTL$7;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$k, "education", VERSION$I, RepresentationType$k, equals$G);
+    const ttlToUse = TTL$8;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$l, "education", VERSION$J, RepresentationType$l, equals$H);
     return createLink(key);
 };
-function getTypeCacheKeys$k(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$l(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$k,
+        representationName: RepresentationType$l,
         mergeable: false
     });
 }
 
-function select$12(luvio, params) {
-    return select$13();
+function select$14(luvio, params) {
+    return select$15();
 }
-function keyBuilder$z(luvio, params) {
+function keyBuilder$B(luvio, params) {
     return keyPrefix + '::ApplicationsOutputRepresentation:(' + ')';
 }
-function getResponseCacheKeys$m(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$k(storeKeyMap, luvio, response, () => keyBuilder$z());
+function getResponseCacheKeys$n(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$l(storeKeyMap, luvio, response, () => keyBuilder$B());
 }
-function ingestSuccess$m(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$n(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$z();
-    luvio.storeIngest(key, ingest$k, body);
+    const key = keyBuilder$B();
+    luvio.storeIngest(key, ingest$l, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$12(),
+        node: select$14(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -443,19 +443,19 @@ function ingestSuccess$m(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$e(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$z();
+function ingestError$f(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$B();
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$7,
+        ttl: TTL$8,
         namespace: keyPrefix,
-        version: VERSION$I,
-        representationName: RepresentationType$k
+        version: VERSION$J,
+        representationName: RepresentationType$l
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$m(config) {
+function createResourceRequest$n(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -469,90 +469,90 @@ function createResourceRequest$m(config) {
     };
 }
 
-const adapterName$m = 'getApplications';
+const adapterName$n = 'getApplications';
 const getApplications_ConfigPropertyMetadata = [];
-const getApplications_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$m, getApplications_ConfigPropertyMetadata);
-const createResourceParams$m = /*#__PURE__*/ createResourceParams$n(getApplications_ConfigPropertyMetadata);
-function keyBuilder$y(luvio, config) {
-    createResourceParams$m(config);
-    return keyBuilder$z();
+const getApplications_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$n, getApplications_ConfigPropertyMetadata);
+const createResourceParams$n = /*#__PURE__*/ createResourceParams$o(getApplications_ConfigPropertyMetadata);
+function keyBuilder$A(luvio, config) {
+    createResourceParams$n(config);
+    return keyBuilder$B();
 }
-function typeCheckConfig$m(untrustedConfig) {
+function typeCheckConfig$n(untrustedConfig) {
     const config = {};
     return config;
 }
-function validateAdapterConfig$m(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$n(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$m();
+    const config = typeCheckConfig$n();
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$e(luvio, config) {
-    createResourceParams$m(config);
-    return select$12();
+function adapterFragment$f(luvio, config) {
+    createResourceParams$n(config);
+    return select$14();
 }
-function onFetchResponseSuccess$e(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$m(luvio, resourceParams, response, {
+function onFetchResponseSuccess$f(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$n(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$m(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$n(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$e(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$e(luvio, resourceParams, response, {
+function onFetchResponseError$f(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$f(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$m(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$n(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$m(luvio, config, options) {
-    const resourceParams = createResourceParams$m(config);
-    const request = createResourceRequest$m();
+function buildNetworkSnapshot$n(luvio, config, options) {
+    const resourceParams = createResourceParams$n(config);
+    const request = createResourceRequest$n();
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$e(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$f(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$m(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$n(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$e(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$f(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$e(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot$m, undefined, false);
+function buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$g(context, coercedAdapterRequestContext, buildNetworkSnapshot$n, undefined, false);
 }
-function buildCachedSnapshotCachePolicy$e(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$f(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$y(luvio, config),
-        node: adapterFragment$e(luvio, config),
+        recordId: keyBuilder$A(luvio, config),
+        node: adapterFragment$f(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$m(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$n(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getApplicationsAdapterFactory = (luvio) => function education__getApplications(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$m(untrustedConfig, getApplications_ConfigPropertyNames);
+    const config = validateAdapterConfig$n(untrustedConfig, getApplications_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$e, buildNetworkSnapshotCachePolicy$e);
+    buildCachedSnapshotCachePolicy$f, buildNetworkSnapshotCachePolicy$f);
 };
 
-function validate$15(obj, path = 'ApplicationRenderMethod') {
+function validate$17(obj, path = 'ApplicationRenderMethod') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -589,7 +589,7 @@ function validate$15(obj, path = 'ApplicationRenderMethod') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$14(obj, path = 'IndividualApplicationTask') {
+function validate$16(obj, path = 'IndividualApplicationTask') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -603,7 +603,7 @@ function validate$14(obj, path = 'IndividualApplicationTask') {
             for (let i = 0; i < obj_applicationRenderMethods.length; i++) {
                 const obj_applicationRenderMethods_item = obj_applicationRenderMethods[i];
                 const path_applicationRenderMethods_item = path_applicationRenderMethods + '[' + i + ']';
-                const referencepath_applicationRenderMethods_itemValidationError = validate$15(obj_applicationRenderMethods_item, path_applicationRenderMethods_item);
+                const referencepath_applicationRenderMethods_itemValidationError = validate$17(obj_applicationRenderMethods_item, path_applicationRenderMethods_item);
                 if (referencepath_applicationRenderMethods_itemValidationError !== null) {
                     let message = 'Object doesn\'t match ApplicationRenderMethod (at "' + path_applicationRenderMethods_item + '")\n';
                     message += referencepath_applicationRenderMethods_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -685,7 +685,7 @@ function validate$14(obj, path = 'IndividualApplicationTask') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$13(obj, path = 'GetApplicationDetailsResult') {
+function validate$15(obj, path = 'GetApplicationDetailsResult') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -700,7 +700,7 @@ function validate$13(obj, path = 'GetApplicationDetailsResult') {
         if (obj.applicant !== undefined) {
             const obj_applicant = obj.applicant;
             const path_applicant = path + '.applicant';
-            const referencepath_applicantValidationError = validate$1a(obj_applicant, path_applicant);
+            const referencepath_applicantValidationError = validate$1c(obj_applicant, path_applicant);
             if (referencepath_applicantValidationError !== null) {
                 let message = 'Object doesn\'t match Applicant (at "' + path_applicant + '")\n';
                 message += referencepath_applicantValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -744,7 +744,7 @@ function validate$13(obj, path = 'GetApplicationDetailsResult') {
             for (let i = 0; i < obj_individualApplicationTasks.length; i++) {
                 const obj_individualApplicationTasks_item = obj_individualApplicationTasks[i];
                 const path_individualApplicationTasks_item = path_individualApplicationTasks + '[' + i + ']';
-                const referencepath_individualApplicationTasks_itemValidationError = validate$14(obj_individualApplicationTasks_item, path_individualApplicationTasks_item);
+                const referencepath_individualApplicationTasks_itemValidationError = validate$16(obj_individualApplicationTasks_item, path_individualApplicationTasks_item);
                 if (referencepath_individualApplicationTasks_itemValidationError !== null) {
                     let message = 'Object doesn\'t match IndividualApplicationTask (at "' + path_individualApplicationTasks_item + '")\n';
                     message += referencepath_individualApplicationTasks_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -776,7 +776,7 @@ function validate$13(obj, path = 'GetApplicationDetailsResult') {
         if (obj.submitter !== undefined) {
             const obj_submitter = obj.submitter;
             const path_submitter = path + '.submitter';
-            const referencepath_submitterValidationError = validate$19(obj_submitter, path_submitter);
+            const referencepath_submitterValidationError = validate$1b(obj_submitter, path_submitter);
             if (referencepath_submitterValidationError !== null) {
                 let message = 'Object doesn\'t match Submitter (at "' + path_submitter + '")\n';
                 message += referencepath_submitterValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -801,9 +801,9 @@ function validate$13(obj, path = 'GetApplicationDetailsResult') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$6 = 100;
-const VERSION$H = "20a50ee9f09ba0dc956412cc14d5b6d5";
-function validate$12(obj, path = 'ApplicationDetailsOutputRepresentation') {
+const TTL$7 = 100;
+const VERSION$I = "20a50ee9f09ba0dc956412cc14d5b6d5";
+function validate$14(obj, path = 'ApplicationDetailsOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -811,7 +811,7 @@ function validate$12(obj, path = 'ApplicationDetailsOutputRepresentation') {
         if (obj.result !== undefined) {
             const obj_result = obj.result;
             const path_result = path + '.result';
-            const referencepath_resultValidationError = validate$13(obj_result, path_result);
+            const referencepath_resultValidationError = validate$15(obj_result, path_result);
             if (referencepath_resultValidationError !== null) {
                 let message = 'Object doesn\'t match GetApplicationDetailsResult (at "' + path_result + '")\n';
                 message += referencepath_resultValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -821,62 +821,62 @@ function validate$12(obj, path = 'ApplicationDetailsOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$j = 'ApplicationDetailsOutputRepresentation';
-function normalize$j(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$k = 'ApplicationDetailsOutputRepresentation';
+function normalize$k(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$11 = function ApplicationDetailsOutputRepresentationSelect() {
+const select$13 = function ApplicationDetailsOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$H,
+        version: VERSION$I,
         private: [],
         opaque: true
     };
 };
-function equals$F(existing, incoming) {
+function equals$G(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$j = function ApplicationDetailsOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$k = function ApplicationDetailsOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$12(input);
+        const validateError = validate$14(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = path.fullPath;
-    const ttlToUse = TTL$6;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$j, "education", VERSION$H, RepresentationType$j, equals$F);
+    const ttlToUse = TTL$7;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$k, "education", VERSION$I, RepresentationType$k, equals$G);
     return createLink(key);
 };
-function getTypeCacheKeys$j(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$k(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$j,
+        representationName: RepresentationType$k,
         mergeable: false
     });
 }
 
-function select$10(luvio, params) {
-    return select$11();
+function select$12(luvio, params) {
+    return select$13();
 }
-function keyBuilder$x(luvio, params) {
+function keyBuilder$z(luvio, params) {
     return keyPrefix + '::ApplicationDetailsOutputRepresentation:(' + 'preliminaryApplicationRefId:' + params.urlParams.preliminaryApplicationRefId + ')';
 }
-function getResponseCacheKeys$l(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$j(storeKeyMap, luvio, response, () => keyBuilder$x(luvio, resourceParams));
+function getResponseCacheKeys$m(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$k(storeKeyMap, luvio, response, () => keyBuilder$z(luvio, resourceParams));
 }
-function ingestSuccess$l(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$m(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$x(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$j, body);
+    const key = keyBuilder$z(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$k, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$10(),
+        node: select$12(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -887,19 +887,19 @@ function ingestSuccess$l(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$d(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$x(luvio, params);
+function ingestError$e(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$z(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$6,
+        ttl: TTL$7,
         namespace: keyPrefix,
-        version: VERSION$H,
-        representationName: RepresentationType$j
+        version: VERSION$I,
+        representationName: RepresentationType$k
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$l(config) {
+function createResourceRequest$m(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -913,93 +913,93 @@ function createResourceRequest$l(config) {
     };
 }
 
-const adapterName$l = 'getApplicationDetails';
+const adapterName$m = 'getApplicationDetails';
 const getApplicationDetails_ConfigPropertyMetadata = [
     generateParamConfigMetadata('preliminaryApplicationRefId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getApplicationDetails_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$l, getApplicationDetails_ConfigPropertyMetadata);
-const createResourceParams$l = /*#__PURE__*/ createResourceParams$n(getApplicationDetails_ConfigPropertyMetadata);
-function keyBuilder$w(luvio, config) {
-    const resourceParams = createResourceParams$l(config);
-    return keyBuilder$x(luvio, resourceParams);
+const getApplicationDetails_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$m, getApplicationDetails_ConfigPropertyMetadata);
+const createResourceParams$m = /*#__PURE__*/ createResourceParams$o(getApplicationDetails_ConfigPropertyMetadata);
+function keyBuilder$y(luvio, config) {
+    const resourceParams = createResourceParams$m(config);
+    return keyBuilder$z(luvio, resourceParams);
 }
-function typeCheckConfig$l(untrustedConfig) {
+function typeCheckConfig$m(untrustedConfig) {
     const config = {};
-    typeCheckConfig$n(untrustedConfig, config, getApplicationDetails_ConfigPropertyMetadata);
+    typeCheckConfig$o(untrustedConfig, config, getApplicationDetails_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$l(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$m(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$l(untrustedConfig);
+    const config = typeCheckConfig$m(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$d(luvio, config) {
-    createResourceParams$l(config);
-    return select$10();
+function adapterFragment$e(luvio, config) {
+    createResourceParams$m(config);
+    return select$12();
 }
-function onFetchResponseSuccess$d(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$l(luvio, resourceParams, response, {
+function onFetchResponseSuccess$e(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$m(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$l(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$m(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$d(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$d(luvio, resourceParams, response, {
+function onFetchResponseError$e(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$e(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$l(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$m(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$l(luvio, config, options) {
-    const resourceParams = createResourceParams$l(config);
-    const request = createResourceRequest$l(resourceParams);
+function buildNetworkSnapshot$m(luvio, config, options) {
+    const resourceParams = createResourceParams$m(config);
+    const request = createResourceRequest$m(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$d(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$e(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$l(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$m(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$d(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$e(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$d(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot$l, undefined, false);
+function buildNetworkSnapshotCachePolicy$e(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$g(context, coercedAdapterRequestContext, buildNetworkSnapshot$m, undefined, false);
 }
-function buildCachedSnapshotCachePolicy$d(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$e(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$w(luvio, config),
-        node: adapterFragment$d(luvio, config),
+        recordId: keyBuilder$y(luvio, config),
+        node: adapterFragment$e(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$l(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$m(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getApplicationDetailsAdapterFactory = (luvio) => function education__getApplicationDetails(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$l(untrustedConfig, getApplicationDetails_ConfigPropertyNames);
+    const config = validateAdapterConfig$m(untrustedConfig, getApplicationDetails_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$d, buildNetworkSnapshotCachePolicy$d);
+    buildCachedSnapshotCachePolicy$e, buildNetworkSnapshotCachePolicy$e);
 };
 
-function validate$11(obj, path = 'AvailableTimeSlotsInputRepresentation') {
+function validate$13(obj, path = 'AvailableTimeSlotsInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1063,8 +1063,8 @@ function validate$11(obj, path = 'AvailableTimeSlotsInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const VERSION$G = "cfd94fbef61f52ffe43428e23e7a68c8";
-function validate$10(obj, path = 'TimeSlot') {
+const VERSION$H = "cfd94fbef61f52ffe43428e23e7a68c8";
+function validate$12(obj, path = 'TimeSlot') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1100,10 +1100,10 @@ function validate$10(obj, path = 'TimeSlot') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$$ = function TimeSlotSelect() {
+const select$11 = function TimeSlotSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$G,
+        version: VERSION$H,
         private: [],
         selections: [
             {
@@ -1129,7 +1129,7 @@ const select$$ = function TimeSlotSelect() {
         ]
     };
 };
-function equals$E(existing, incoming) {
+function equals$F(existing, incoming) {
     const existing_endTime = existing.endTime;
     const incoming_endTime = incoming.endTime;
     // if at least one of these optionals is defined
@@ -1185,8 +1185,8 @@ function equals$E(existing, incoming) {
     return true;
 }
 
-const VERSION$F = "9c2ef94b89ee532c50c8423528617441";
-function validate$$(obj, path = 'AvailableTimeSlotsOuputRepresentation') {
+const VERSION$G = "9c2ef94b89ee532c50c8423528617441";
+function validate$11(obj, path = 'AvailableTimeSlotsOuputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1199,7 +1199,7 @@ function validate$$(obj, path = 'AvailableTimeSlotsOuputRepresentation') {
         for (let i = 0; i < obj_timeSlots.length; i++) {
             const obj_timeSlots_item = obj_timeSlots[i];
             const path_timeSlots_item = path_timeSlots + '[' + i + ']';
-            const referencepath_timeSlots_itemValidationError = validate$10(obj_timeSlots_item, path_timeSlots_item);
+            const referencepath_timeSlots_itemValidationError = validate$12(obj_timeSlots_item, path_timeSlots_item);
             if (referencepath_timeSlots_itemValidationError !== null) {
                 let message = 'Object doesn\'t match TimeSlot (at "' + path_timeSlots_item + '")\n';
                 message += referencepath_timeSlots_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -1209,15 +1209,15 @@ function validate$$(obj, path = 'AvailableTimeSlotsOuputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$i = 'AvailableTimeSlotsOuputRepresentation';
-function normalize$i(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$j = 'AvailableTimeSlotsOuputRepresentation';
+function normalize$j(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$_ = function AvailableTimeSlotsOuputRepresentationSelect() {
-    const { selections: TimeSlot__selections, opaque: TimeSlot__opaque, } = select$$();
+const select$10 = function AvailableTimeSlotsOuputRepresentationSelect() {
+    const { selections: TimeSlot__selections, opaque: TimeSlot__opaque, } = select$11();
     return {
         kind: 'Fragment',
-        version: VERSION$F,
+        version: VERSION$G,
         private: [],
         selections: [
             {
@@ -1229,11 +1229,11 @@ const select$_ = function AvailableTimeSlotsOuputRepresentationSelect() {
         ]
     };
 };
-function equals$D(existing, incoming) {
+function equals$E(existing, incoming) {
     const existing_timeSlots = existing.timeSlots;
     const incoming_timeSlots = incoming.timeSlots;
     const equals_timeSlots_items = equalsArray(existing_timeSlots, incoming_timeSlots, (existing_timeSlots_item, incoming_timeSlots_item) => {
-        if (!(equals$E(existing_timeSlots_item, incoming_timeSlots_item))) {
+        if (!(equals$F(existing_timeSlots_item, incoming_timeSlots_item))) {
             return false;
         }
     });
@@ -1242,44 +1242,44 @@ function equals$D(existing, incoming) {
     }
     return true;
 }
-const ingest$i = function AvailableTimeSlotsOuputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$j = function AvailableTimeSlotsOuputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$$(input);
+        const validateError = validate$11(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = path.fullPath;
     const ttlToUse = path.ttl !== undefined ? path.ttl : 360000;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$i, "education", VERSION$F, RepresentationType$i, equals$D);
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$j, "education", VERSION$G, RepresentationType$j, equals$E);
     return createLink(key);
 };
-function getTypeCacheKeys$i(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$j(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$i,
+        representationName: RepresentationType$j,
         mergeable: false
     });
 }
 
-function select$Z(luvio, params) {
-    return select$_();
+function select$$(luvio, params) {
+    return select$10();
 }
-function keyBuilder$v(luvio, params) {
+function keyBuilder$x(luvio, params) {
     return keyPrefix + '::AvailableTimeSlotsOuputRepresentation:(' + (params.body.availableTimeSlotsInput.endTime === undefined ? 'availableTimeSlotsInput.endTime' : 'availableTimeSlotsInput.endTime:' + params.body.availableTimeSlotsInput.endTime) + '::' + 'availableTimeSlotsInput.engagementChannelTypeIds:' + params.body.availableTimeSlotsInput.engagementChannelTypeIds + '::' + 'availableTimeSlotsInput.serviceResourceIds:' + params.body.availableTimeSlotsInput.serviceResourceIds + '::' + 'availableTimeSlotsInput.serviceTerritoryIds:' + params.body.availableTimeSlotsInput.serviceTerritoryIds + '::' + (params.body.availableTimeSlotsInput.startTime === undefined ? 'availableTimeSlotsInput.startTime' : 'availableTimeSlotsInput.startTime:' + params.body.availableTimeSlotsInput.startTime) + '::' + 'availableTimeSlotsInput.workTypeGroupId:' + params.body.availableTimeSlotsInput.workTypeGroupId + ')';
 }
-function getResponseCacheKeys$k(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$i(storeKeyMap, luvio, response, () => keyBuilder$v(luvio, resourceParams));
+function getResponseCacheKeys$l(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$j(storeKeyMap, luvio, response, () => keyBuilder$x(luvio, resourceParams));
 }
-function ingestSuccess$k(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$l(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$v(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$i, body);
+    const key = keyBuilder$x(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$j, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$Z(),
+        node: select$$(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -1290,13 +1290,13 @@ function ingestSuccess$k(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$c(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$v(luvio, params);
+function ingestError$d(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$x(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$k(config) {
+function createResourceRequest$l(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -1310,98 +1310,98 @@ function createResourceRequest$k(config) {
     };
 }
 
-const adapterName$k = 'getAvailableTimeSlots';
+const adapterName$l = 'getAvailableTimeSlots';
 const getAvailableTimeSlots_ConfigPropertyMetadata = [
     generateParamConfigMetadata('availableTimeSlotsInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const getAvailableTimeSlots_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$k, getAvailableTimeSlots_ConfigPropertyMetadata);
-const createResourceParams$k = /*#__PURE__*/ createResourceParams$n(getAvailableTimeSlots_ConfigPropertyMetadata);
-function keyBuilder$u(luvio, config) {
-    const resourceParams = createResourceParams$k(config);
-    return keyBuilder$v(luvio, resourceParams);
+const getAvailableTimeSlots_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$l, getAvailableTimeSlots_ConfigPropertyMetadata);
+const createResourceParams$l = /*#__PURE__*/ createResourceParams$o(getAvailableTimeSlots_ConfigPropertyMetadata);
+function keyBuilder$w(luvio, config) {
+    const resourceParams = createResourceParams$l(config);
+    return keyBuilder$x(luvio, resourceParams);
 }
-function typeCheckConfig$k(untrustedConfig) {
+function typeCheckConfig$l(untrustedConfig) {
     const config = {};
     const untrustedConfig_availableTimeSlotsInput = untrustedConfig.availableTimeSlotsInput;
-    const referenceAvailableTimeSlotsInputRepresentationValidationError = validate$11(untrustedConfig_availableTimeSlotsInput);
+    const referenceAvailableTimeSlotsInputRepresentationValidationError = validate$13(untrustedConfig_availableTimeSlotsInput);
     if (referenceAvailableTimeSlotsInputRepresentationValidationError === null) {
         config.availableTimeSlotsInput = untrustedConfig_availableTimeSlotsInput;
     }
     return config;
 }
-function validateAdapterConfig$k(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$l(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$k(untrustedConfig);
+    const config = typeCheckConfig$l(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$c(luvio, config) {
-    createResourceParams$k(config);
-    return select$Z();
+function adapterFragment$d(luvio, config) {
+    createResourceParams$l(config);
+    return select$$();
 }
-function onFetchResponseSuccess$c(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$k(luvio, resourceParams, response, {
+function onFetchResponseSuccess$d(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$l(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$k(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$l(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$c(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$c(luvio, resourceParams, response, {
+function onFetchResponseError$d(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$d(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$k(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$l(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$k(luvio, config, options) {
-    const resourceParams = createResourceParams$k(config);
-    const request = createResourceRequest$k(resourceParams);
+function buildNetworkSnapshot$l(luvio, config, options) {
+    const resourceParams = createResourceParams$l(config);
+    const request = createResourceRequest$l(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$c(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$d(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$k(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$l(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$c(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$d(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$c(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot$k, 'get', false);
+function buildNetworkSnapshotCachePolicy$d(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$g(context, coercedAdapterRequestContext, buildNetworkSnapshot$l, 'get', false);
 }
-function buildCachedSnapshotCachePolicy$c(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$d(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$u(luvio, config),
-        node: adapterFragment$c(luvio, config),
+        recordId: keyBuilder$w(luvio, config),
+        node: adapterFragment$d(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$k(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$l(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getAvailableTimeSlotsAdapterFactory = (luvio) => function education__getAvailableTimeSlots(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$k(untrustedConfig, getAvailableTimeSlots_ConfigPropertyNames);
+    const config = validateAdapterConfig$l(untrustedConfig, getAvailableTimeSlots_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$c, buildNetworkSnapshotCachePolicy$c);
+    buildCachedSnapshotCachePolicy$d, buildNetworkSnapshotCachePolicy$d);
 };
 
-const VERSION$E = "c470aba735607497dd11c1fcd34489d1";
-function validate$_(obj, path = 'AvailableTopic') {
+const VERSION$F = "c470aba735607497dd11c1fcd34489d1";
+function validate$10(obj, path = 'AvailableTopic') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1446,10 +1446,10 @@ function validate$_(obj, path = 'AvailableTopic') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$Y = function AvailableTopicSelect() {
+const select$_ = function AvailableTopicSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$E,
+        version: VERSION$F,
         private: [],
         selections: [
             {
@@ -1475,7 +1475,7 @@ const select$Y = function AvailableTopicSelect() {
         ]
     };
 };
-function equals$C(existing, incoming) {
+function equals$D(existing, incoming) {
     const existing_parentWorkTypeGroupName = existing.parentWorkTypeGroupName;
     const incoming_parentWorkTypeGroupName = incoming.parentWorkTypeGroupName;
     // if at least one of these optionals is defined
@@ -1536,8 +1536,8 @@ function equals$C(existing, incoming) {
     return true;
 }
 
-const VERSION$D = "3cb0110faf688dc57056aa83be527181";
-function validate$Z(obj, path = 'AvailableTopicsOutputRepresentation') {
+const VERSION$E = "3cb0110faf688dc57056aa83be527181";
+function validate$$(obj, path = 'AvailableTopicsOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1550,7 +1550,7 @@ function validate$Z(obj, path = 'AvailableTopicsOutputRepresentation') {
         for (let i = 0; i < obj_topics.length; i++) {
             const obj_topics_item = obj_topics[i];
             const path_topics_item = path_topics + '[' + i + ']';
-            const referencepath_topics_itemValidationError = validate$_(obj_topics_item, path_topics_item);
+            const referencepath_topics_itemValidationError = validate$10(obj_topics_item, path_topics_item);
             if (referencepath_topics_itemValidationError !== null) {
                 let message = 'Object doesn\'t match AvailableTopic (at "' + path_topics_item + '")\n';
                 message += referencepath_topics_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -1560,15 +1560,15 @@ function validate$Z(obj, path = 'AvailableTopicsOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$h = 'AvailableTopicsOutputRepresentation';
-function normalize$h(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$i = 'AvailableTopicsOutputRepresentation';
+function normalize$i(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$X = function AvailableTopicsOutputRepresentationSelect() {
-    const { selections: AvailableTopic__selections, opaque: AvailableTopic__opaque, } = select$Y();
+const select$Z = function AvailableTopicsOutputRepresentationSelect() {
+    const { selections: AvailableTopic__selections, opaque: AvailableTopic__opaque, } = select$_();
     return {
         kind: 'Fragment',
-        version: VERSION$D,
+        version: VERSION$E,
         private: [],
         selections: [
             {
@@ -1580,11 +1580,11 @@ const select$X = function AvailableTopicsOutputRepresentationSelect() {
         ]
     };
 };
-function equals$B(existing, incoming) {
+function equals$C(existing, incoming) {
     const existing_topics = existing.topics;
     const incoming_topics = incoming.topics;
     const equals_topics_items = equalsArray(existing_topics, incoming_topics, (existing_topics_item, incoming_topics_item) => {
-        if (!(equals$C(existing_topics_item, incoming_topics_item))) {
+        if (!(equals$D(existing_topics_item, incoming_topics_item))) {
             return false;
         }
     });
@@ -1593,44 +1593,44 @@ function equals$B(existing, incoming) {
     }
     return true;
 }
-const ingest$h = function AvailableTopicsOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$i = function AvailableTopicsOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$Z(input);
+        const validateError = validate$$(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = path.fullPath;
     const ttlToUse = path.ttl !== undefined ? path.ttl : 360000;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$h, "education", VERSION$D, RepresentationType$h, equals$B);
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$i, "education", VERSION$E, RepresentationType$i, equals$C);
     return createLink(key);
 };
-function getTypeCacheKeys$h(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$i(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$h,
+        representationName: RepresentationType$i,
         mergeable: false
     });
 }
 
-function select$W(luvio, params) {
-    return select$X();
+function select$Y(luvio, params) {
+    return select$Z();
 }
-function keyBuilder$t(luvio, params) {
+function keyBuilder$v(luvio, params) {
     return keyPrefix + '::AvailableTopicsOutputRepresentation:(' + ')';
 }
-function getResponseCacheKeys$j(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$h(storeKeyMap, luvio, response, () => keyBuilder$t());
+function getResponseCacheKeys$k(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$i(storeKeyMap, luvio, response, () => keyBuilder$v());
 }
-function ingestSuccess$j(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$k(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$t();
-    luvio.storeIngest(key, ingest$h, body);
+    const key = keyBuilder$v();
+    luvio.storeIngest(key, ingest$i, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$W(),
+        node: select$Y(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -1641,13 +1641,13 @@ function ingestSuccess$j(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$b(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$t();
+function ingestError$c(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$v();
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$j(config) {
+function createResourceRequest$k(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -1661,95 +1661,95 @@ function createResourceRequest$j(config) {
     };
 }
 
-const adapterName$j = 'getAvailableTopics';
+const adapterName$k = 'getAvailableTopics';
 const getAvailableTopics_ConfigPropertyMetadata = [];
-const getAvailableTopics_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$j, getAvailableTopics_ConfigPropertyMetadata);
-const createResourceParams$j = /*#__PURE__*/ createResourceParams$n(getAvailableTopics_ConfigPropertyMetadata);
-function keyBuilder$s(luvio, config) {
-    createResourceParams$j(config);
-    return keyBuilder$t();
+const getAvailableTopics_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$k, getAvailableTopics_ConfigPropertyMetadata);
+const createResourceParams$k = /*#__PURE__*/ createResourceParams$o(getAvailableTopics_ConfigPropertyMetadata);
+function keyBuilder$u(luvio, config) {
+    createResourceParams$k(config);
+    return keyBuilder$v();
 }
-function typeCheckConfig$j(untrustedConfig) {
+function typeCheckConfig$k(untrustedConfig) {
     const config = {};
     return config;
 }
-function validateAdapterConfig$j(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$k(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$j();
+    const config = typeCheckConfig$k();
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$b(luvio, config) {
-    createResourceParams$j(config);
-    return select$W();
+function adapterFragment$c(luvio, config) {
+    createResourceParams$k(config);
+    return select$Y();
 }
-function onFetchResponseSuccess$b(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$j(luvio, resourceParams, response, {
+function onFetchResponseSuccess$c(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$k(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$j(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$k(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$b(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$b(luvio, resourceParams, response, {
+function onFetchResponseError$c(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$c(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$j(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$k(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$j(luvio, config, options) {
-    const resourceParams = createResourceParams$j(config);
-    const request = createResourceRequest$j();
+function buildNetworkSnapshot$k(luvio, config, options) {
+    const resourceParams = createResourceParams$k(config);
+    const request = createResourceRequest$k();
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$b(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$c(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$j(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$k(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$b(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$c(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$b(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot$j, undefined, false);
+function buildNetworkSnapshotCachePolicy$c(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$g(context, coercedAdapterRequestContext, buildNetworkSnapshot$k, undefined, false);
 }
-function buildCachedSnapshotCachePolicy$b(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$c(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$s(luvio, config),
-        node: adapterFragment$b(luvio, config),
+        recordId: keyBuilder$u(luvio, config),
+        node: adapterFragment$c(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$j(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$k(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getAvailableTopicsAdapterFactory = (luvio) => function education__getAvailableTopics(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$j(untrustedConfig, getAvailableTopics_ConfigPropertyNames);
+    const config = validateAdapterConfig$k(untrustedConfig, getAvailableTopics_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$b, buildNetworkSnapshotCachePolicy$b);
+    buildCachedSnapshotCachePolicy$c, buildNetworkSnapshotCachePolicy$c);
 };
 
-const VERSION$C = "b91b2c52908f1e75dc471ab19f3a612c";
-const select$V = function LearningCourseOutputSelect() {
-    const { selections: LearningOutputSelections } = select$T();
+const VERSION$D = "b91b2c52908f1e75dc471ab19f3a612c";
+const select$X = function LearningCourseOutputSelect() {
+    const { selections: LearningOutputSelections } = select$V();
     return {
         kind: 'Fragment',
-        version: VERSION$C,
+        version: VERSION$D,
         private: [],
         selections: [
             ...LearningOutputSelections,
@@ -1782,12 +1782,12 @@ const select$V = function LearningCourseOutputSelect() {
     };
 };
 
-const VERSION$B = "cbcb4b73c08332ecb30476cf1c496a3d";
-const select$U = function LearningProgramOutputSelect() {
-    const { selections: LearningOutputSelections } = select$T();
+const VERSION$C = "cbcb4b73c08332ecb30476cf1c496a3d";
+const select$W = function LearningProgramOutputSelect() {
+    const { selections: LearningOutputSelections } = select$V();
     return {
         kind: 'Fragment',
-        version: VERSION$B,
+        version: VERSION$C,
         private: [],
         selections: [
             ...LearningOutputSelections,
@@ -1805,8 +1805,8 @@ var DiscriminatorValues;
     DiscriminatorValues["LearningCourse"] = "LearningCourse";
     DiscriminatorValues["LearningProgram"] = "LearningProgram";
 })(DiscriminatorValues || (DiscriminatorValues = {}));
-const VERSION$A = "4cbea421d9f8469662b2fe303c2f4ba2";
-function validate$Y(obj, path = 'LearningOutput') {
+const VERSION$B = "4cbea421d9f8469662b2fe303c2f4ba2";
+function validate$_(obj, path = 'LearningOutput') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1893,8 +1893,8 @@ function validate$Y(obj, path = 'LearningOutput') {
     return v_error === undefined ? null : v_error;
 }
 const selectChildren = function LearningOutputSelectChildren() {
-    const learningCourseOutputSelections = select$V();
-    const learningProgramOutputSelections = select$U();
+    const learningCourseOutputSelections = select$X();
+    const learningProgramOutputSelections = select$W();
     return {
         kind: 'Fragment',
         union: true,
@@ -1905,10 +1905,10 @@ const selectChildren = function LearningOutputSelectChildren() {
         }
     };
 };
-const select$T = function LearningOutputSelect() {
+const select$V = function LearningOutputSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$A,
+        version: VERSION$B,
         private: [],
         selections: [
             {
@@ -1973,7 +1973,7 @@ const select$T = function LearningOutputSelect() {
         ]
     };
 };
-function equals$A(existing, incoming) {
+function equals$B(existing, incoming) {
     const existing_active = existing.active;
     const incoming_active = incoming.active;
     // if at least one of these optionals is defined
@@ -2125,8 +2125,8 @@ function equals$A(existing, incoming) {
     return true;
 }
 
-const VERSION$z = "97ece1d620b7a7775b8ec069c727fb0c";
-function validate$X(obj, path = 'LearningOutcomeItemOutput') {
+const VERSION$A = "97ece1d620b7a7775b8ec069c727fb0c";
+function validate$Z(obj, path = 'LearningOutcomeItemOutput') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -2151,10 +2151,10 @@ function validate$X(obj, path = 'LearningOutcomeItemOutput') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$S = function LearningOutcomeItemOutputSelect() {
+const select$U = function LearningOutcomeItemOutputSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$z,
+        version: VERSION$A,
         private: [],
         selections: [
             {
@@ -2175,7 +2175,7 @@ const select$S = function LearningOutcomeItemOutputSelect() {
         ]
     };
 };
-function equals$z(existing, incoming) {
+function equals$A(existing, incoming) {
     const existing_durationUnit = existing.durationUnit;
     const incoming_durationUnit = incoming.durationUnit;
     // if at least one of these optionals is defined
@@ -2218,8 +2218,8 @@ function equals$z(existing, incoming) {
     return true;
 }
 
-const VERSION$y = "1bdbecc684e08a141881821c200a3684";
-function validate$W(obj, path = 'LearningStatus') {
+const VERSION$z = "1bdbecc684e08a141881821c200a3684";
+function validate$Y(obj, path = 'LearningStatus') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -2267,10 +2267,10 @@ function validate$W(obj, path = 'LearningStatus') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$R = function LearningStatusSelect() {
+const select$T = function LearningStatusSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$y,
+        version: VERSION$z,
         private: [],
         selections: [
             {
@@ -2305,7 +2305,7 @@ const select$R = function LearningStatusSelect() {
         ]
     };
 };
-function equals$y(existing, incoming) {
+function equals$z(existing, incoming) {
     const existing_academicSeason = existing.academicSeason;
     const incoming_academicSeason = incoming.academicSeason;
     // if at least one of these optionals is defined
@@ -2379,8 +2379,8 @@ function equals$y(existing, incoming) {
     return true;
 }
 
-const VERSION$x = "626a699b7d94feb238f5a5a6641daa16";
-function validate$V(obj, path = 'LearningFulfiller') {
+const VERSION$y = "626a699b7d94feb238f5a5a6641daa16";
+function validate$X(obj, path = 'LearningFulfiller') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -2388,7 +2388,7 @@ function validate$V(obj, path = 'LearningFulfiller') {
         if (obj.learning !== undefined) {
             const obj_learning = obj.learning;
             const path_learning = path + '.learning';
-            const referencepath_learningValidationError = validate$Y(obj_learning, path_learning);
+            const referencepath_learningValidationError = validate$_(obj_learning, path_learning);
             if (referencepath_learningValidationError !== null) {
                 let message = 'Object doesn\'t match LearningOutput (at "' + path_learning + '")\n';
                 message += referencepath_learningValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -2398,7 +2398,7 @@ function validate$V(obj, path = 'LearningFulfiller') {
         if (obj.learningOutcomeItem !== undefined) {
             const obj_learningOutcomeItem = obj.learningOutcomeItem;
             const path_learningOutcomeItem = path + '.learningOutcomeItem';
-            const referencepath_learningOutcomeItemValidationError = validate$X(obj_learningOutcomeItem, path_learningOutcomeItem);
+            const referencepath_learningOutcomeItemValidationError = validate$Z(obj_learningOutcomeItem, path_learningOutcomeItem);
             if (referencepath_learningOutcomeItemValidationError !== null) {
                 let message = 'Object doesn\'t match LearningOutcomeItemOutput (at "' + path_learningOutcomeItem + '")\n';
                 message += referencepath_learningOutcomeItemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -2408,7 +2408,7 @@ function validate$V(obj, path = 'LearningFulfiller') {
         if (obj.learningStatus !== undefined) {
             const obj_learningStatus = obj.learningStatus;
             const path_learningStatus = path + '.learningStatus';
-            const referencepath_learningStatusValidationError = validate$W(obj_learningStatus, path_learningStatus);
+            const referencepath_learningStatusValidationError = validate$Y(obj_learningStatus, path_learningStatus);
             if (referencepath_learningStatusValidationError !== null) {
                 let message = 'Object doesn\'t match LearningStatus (at "' + path_learningStatus + '")\n';
                 message += referencepath_learningStatusValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -2418,13 +2418,13 @@ function validate$V(obj, path = 'LearningFulfiller') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$Q = function LearningFulfillerSelect() {
+const select$S = function LearningFulfillerSelect() {
     const LearningOutput__unionSelections = selectChildren();
-    const { selections: LearningOutcomeItemOutput__selections, opaque: LearningOutcomeItemOutput__opaque, } = select$S();
-    const { selections: LearningStatus__selections, opaque: LearningStatus__opaque, } = select$R();
+    const { selections: LearningOutcomeItemOutput__selections, opaque: LearningOutcomeItemOutput__opaque, } = select$U();
+    const { selections: LearningStatus__selections, opaque: LearningStatus__opaque, } = select$T();
     return {
         kind: 'Fragment',
-        version: VERSION$x,
+        version: VERSION$y,
         private: [],
         selections: [
             {
@@ -2450,7 +2450,7 @@ const select$Q = function LearningFulfillerSelect() {
         ]
     };
 };
-function equals$x(existing, incoming) {
+function equals$y(existing, incoming) {
     const existing_learning = existing.learning;
     const incoming_learning = incoming.learning;
     // if at least one of these optionals is defined
@@ -2460,7 +2460,7 @@ function equals$x(existing, incoming) {
         if (existing_learning === undefined || incoming_learning === undefined) {
             return false;
         }
-        if (!(equals$A(existing_learning, incoming_learning))) {
+        if (!(equals$B(existing_learning, incoming_learning))) {
             return false;
         }
     }
@@ -2473,7 +2473,7 @@ function equals$x(existing, incoming) {
         if (existing_learningOutcomeItem === undefined || incoming_learningOutcomeItem === undefined) {
             return false;
         }
-        if (!(equals$z(existing_learningOutcomeItem, incoming_learningOutcomeItem))) {
+        if (!(equals$A(existing_learningOutcomeItem, incoming_learningOutcomeItem))) {
             return false;
         }
     }
@@ -2486,15 +2486,15 @@ function equals$x(existing, incoming) {
         if (existing_learningStatus === undefined || incoming_learningStatus === undefined) {
             return false;
         }
-        if (!(equals$y(existing_learningStatus, incoming_learningStatus))) {
+        if (!(equals$z(existing_learningStatus, incoming_learningStatus))) {
             return false;
         }
     }
     return true;
 }
 
-const VERSION$w = "ed4788c6324cb7fee773d388cf21b1b4";
-function validate$U(obj, path = 'LearningProgramPlanRequirementOutput') {
+const VERSION$x = "ed4788c6324cb7fee773d388cf21b1b4";
+function validate$W(obj, path = 'LearningProgramPlanRequirementOutput') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -2532,7 +2532,7 @@ function validate$U(obj, path = 'LearningProgramPlanRequirementOutput') {
             for (let i = 0; i < obj_fulfilledBy.length; i++) {
                 const obj_fulfilledBy_item = obj_fulfilledBy[i];
                 const path_fulfilledBy_item = path_fulfilledBy + '[' + i + ']';
-                const referencepath_fulfilledBy_itemValidationError = validate$V(obj_fulfilledBy_item, path_fulfilledBy_item);
+                const referencepath_fulfilledBy_itemValidationError = validate$X(obj_fulfilledBy_item, path_fulfilledBy_item);
                 if (referencepath_fulfilledBy_itemValidationError !== null) {
                     let message = 'Object doesn\'t match LearningFulfiller (at "' + path_fulfilledBy_item + '")\n';
                     message += referencepath_fulfilledBy_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -2578,11 +2578,11 @@ function validate$U(obj, path = 'LearningProgramPlanRequirementOutput') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$P = function LearningProgramPlanRequirementOutputSelect() {
-    const { selections: LearningFulfiller__selections, opaque: LearningFulfiller__opaque, } = select$Q();
+const select$R = function LearningProgramPlanRequirementOutputSelect() {
+    const { selections: LearningFulfiller__selections, opaque: LearningFulfiller__opaque, } = select$S();
     return {
         kind: 'Fragment',
-        version: VERSION$w,
+        version: VERSION$x,
         private: [],
         selections: [
             {
@@ -2640,7 +2640,7 @@ const select$P = function LearningProgramPlanRequirementOutputSelect() {
         ]
     };
 };
-function equals$w(existing, incoming) {
+function equals$x(existing, incoming) {
     const existing_category = existing.category;
     const incoming_category = incoming.category;
     // if at least one of these optionals is defined
@@ -2768,7 +2768,7 @@ function equals$w(existing, incoming) {
             return false;
         }
         const equals_fulfilledBy_items = equalsArray(existing_fulfilledBy, incoming_fulfilledBy, (existing_fulfilledBy_item, incoming_fulfilledBy_item) => {
-            if (!(equals$x(existing_fulfilledBy_item, incoming_fulfilledBy_item))) {
+            if (!(equals$y(existing_fulfilledBy_item, incoming_fulfilledBy_item))) {
                 return false;
             }
         });
@@ -2779,8 +2779,8 @@ function equals$w(existing, incoming) {
     return true;
 }
 
-const VERSION$v = "d7af2bfee148ac8ae983037e910f21ac";
-function validate$T(obj, path = 'LearnerProgramRequirement') {
+const VERSION$w = "d7af2bfee148ac8ae983037e910f21ac";
+function validate$V(obj, path = 'LearnerProgramRequirement') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -2807,7 +2807,7 @@ function validate$T(obj, path = 'LearnerProgramRequirement') {
         if (obj.learningProgramPlanRequirement !== undefined) {
             const obj_learningProgramPlanRequirement = obj.learningProgramPlanRequirement;
             const path_learningProgramPlanRequirement = path + '.learningProgramPlanRequirement';
-            const referencepath_learningProgramPlanRequirementValidationError = validate$U(obj_learningProgramPlanRequirement, path_learningProgramPlanRequirement);
+            const referencepath_learningProgramPlanRequirementValidationError = validate$W(obj_learningProgramPlanRequirement, path_learningProgramPlanRequirement);
             if (referencepath_learningProgramPlanRequirementValidationError !== null) {
                 let message = 'Object doesn\'t match LearningProgramPlanRequirementOutput (at "' + path_learningProgramPlanRequirement + '")\n';
                 message += referencepath_learningProgramPlanRequirementValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -2852,11 +2852,11 @@ function validate$T(obj, path = 'LearnerProgramRequirement') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$O = function LearnerProgramRequirementSelect() {
-    const { selections: LearningProgramPlanRequirementOutput__selections, opaque: LearningProgramPlanRequirementOutput__opaque, } = select$P();
+const select$Q = function LearnerProgramRequirementSelect() {
+    const { selections: LearningProgramPlanRequirementOutput__selections, opaque: LearningProgramPlanRequirementOutput__opaque, } = select$R();
     return {
         kind: 'Fragment',
-        version: VERSION$v,
+        version: VERSION$w,
         private: [],
         selections: [
             {
@@ -2901,7 +2901,7 @@ const select$O = function LearnerProgramRequirementSelect() {
         ]
     };
 };
-function equals$v(existing, incoming) {
+function equals$w(existing, incoming) {
     const existing_description = existing.description;
     const incoming_description = incoming.description;
     // if at least one of these optionals is defined
@@ -2973,7 +2973,7 @@ function equals$v(existing, incoming) {
         if (existing_learningProgramPlanRequirement === undefined || incoming_learningProgramPlanRequirement === undefined) {
             return false;
         }
-        if (!(equals$w(existing_learningProgramPlanRequirement, incoming_learningProgramPlanRequirement))) {
+        if (!(equals$x(existing_learningProgramPlanRequirement, incoming_learningProgramPlanRequirement))) {
             return false;
         }
     }
@@ -2998,8 +2998,8 @@ function equals$v(existing, incoming) {
     return true;
 }
 
-const VERSION$u = "9b999e9822e37e43506982e4548078a0";
-function validate$S(obj, path = 'LearnerProgram') {
+const VERSION$v = "9b999e9822e37e43506982e4548078a0";
+function validate$U(obj, path = 'LearnerProgram') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -3069,7 +3069,7 @@ function validate$S(obj, path = 'LearnerProgram') {
             for (let i = 0; i < obj_requirements.length; i++) {
                 const obj_requirements_item = obj_requirements[i];
                 const path_requirements_item = path_requirements + '[' + i + ']';
-                const referencepath_requirements_itemValidationError = validate$T(obj_requirements_item, path_requirements_item);
+                const referencepath_requirements_itemValidationError = validate$V(obj_requirements_item, path_requirements_item);
                 if (referencepath_requirements_itemValidationError !== null) {
                     let message = 'Object doesn\'t match LearnerProgramRequirement (at "' + path_requirements_item + '")\n';
                     message += referencepath_requirements_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -3094,11 +3094,11 @@ function validate$S(obj, path = 'LearnerProgram') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$N = function LearnerProgramSelect() {
-    const { selections: LearnerProgramRequirement__selections, opaque: LearnerProgramRequirement__opaque, } = select$O();
+const select$P = function LearnerProgramSelect() {
+    const { selections: LearnerProgramRequirement__selections, opaque: LearnerProgramRequirement__opaque, } = select$Q();
     return {
         kind: 'Fragment',
-        version: VERSION$u,
+        version: VERSION$v,
         private: [],
         selections: [
             {
@@ -3164,7 +3164,7 @@ const select$N = function LearnerProgramSelect() {
         ]
     };
 };
-function equals$u(existing, incoming) {
+function equals$v(existing, incoming) {
     const existing_description = existing.description;
     const incoming_description = incoming.description;
     // if at least one of these optionals is defined
@@ -3275,7 +3275,7 @@ function equals$u(existing, incoming) {
             return false;
         }
         const equals_requirements_items = equalsArray(existing_requirements, incoming_requirements, (existing_requirements_item, incoming_requirements_item) => {
-            if (!(equals$v(existing_requirements_item, incoming_requirements_item))) {
+            if (!(equals$w(existing_requirements_item, incoming_requirements_item))) {
                 return false;
             }
         });
@@ -3286,8 +3286,8 @@ function equals$u(existing, incoming) {
     return true;
 }
 
-const VERSION$t = "a14b9073a0ed9a08a5bb2c6ae6d8eac0";
-function validate$R(obj, path = 'LearnerProgressOutputRepresentation') {
+const VERSION$u = "a14b9073a0ed9a08a5bb2c6ae6d8eac0";
+function validate$T(obj, path = 'LearnerProgressOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -3301,7 +3301,7 @@ function validate$R(obj, path = 'LearnerProgressOutputRepresentation') {
             for (let i = 0; i < obj_learnerPrograms.length; i++) {
                 const obj_learnerPrograms_item = obj_learnerPrograms[i];
                 const path_learnerPrograms_item = path_learnerPrograms + '[' + i + ']';
-                const referencepath_learnerPrograms_itemValidationError = validate$S(obj_learnerPrograms_item, path_learnerPrograms_item);
+                const referencepath_learnerPrograms_itemValidationError = validate$U(obj_learnerPrograms_item, path_learnerPrograms_item);
                 if (referencepath_learnerPrograms_itemValidationError !== null) {
                     let message = 'Object doesn\'t match LearnerProgram (at "' + path_learnerPrograms_item + '")\n';
                     message += referencepath_learnerPrograms_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -3312,15 +3312,15 @@ function validate$R(obj, path = 'LearnerProgressOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$g = 'LearnerProgressOutputRepresentation';
-function normalize$g(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$h = 'LearnerProgressOutputRepresentation';
+function normalize$h(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$M = function LearnerProgressOutputRepresentationSelect() {
-    const { selections: LearnerProgram__selections, opaque: LearnerProgram__opaque, } = select$N();
+const select$O = function LearnerProgressOutputRepresentationSelect() {
+    const { selections: LearnerProgram__selections, opaque: LearnerProgram__opaque, } = select$P();
     return {
         kind: 'Fragment',
-        version: VERSION$t,
+        version: VERSION$u,
         private: [],
         selections: [
             {
@@ -3333,7 +3333,7 @@ const select$M = function LearnerProgressOutputRepresentationSelect() {
         ]
     };
 };
-function equals$t(existing, incoming) {
+function equals$u(existing, incoming) {
     const existing_learnerPrograms = existing.learnerPrograms;
     const incoming_learnerPrograms = incoming.learnerPrograms;
     // if at least one of these optionals is defined
@@ -3344,7 +3344,7 @@ function equals$t(existing, incoming) {
             return false;
         }
         const equals_learnerPrograms_items = equalsArray(existing_learnerPrograms, incoming_learnerPrograms, (existing_learnerPrograms_item, incoming_learnerPrograms_item) => {
-            if (!(equals$u(existing_learnerPrograms_item, incoming_learnerPrograms_item))) {
+            if (!(equals$v(existing_learnerPrograms_item, incoming_learnerPrograms_item))) {
                 return false;
             }
         });
@@ -3354,44 +3354,44 @@ function equals$t(existing, incoming) {
     }
     return true;
 }
-const ingest$g = function LearnerProgressOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$h = function LearnerProgressOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$R(input);
+        const validateError = validate$T(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = path.fullPath;
     const ttlToUse = path.ttl !== undefined ? path.ttl : 360000;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$g, "education", VERSION$t, RepresentationType$g, equals$t);
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$h, "education", VERSION$u, RepresentationType$h, equals$u);
     return createLink(key);
 };
-function getTypeCacheKeys$g(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$h(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$g,
+        representationName: RepresentationType$h,
         mergeable: false
     });
 }
 
-function select$L(luvio, params) {
-    return select$M();
+function select$N(luvio, params) {
+    return select$O();
 }
-function keyBuilder$r(luvio, params) {
+function keyBuilder$t(luvio, params) {
     return keyPrefix + '::LearnerProgressOutputRepresentation:(' + 'contactId:' + params.urlParams.contactId + ')';
 }
-function getResponseCacheKeys$i(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$g(storeKeyMap, luvio, response, () => keyBuilder$r(luvio, resourceParams));
+function getResponseCacheKeys$j(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$h(storeKeyMap, luvio, response, () => keyBuilder$t(luvio, resourceParams));
 }
-function ingestSuccess$i(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$j(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$r(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$g, body);
+    const key = keyBuilder$t(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$h, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$L(),
+        node: select$N(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -3402,13 +3402,13 @@ function ingestSuccess$i(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$a(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$r(luvio, params);
+function ingestError$b(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$t(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$i(config) {
+function createResourceRequest$j(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -3422,93 +3422,93 @@ function createResourceRequest$i(config) {
     };
 }
 
-const adapterName$i = 'getLearnerProgress';
+const adapterName$j = 'getLearnerProgress';
 const getLearnerProgress_ConfigPropertyMetadata = [
     generateParamConfigMetadata('contactId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getLearnerProgress_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$i, getLearnerProgress_ConfigPropertyMetadata);
-const createResourceParams$i = /*#__PURE__*/ createResourceParams$n(getLearnerProgress_ConfigPropertyMetadata);
-function keyBuilder$q(luvio, config) {
-    const resourceParams = createResourceParams$i(config);
-    return keyBuilder$r(luvio, resourceParams);
+const getLearnerProgress_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$j, getLearnerProgress_ConfigPropertyMetadata);
+const createResourceParams$j = /*#__PURE__*/ createResourceParams$o(getLearnerProgress_ConfigPropertyMetadata);
+function keyBuilder$s(luvio, config) {
+    const resourceParams = createResourceParams$j(config);
+    return keyBuilder$t(luvio, resourceParams);
 }
-function typeCheckConfig$i(untrustedConfig) {
+function typeCheckConfig$j(untrustedConfig) {
     const config = {};
-    typeCheckConfig$n(untrustedConfig, config, getLearnerProgress_ConfigPropertyMetadata);
+    typeCheckConfig$o(untrustedConfig, config, getLearnerProgress_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$i(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$j(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$i(untrustedConfig);
+    const config = typeCheckConfig$j(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$a(luvio, config) {
-    createResourceParams$i(config);
-    return select$L();
+function adapterFragment$b(luvio, config) {
+    createResourceParams$j(config);
+    return select$N();
 }
-function onFetchResponseSuccess$a(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$i(luvio, resourceParams, response, {
+function onFetchResponseSuccess$b(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$j(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$i(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$j(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$a(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$a(luvio, resourceParams, response, {
+function onFetchResponseError$b(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$b(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$i(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$j(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$i(luvio, config, options) {
-    const resourceParams = createResourceParams$i(config);
-    const request = createResourceRequest$i(resourceParams);
+function buildNetworkSnapshot$j(luvio, config, options) {
+    const resourceParams = createResourceParams$j(config);
+    const request = createResourceRequest$j(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$a(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$b(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$i(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$j(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$a(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$b(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot$i, undefined, false);
+function buildNetworkSnapshotCachePolicy$b(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$g(context, coercedAdapterRequestContext, buildNetworkSnapshot$j, undefined, false);
 }
-function buildCachedSnapshotCachePolicy$a(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$b(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$q(luvio, config),
-        node: adapterFragment$a(luvio, config),
+        recordId: keyBuilder$s(luvio, config),
+        node: adapterFragment$b(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$i(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$j(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getLearnerProgressAdapterFactory = (luvio) => function education__getLearnerProgress(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$i(untrustedConfig, getLearnerProgress_ConfigPropertyNames);
+    const config = validateAdapterConfig$j(untrustedConfig, getLearnerProgress_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$a, buildNetworkSnapshotCachePolicy$a);
+    buildCachedSnapshotCachePolicy$b, buildNetworkSnapshotCachePolicy$b);
 };
 
-function validate$Q(obj, path = 'CreateLearningInputRepresentation') {
+function validate$S(obj, path = 'CreateLearningInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -3592,9 +3592,9 @@ function validate$Q(obj, path = 'CreateLearningInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$5 = 100;
-const VERSION$s = "007261ab77a4c0e4b59ae9c1245e9305";
-function validate$P(obj, path = 'CreateLearningOutputRepresentation') {
+const TTL$6 = 100;
+const VERSION$t = "007261ab77a4c0e4b59ae9c1245e9305";
+function validate$R(obj, path = 'CreateLearningOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -3663,68 +3663,68 @@ function validate$P(obj, path = 'CreateLearningOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$f = 'CreateLearningOutputRepresentation';
-function keyBuilder$p(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$f + ':' + config.id;
+const RepresentationType$g = 'CreateLearningOutputRepresentation';
+function keyBuilder$r(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$g + ':' + config.id;
 }
 function keyBuilderFromType$5(luvio, object) {
     const keyParams = {
         id: object.learningId
     };
-    return keyBuilder$p(luvio, keyParams);
+    return keyBuilder$r(luvio, keyParams);
 }
-function normalize$f(input, existing, path, luvio, store, timestamp) {
+function normalize$g(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$K = function CreateLearningOutputRepresentationSelect() {
+const select$M = function CreateLearningOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$s,
+        version: VERSION$t,
         private: [],
         opaque: true
     };
 };
-function equals$s(existing, incoming) {
+function equals$t(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$f = function CreateLearningOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$g = function CreateLearningOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$P(input);
+        const validateError = validate$R(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = keyBuilderFromType$5(luvio, input);
-    const ttlToUse = TTL$5;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$f, "education", VERSION$s, RepresentationType$f, equals$s);
+    const ttlToUse = TTL$6;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$g, "education", VERSION$t, RepresentationType$g, equals$t);
     return createLink(key);
 };
-function getTypeCacheKeys$f(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$g(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = keyBuilderFromType$5(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$f,
+        representationName: RepresentationType$g,
         mergeable: false
     });
 }
 
-function select$J(luvio, params) {
-    return select$K();
+function select$L(luvio, params) {
+    return select$M();
 }
-function getResponseCacheKeys$h(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$f(storeKeyMap, luvio, response);
+function getResponseCacheKeys$i(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$g(storeKeyMap, luvio, response);
 }
-function ingestSuccess$h(luvio, resourceParams, response) {
+function ingestSuccess$i(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$5(luvio, body);
-    luvio.storeIngest(key, ingest$f, body);
+    luvio.storeIngest(key, ingest$g, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$J(),
+        node: select$L(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -3735,7 +3735,7 @@ function ingestSuccess$h(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$h(config) {
+function createResourceRequest$i(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -3749,45 +3749,45 @@ function createResourceRequest$h(config) {
     };
 }
 
-const adapterName$h = 'postCreateLearning';
+const adapterName$i = 'postCreateLearning';
 const postCreateLearning_ConfigPropertyMetadata = [
     generateParamConfigMetadata('createLearningRecord', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const postCreateLearning_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$h, postCreateLearning_ConfigPropertyMetadata);
-const createResourceParams$h = /*#__PURE__*/ createResourceParams$n(postCreateLearning_ConfigPropertyMetadata);
-function typeCheckConfig$h(untrustedConfig) {
+const postCreateLearning_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$i, postCreateLearning_ConfigPropertyMetadata);
+const createResourceParams$i = /*#__PURE__*/ createResourceParams$o(postCreateLearning_ConfigPropertyMetadata);
+function typeCheckConfig$i(untrustedConfig) {
     const config = {};
     const untrustedConfig_createLearningRecord = untrustedConfig.createLearningRecord;
-    const referenceCreateLearningInputRepresentationValidationError = validate$Q(untrustedConfig_createLearningRecord);
+    const referenceCreateLearningInputRepresentationValidationError = validate$S(untrustedConfig_createLearningRecord);
     if (referenceCreateLearningInputRepresentationValidationError === null) {
         config.createLearningRecord = untrustedConfig_createLearningRecord;
     }
     return config;
 }
-function validateAdapterConfig$h(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$i(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$h(untrustedConfig);
+    const config = typeCheckConfig$i(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$h(luvio, config, options) {
-    const resourceParams = createResourceParams$h(config);
-    const request = createResourceRequest$h(resourceParams);
+function buildNetworkSnapshot$i(luvio, config, options) {
+    const resourceParams = createResourceParams$i(config);
+    const request = createResourceRequest$i(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$h(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$i(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$h(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$i(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -3797,16 +3797,16 @@ function buildNetworkSnapshot$h(luvio, config, options) {
 }
 const postCreateLearningAdapterFactory = (luvio) => {
     return function postCreateLearning(untrustedConfig) {
-        const config = validateAdapterConfig$h(untrustedConfig, postCreateLearning_ConfigPropertyNames);
+        const config = validateAdapterConfig$i(untrustedConfig, postCreateLearning_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "postCreateLearning"');
         }
-        return buildNetworkSnapshot$h(luvio, config);
+        return buildNetworkSnapshot$i(luvio, config);
     };
 };
 
-function validate$O(obj, path = 'UpdateLearningInputRepresentation') {
+function validate$Q(obj, path = 'UpdateLearningInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -3855,19 +3855,19 @@ function validate$O(obj, path = 'UpdateLearningInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function select$I(luvio, params) {
-    return select$K();
+function select$K(luvio, params) {
+    return select$M();
 }
-function getResponseCacheKeys$g(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$f(storeKeyMap, luvio, response);
+function getResponseCacheKeys$h(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$g(storeKeyMap, luvio, response);
 }
-function ingestSuccess$g(luvio, resourceParams, response) {
+function ingestSuccess$h(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$5(luvio, body);
-    luvio.storeIngest(key, ingest$f, body);
+    luvio.storeIngest(key, ingest$g, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$I(),
+        node: select$K(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -3878,7 +3878,7 @@ function ingestSuccess$g(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$g(config) {
+function createResourceRequest$h(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -3892,45 +3892,45 @@ function createResourceRequest$g(config) {
     };
 }
 
-const adapterName$g = 'updateLearning';
+const adapterName$h = 'updateLearning';
 const updateLearning_ConfigPropertyMetadata = [
     generateParamConfigMetadata('updateLearningRecord', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const updateLearning_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$g, updateLearning_ConfigPropertyMetadata);
-const createResourceParams$g = /*#__PURE__*/ createResourceParams$n(updateLearning_ConfigPropertyMetadata);
-function typeCheckConfig$g(untrustedConfig) {
+const updateLearning_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$h, updateLearning_ConfigPropertyMetadata);
+const createResourceParams$h = /*#__PURE__*/ createResourceParams$o(updateLearning_ConfigPropertyMetadata);
+function typeCheckConfig$h(untrustedConfig) {
     const config = {};
     const untrustedConfig_updateLearningRecord = untrustedConfig.updateLearningRecord;
-    const referenceUpdateLearningInputRepresentationValidationError = validate$O(untrustedConfig_updateLearningRecord);
+    const referenceUpdateLearningInputRepresentationValidationError = validate$Q(untrustedConfig_updateLearningRecord);
     if (referenceUpdateLearningInputRepresentationValidationError === null) {
         config.updateLearningRecord = untrustedConfig_updateLearningRecord;
     }
     return config;
 }
-function validateAdapterConfig$g(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$h(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$g(untrustedConfig);
+    const config = typeCheckConfig$h(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$g(luvio, config, options) {
-    const resourceParams = createResourceParams$g(config);
-    const request = createResourceRequest$g(resourceParams);
+function buildNetworkSnapshot$h(luvio, config, options) {
+    const resourceParams = createResourceParams$h(config);
+    const request = createResourceRequest$h(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$g(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$h(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$g(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$h(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -3940,16 +3940,16 @@ function buildNetworkSnapshot$g(luvio, config, options) {
 }
 const updateLearningAdapterFactory = (luvio) => {
     return function updateLearning(untrustedConfig) {
-        const config = validateAdapterConfig$g(untrustedConfig, updateLearning_ConfigPropertyNames);
+        const config = validateAdapterConfig$h(untrustedConfig, updateLearning_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "updateLearning"');
         }
-        return buildNetworkSnapshot$g(luvio, config);
+        return buildNetworkSnapshot$h(luvio, config);
     };
 };
 
-function validate$N(obj, path = 'Requirement') {
+function validate$P(obj, path = 'Requirement') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -3968,7 +3968,7 @@ function validate$N(obj, path = 'Requirement') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$M(obj, path = 'LearningProgramPlanInputRepresentation') {
+function validate$O(obj, path = 'LearningProgramPlanInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -3986,7 +3986,7 @@ function validate$M(obj, path = 'LearningProgramPlanInputRepresentation') {
         for (let i = 0; i < obj_requirement.length; i++) {
             const obj_requirement_item = obj_requirement[i];
             const path_requirement_item = path_requirement + '[' + i + ']';
-            const referencepath_requirement_itemValidationError = validate$N(obj_requirement_item, path_requirement_item);
+            const referencepath_requirement_itemValidationError = validate$P(obj_requirement_item, path_requirement_item);
             if (referencepath_requirement_itemValidationError !== null) {
                 let message = 'Object doesn\'t match Requirement (at "' + path_requirement_item + '")\n';
                 message += referencepath_requirement_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -3997,9 +3997,9 @@ function validate$M(obj, path = 'LearningProgramPlanInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$4 = 100;
-const VERSION$r = "0218a0ed0a2278eb0405096372ffa5de";
-function validate$L(obj, path = 'LearningProgramPlanOutputRepresentation') {
+const TTL$5 = 100;
+const VERSION$s = "0218a0ed0a2278eb0405096372ffa5de";
+function validate$N(obj, path = 'LearningProgramPlanOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4012,68 +4012,68 @@ function validate$L(obj, path = 'LearningProgramPlanOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$e = 'LearningProgramPlanOutputRepresentation';
-function keyBuilder$o(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$e + ':' + config.id;
+const RepresentationType$f = 'LearningProgramPlanOutputRepresentation';
+function keyBuilder$q(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$f + ':' + config.id;
 }
 function keyBuilderFromType$4(luvio, object) {
     const keyParams = {
         id: object.learningProgramPlanId
     };
-    return keyBuilder$o(luvio, keyParams);
+    return keyBuilder$q(luvio, keyParams);
 }
-function normalize$e(input, existing, path, luvio, store, timestamp) {
+function normalize$f(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$H = function LearningProgramPlanOutputRepresentationSelect() {
+const select$J = function LearningProgramPlanOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$r,
+        version: VERSION$s,
         private: [],
         opaque: true
     };
 };
-function equals$r(existing, incoming) {
+function equals$s(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$e = function LearningProgramPlanOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$f = function LearningProgramPlanOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$L(input);
+        const validateError = validate$N(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = keyBuilderFromType$4(luvio, input);
-    const ttlToUse = TTL$4;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$e, "education", VERSION$r, RepresentationType$e, equals$r);
+    const ttlToUse = TTL$5;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$f, "education", VERSION$s, RepresentationType$f, equals$s);
     return createLink(key);
 };
-function getTypeCacheKeys$e(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$f(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = keyBuilderFromType$4(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$e,
+        representationName: RepresentationType$f,
         mergeable: false
     });
 }
 
-function select$G(luvio, params) {
-    return select$H();
+function select$I(luvio, params) {
+    return select$J();
 }
-function getResponseCacheKeys$f(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$e(storeKeyMap, luvio, response);
+function getResponseCacheKeys$g(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$f(storeKeyMap, luvio, response);
 }
-function ingestSuccess$f(luvio, resourceParams, response) {
+function ingestSuccess$g(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$4(luvio, body);
-    luvio.storeIngest(key, ingest$e, body);
+    luvio.storeIngest(key, ingest$f, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$G(),
+        node: select$I(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -4084,7 +4084,7 @@ function ingestSuccess$f(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$f(config) {
+function createResourceRequest$g(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -4098,45 +4098,45 @@ function createResourceRequest$f(config) {
     };
 }
 
-const adapterName$f = 'postPublishLearningProgramPlan';
+const adapterName$g = 'postPublishLearningProgramPlan';
 const postPublishLearningProgramPlan_ConfigPropertyMetadata = [
     generateParamConfigMetadata('publishLearningProgramPlan', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const postPublishLearningProgramPlan_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$f, postPublishLearningProgramPlan_ConfigPropertyMetadata);
-const createResourceParams$f = /*#__PURE__*/ createResourceParams$n(postPublishLearningProgramPlan_ConfigPropertyMetadata);
-function typeCheckConfig$f(untrustedConfig) {
+const postPublishLearningProgramPlan_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$g, postPublishLearningProgramPlan_ConfigPropertyMetadata);
+const createResourceParams$g = /*#__PURE__*/ createResourceParams$o(postPublishLearningProgramPlan_ConfigPropertyMetadata);
+function typeCheckConfig$g(untrustedConfig) {
     const config = {};
     const untrustedConfig_publishLearningProgramPlan = untrustedConfig.publishLearningProgramPlan;
-    const referenceLearningProgramPlanInputRepresentationValidationError = validate$M(untrustedConfig_publishLearningProgramPlan);
+    const referenceLearningProgramPlanInputRepresentationValidationError = validate$O(untrustedConfig_publishLearningProgramPlan);
     if (referenceLearningProgramPlanInputRepresentationValidationError === null) {
         config.publishLearningProgramPlan = untrustedConfig_publishLearningProgramPlan;
     }
     return config;
 }
-function validateAdapterConfig$f(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$g(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$f(untrustedConfig);
+    const config = typeCheckConfig$g(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$f(luvio, config, options) {
-    const resourceParams = createResourceParams$f(config);
-    const request = createResourceRequest$f(resourceParams);
+function buildNetworkSnapshot$g(luvio, config, options) {
+    const resourceParams = createResourceParams$g(config);
+    const request = createResourceRequest$g(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$f(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$g(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$f(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$g(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -4146,17 +4146,17 @@ function buildNetworkSnapshot$f(luvio, config, options) {
 }
 const postPublishLearningProgramPlanAdapterFactory = (luvio) => {
     return function postPublishLearningProgramPlan(untrustedConfig) {
-        const config = validateAdapterConfig$f(untrustedConfig, postPublishLearningProgramPlan_ConfigPropertyNames);
+        const config = validateAdapterConfig$g(untrustedConfig, postPublishLearningProgramPlan_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "postPublishLearningProgramPlan"');
         }
-        return buildNetworkSnapshot$f(luvio, config);
+        return buildNetworkSnapshot$g(luvio, config);
     };
 };
 
-const VERSION$q = "201f86357276cc8ed2ee9d7f51616b64";
-function validate$K(obj, path = 'PreviewLearningProgramPlanOutputRepresentation') {
+const VERSION$r = "201f86357276cc8ed2ee9d7f51616b64";
+function validate$M(obj, path = 'PreviewLearningProgramPlanOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4189,7 +4189,7 @@ function validate$K(obj, path = 'PreviewLearningProgramPlanOutputRepresentation'
             for (let i = 0; i < obj_programPlanRequirements.length; i++) {
                 const obj_programPlanRequirements_item = obj_programPlanRequirements[i];
                 const path_programPlanRequirements_item = path_programPlanRequirements + '[' + i + ']';
-                const referencepath_programPlanRequirements_itemValidationError = validate$U(obj_programPlanRequirements_item, path_programPlanRequirements_item);
+                const referencepath_programPlanRequirements_itemValidationError = validate$W(obj_programPlanRequirements_item, path_programPlanRequirements_item);
                 if (referencepath_programPlanRequirements_itemValidationError !== null) {
                     let message = 'Object doesn\'t match LearningProgramPlanRequirementOutput (at "' + path_programPlanRequirements_item + '")\n';
                     message += referencepath_programPlanRequirements_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -4200,15 +4200,15 @@ function validate$K(obj, path = 'PreviewLearningProgramPlanOutputRepresentation'
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$d = 'PreviewLearningProgramPlanOutputRepresentation';
-function normalize$d(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$e = 'PreviewLearningProgramPlanOutputRepresentation';
+function normalize$e(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$F = function PreviewLearningProgramPlanOutputRepresentationSelect() {
-    const { selections: LearningProgramPlanRequirementOutput__selections, opaque: LearningProgramPlanRequirementOutput__opaque, } = select$P();
+const select$H = function PreviewLearningProgramPlanOutputRepresentationSelect() {
+    const { selections: LearningProgramPlanRequirementOutput__selections, opaque: LearningProgramPlanRequirementOutput__opaque, } = select$R();
     return {
         kind: 'Fragment',
-        version: VERSION$q,
+        version: VERSION$r,
         private: [],
         selections: [
             {
@@ -4235,7 +4235,7 @@ const select$F = function PreviewLearningProgramPlanOutputRepresentationSelect()
         ]
     };
 };
-function equals$q(existing, incoming) {
+function equals$r(existing, incoming) {
     const existing_description = existing.description;
     const incoming_description = incoming.description;
     // if at least one of these optionals is defined
@@ -4277,7 +4277,7 @@ function equals$q(existing, incoming) {
             return false;
         }
         const equals_programPlanRequirements_items = equalsArray(existing_programPlanRequirements, incoming_programPlanRequirements, (existing_programPlanRequirements_item, incoming_programPlanRequirements_item) => {
-            if (!(equals$w(existing_programPlanRequirements_item, incoming_programPlanRequirements_item))) {
+            if (!(equals$x(existing_programPlanRequirements_item, incoming_programPlanRequirements_item))) {
                 return false;
             }
         });
@@ -4287,44 +4287,44 @@ function equals$q(existing, incoming) {
     }
     return true;
 }
-const ingest$d = function PreviewLearningProgramPlanOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$e = function PreviewLearningProgramPlanOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$K(input);
+        const validateError = validate$M(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = path.fullPath;
     const ttlToUse = path.ttl !== undefined ? path.ttl : 360000;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$d, "education", VERSION$q, RepresentationType$d, equals$q);
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$e, "education", VERSION$r, RepresentationType$e, equals$r);
     return createLink(key);
 };
-function getTypeCacheKeys$d(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$e(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$d,
+        representationName: RepresentationType$e,
         mergeable: false
     });
 }
 
-function select$E(luvio, params) {
-    return select$F();
+function select$G(luvio, params) {
+    return select$H();
 }
-function keyBuilder$n(luvio, params) {
+function keyBuilder$p(luvio, params) {
     return keyPrefix + '::PreviewLearningProgramPlanOutputRepresentation:(' + 'learningProgramPlanId:' + params.urlParams.learningProgramPlanId + ')';
 }
-function getResponseCacheKeys$e(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$d(storeKeyMap, luvio, response, () => keyBuilder$n(luvio, resourceParams));
+function getResponseCacheKeys$f(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$e(storeKeyMap, luvio, response, () => keyBuilder$p(luvio, resourceParams));
 }
-function ingestSuccess$e(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$f(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$n(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$d, body);
+    const key = keyBuilder$p(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$e, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$E(),
+        node: select$G(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -4335,13 +4335,13 @@ function ingestSuccess$e(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$9(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$n(luvio, params);
+function ingestError$a(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$p(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$e(config) {
+function createResourceRequest$f(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -4355,93 +4355,93 @@ function createResourceRequest$e(config) {
     };
 }
 
-const adapterName$e = 'getPreviewLearningProgramPlan';
+const adapterName$f = 'getPreviewLearningProgramPlan';
 const getPreviewLearningProgramPlan_ConfigPropertyMetadata = [
     generateParamConfigMetadata('learningProgramPlanId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getPreviewLearningProgramPlan_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$e, getPreviewLearningProgramPlan_ConfigPropertyMetadata);
-const createResourceParams$e = /*#__PURE__*/ createResourceParams$n(getPreviewLearningProgramPlan_ConfigPropertyMetadata);
-function keyBuilder$m(luvio, config) {
-    const resourceParams = createResourceParams$e(config);
-    return keyBuilder$n(luvio, resourceParams);
+const getPreviewLearningProgramPlan_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$f, getPreviewLearningProgramPlan_ConfigPropertyMetadata);
+const createResourceParams$f = /*#__PURE__*/ createResourceParams$o(getPreviewLearningProgramPlan_ConfigPropertyMetadata);
+function keyBuilder$o(luvio, config) {
+    const resourceParams = createResourceParams$f(config);
+    return keyBuilder$p(luvio, resourceParams);
 }
-function typeCheckConfig$e(untrustedConfig) {
+function typeCheckConfig$f(untrustedConfig) {
     const config = {};
-    typeCheckConfig$n(untrustedConfig, config, getPreviewLearningProgramPlan_ConfigPropertyMetadata);
+    typeCheckConfig$o(untrustedConfig, config, getPreviewLearningProgramPlan_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$e(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$f(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$e(untrustedConfig);
+    const config = typeCheckConfig$f(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$9(luvio, config) {
-    createResourceParams$e(config);
-    return select$E();
+function adapterFragment$a(luvio, config) {
+    createResourceParams$f(config);
+    return select$G();
 }
-function onFetchResponseSuccess$9(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$e(luvio, resourceParams, response, {
+function onFetchResponseSuccess$a(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$f(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$e(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$f(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$9(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$9(luvio, resourceParams, response, {
+function onFetchResponseError$a(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$a(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$e(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$f(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$e(luvio, config, options) {
-    const resourceParams = createResourceParams$e(config);
-    const request = createResourceRequest$e(resourceParams);
+function buildNetworkSnapshot$f(luvio, config, options) {
+    const resourceParams = createResourceParams$f(config);
+    const request = createResourceRequest$f(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$9(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$a(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$e(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$f(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$9(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$a(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot$e, undefined, false);
+function buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$g(context, coercedAdapterRequestContext, buildNetworkSnapshot$f, undefined, false);
 }
-function buildCachedSnapshotCachePolicy$9(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$a(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$m(luvio, config),
-        node: adapterFragment$9(luvio, config),
+        recordId: keyBuilder$o(luvio, config),
+        node: adapterFragment$a(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$e(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$f(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getPreviewLearningProgramPlanAdapterFactory = (luvio) => function education__getPreviewLearningProgramPlan(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$e(untrustedConfig, getPreviewLearningProgramPlan_ConfigPropertyNames);
+    const config = validateAdapterConfig$f(untrustedConfig, getPreviewLearningProgramPlan_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$9, buildNetworkSnapshotCachePolicy$9);
+    buildCachedSnapshotCachePolicy$a, buildNetworkSnapshotCachePolicy$a);
 };
 
-function validate$J(obj, path = 'CarePlanTaskInputRepresentation') {
+function validate$L(obj, path = 'CarePlanTaskInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4506,7 +4506,7 @@ function validate$J(obj, path = 'CarePlanTaskInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$I(obj, path = 'BenefitDisbursementForBenefitSessionInputRepresentation') {
+function validate$K(obj, path = 'BenefitDisbursementForBenefitSessionInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4560,7 +4560,7 @@ function validate$I(obj, path = 'BenefitDisbursementForBenefitSessionInputRepres
     return v_error === undefined ? null : v_error;
 }
 
-function validate$H(obj, path = 'BenefitDisbursementListInputRepresentation') {
+function validate$J(obj, path = 'BenefitDisbursementListInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4573,7 +4573,7 @@ function validate$H(obj, path = 'BenefitDisbursementListInputRepresentation') {
         for (let i = 0; i < obj_records.length; i++) {
             const obj_records_item = obj_records[i];
             const path_records_item = path_records + '[' + i + ']';
-            const referencepath_records_itemValidationError = validate$I(obj_records_item, path_records_item);
+            const referencepath_records_itemValidationError = validate$K(obj_records_item, path_records_item);
             if (referencepath_records_itemValidationError !== null) {
                 let message = 'Object doesn\'t match BenefitDisbursementForBenefitSessionInputRepresentation (at "' + path_records_item + '")\n';
                 message += referencepath_records_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -4584,7 +4584,7 @@ function validate$H(obj, path = 'BenefitDisbursementListInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$G(obj, path = 'CustomFieldInputRepresentation') {
+function validate$I(obj, path = 'CustomFieldInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4610,7 +4610,7 @@ function validate$G(obj, path = 'CustomFieldInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$F(obj, path = 'CustomFieldListInputRepresentation') {
+function validate$H(obj, path = 'CustomFieldListInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4623,7 +4623,7 @@ function validate$F(obj, path = 'CustomFieldListInputRepresentation') {
         for (let i = 0; i < obj_records.length; i++) {
             const obj_records_item = obj_records[i];
             const path_records_item = path_records + '[' + i + ']';
-            const referencepath_records_itemValidationError = validate$G(obj_records_item, path_records_item);
+            const referencepath_records_itemValidationError = validate$I(obj_records_item, path_records_item);
             if (referencepath_records_itemValidationError !== null) {
                 let message = 'Object doesn\'t match CustomFieldInputRepresentation (at "' + path_records_item + '")\n';
                 message += referencepath_records_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -4634,7 +4634,7 @@ function validate$F(obj, path = 'CustomFieldListInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$E(obj, path = 'BenefitAssignmentInputRepresentation') {
+function validate$G(obj, path = 'BenefitAssignmentInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4642,7 +4642,7 @@ function validate$E(obj, path = 'BenefitAssignmentInputRepresentation') {
         if (obj.benefitAssignmentTasks !== undefined) {
             const obj_benefitAssignmentTasks = obj.benefitAssignmentTasks;
             const path_benefitAssignmentTasks = path + '.benefitAssignmentTasks';
-            const referencepath_benefitAssignmentTasksValidationError = validate$J(obj_benefitAssignmentTasks, path_benefitAssignmentTasks);
+            const referencepath_benefitAssignmentTasksValidationError = validate$L(obj_benefitAssignmentTasks, path_benefitAssignmentTasks);
             if (referencepath_benefitAssignmentTasksValidationError !== null) {
                 let message = 'Object doesn\'t match CarePlanTaskInputRepresentation (at "' + path_benefitAssignmentTasks + '")\n';
                 message += referencepath_benefitAssignmentTasksValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -4652,7 +4652,7 @@ function validate$E(obj, path = 'BenefitAssignmentInputRepresentation') {
         if (obj.benefitDisbursements !== undefined) {
             const obj_benefitDisbursements = obj.benefitDisbursements;
             const path_benefitDisbursements = path + '.benefitDisbursements';
-            const referencepath_benefitDisbursementsValidationError = validate$H(obj_benefitDisbursements, path_benefitDisbursements);
+            const referencepath_benefitDisbursementsValidationError = validate$J(obj_benefitDisbursements, path_benefitDisbursements);
             if (referencepath_benefitDisbursementsValidationError !== null) {
                 let message = 'Object doesn\'t match BenefitDisbursementListInputRepresentation (at "' + path_benefitDisbursements + '")\n';
                 message += referencepath_benefitDisbursementsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -4674,7 +4674,7 @@ function validate$E(obj, path = 'BenefitAssignmentInputRepresentation') {
         if (obj.customFields !== undefined) {
             const obj_customFields = obj.customFields;
             const path_customFields = path + '.customFields';
-            const referencepath_customFieldsValidationError = validate$F(obj_customFields, path_customFields);
+            const referencepath_customFieldsValidationError = validate$H(obj_customFields, path_customFields);
             if (referencepath_customFieldsValidationError !== null) {
                 let message = 'Object doesn\'t match CustomFieldListInputRepresentation (at "' + path_customFields + '")\n';
                 message += referencepath_customFieldsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -4745,7 +4745,7 @@ function validate$E(obj, path = 'BenefitAssignmentInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$D(obj, path = 'BenefitAssignmentListInputRepresentation') {
+function validate$F(obj, path = 'BenefitAssignmentListInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4758,7 +4758,7 @@ function validate$D(obj, path = 'BenefitAssignmentListInputRepresentation') {
         for (let i = 0; i < obj_records.length; i++) {
             const obj_records_item = obj_records[i];
             const path_records_item = path_records + '[' + i + ']';
-            const referencepath_records_itemValidationError = validate$E(obj_records_item, path_records_item);
+            const referencepath_records_itemValidationError = validate$G(obj_records_item, path_records_item);
             if (referencepath_records_itemValidationError !== null) {
                 let message = 'Object doesn\'t match BenefitAssignmentInputRepresentation (at "' + path_records_item + '")\n';
                 message += referencepath_records_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -4769,7 +4769,7 @@ function validate$D(obj, path = 'BenefitAssignmentListInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$C(obj, path = 'GoalAssignmentInputRepresentation') {
+function validate$E(obj, path = 'GoalAssignmentInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4777,7 +4777,7 @@ function validate$C(obj, path = 'GoalAssignmentInputRepresentation') {
         if (obj.associatedBenefitAssignments !== undefined) {
             const obj_associatedBenefitAssignments = obj.associatedBenefitAssignments;
             const path_associatedBenefitAssignments = path + '.associatedBenefitAssignments';
-            const referencepath_associatedBenefitAssignmentsValidationError = validate$D(obj_associatedBenefitAssignments, path_associatedBenefitAssignments);
+            const referencepath_associatedBenefitAssignmentsValidationError = validate$F(obj_associatedBenefitAssignments, path_associatedBenefitAssignments);
             if (referencepath_associatedBenefitAssignmentsValidationError !== null) {
                 let message = 'Object doesn\'t match BenefitAssignmentListInputRepresentation (at "' + path_associatedBenefitAssignments + '")\n';
                 message += referencepath_associatedBenefitAssignmentsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -4787,7 +4787,7 @@ function validate$C(obj, path = 'GoalAssignmentInputRepresentation') {
         if (obj.associatedSubGoalAssignments !== undefined) {
             const obj_associatedSubGoalAssignments = obj.associatedSubGoalAssignments;
             const path_associatedSubGoalAssignments = path + '.associatedSubGoalAssignments';
-            const referencepath_associatedSubGoalAssignmentsValidationError = validate$B(obj_associatedSubGoalAssignments, path_associatedSubGoalAssignments);
+            const referencepath_associatedSubGoalAssignmentsValidationError = validate$D(obj_associatedSubGoalAssignments, path_associatedSubGoalAssignments);
             if (referencepath_associatedSubGoalAssignmentsValidationError !== null) {
                 let message = 'Object doesn\'t match GoalAssignmentListInputRepresentation (at "' + path_associatedSubGoalAssignments + '")\n';
                 message += referencepath_associatedSubGoalAssignmentsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -4807,7 +4807,7 @@ function validate$C(obj, path = 'GoalAssignmentInputRepresentation') {
         if (obj.customFields !== undefined) {
             const obj_customFields = obj.customFields;
             const path_customFields = path + '.customFields';
-            const referencepath_customFieldsValidationError = validate$F(obj_customFields, path_customFields);
+            const referencepath_customFieldsValidationError = validate$H(obj_customFields, path_customFields);
             if (referencepath_customFieldsValidationError !== null) {
                 let message = 'Object doesn\'t match CustomFieldListInputRepresentation (at "' + path_customFields + '")\n';
                 message += referencepath_customFieldsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -4831,7 +4831,7 @@ function validate$C(obj, path = 'GoalAssignmentInputRepresentation') {
         if (obj.goalAssignmentTasks !== undefined) {
             const obj_goalAssignmentTasks = obj.goalAssignmentTasks;
             const path_goalAssignmentTasks = path + '.goalAssignmentTasks';
-            const referencepath_goalAssignmentTasksValidationError = validate$J(obj_goalAssignmentTasks, path_goalAssignmentTasks);
+            const referencepath_goalAssignmentTasksValidationError = validate$L(obj_goalAssignmentTasks, path_goalAssignmentTasks);
             if (referencepath_goalAssignmentTasksValidationError !== null) {
                 let message = 'Object doesn\'t match CarePlanTaskInputRepresentation (at "' + path_goalAssignmentTasks + '")\n';
                 message += referencepath_goalAssignmentTasksValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -4882,7 +4882,7 @@ function validate$C(obj, path = 'GoalAssignmentInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$B(obj, path = 'GoalAssignmentListInputRepresentation') {
+function validate$D(obj, path = 'GoalAssignmentListInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4895,7 +4895,7 @@ function validate$B(obj, path = 'GoalAssignmentListInputRepresentation') {
         for (let i = 0; i < obj_records.length; i++) {
             const obj_records_item = obj_records[i];
             const path_records_item = path_records + '[' + i + ']';
-            const referencepath_records_itemValidationError = validate$C(obj_records_item, path_records_item);
+            const referencepath_records_itemValidationError = validate$E(obj_records_item, path_records_item);
             if (referencepath_records_itemValidationError !== null) {
                 let message = 'Object doesn\'t match GoalAssignmentInputRepresentation (at "' + path_records_item + '")\n';
                 message += referencepath_records_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -4906,7 +4906,7 @@ function validate$B(obj, path = 'GoalAssignmentListInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$A(obj, path = 'CarePlanInputRepresentation') {
+function validate$C(obj, path = 'CarePlanInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4914,7 +4914,7 @@ function validate$A(obj, path = 'CarePlanInputRepresentation') {
         if (obj.benefitAssignments !== undefined) {
             const obj_benefitAssignments = obj.benefitAssignments;
             const path_benefitAssignments = path + '.benefitAssignments';
-            const referencepath_benefitAssignmentsValidationError = validate$D(obj_benefitAssignments, path_benefitAssignments);
+            const referencepath_benefitAssignmentsValidationError = validate$F(obj_benefitAssignments, path_benefitAssignments);
             if (referencepath_benefitAssignmentsValidationError !== null) {
                 let message = 'Object doesn\'t match BenefitAssignmentListInputRepresentation (at "' + path_benefitAssignments + '")\n';
                 message += referencepath_benefitAssignmentsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -4924,7 +4924,7 @@ function validate$A(obj, path = 'CarePlanInputRepresentation') {
         if (obj.carePlanTasks !== undefined) {
             const obj_carePlanTasks = obj.carePlanTasks;
             const path_carePlanTasks = path + '.carePlanTasks';
-            const referencepath_carePlanTasksValidationError = validate$J(obj_carePlanTasks, path_carePlanTasks);
+            const referencepath_carePlanTasksValidationError = validate$L(obj_carePlanTasks, path_carePlanTasks);
             if (referencepath_carePlanTasksValidationError !== null) {
                 let message = 'Object doesn\'t match CarePlanTaskInputRepresentation (at "' + path_carePlanTasks + '")\n';
                 message += referencepath_carePlanTasksValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -4946,7 +4946,7 @@ function validate$A(obj, path = 'CarePlanInputRepresentation') {
         if (obj.customFields !== undefined) {
             const obj_customFields = obj.customFields;
             const path_customFields = path + '.customFields';
-            const referencepath_customFieldsValidationError = validate$F(obj_customFields, path_customFields);
+            const referencepath_customFieldsValidationError = validate$H(obj_customFields, path_customFields);
             if (referencepath_customFieldsValidationError !== null) {
                 let message = 'Object doesn\'t match CustomFieldListInputRepresentation (at "' + path_customFields + '")\n';
                 message += referencepath_customFieldsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -4970,7 +4970,7 @@ function validate$A(obj, path = 'CarePlanInputRepresentation') {
         if (obj.goalAssignments !== undefined) {
             const obj_goalAssignments = obj.goalAssignments;
             const path_goalAssignments = path + '.goalAssignments';
-            const referencepath_goalAssignmentsValidationError = validate$B(obj_goalAssignments, path_goalAssignments);
+            const referencepath_goalAssignmentsValidationError = validate$D(obj_goalAssignments, path_goalAssignments);
             if (referencepath_goalAssignmentsValidationError !== null) {
                 let message = 'Object doesn\'t match GoalAssignmentListInputRepresentation (at "' + path_goalAssignments + '")\n';
                 message += referencepath_goalAssignmentsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -5017,7 +5017,7 @@ function validate$A(obj, path = 'CarePlanInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$z(obj, path = 'CarePlanListInputRepresentation') {
+function validate$B(obj, path = 'CarePlanListInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5030,7 +5030,7 @@ function validate$z(obj, path = 'CarePlanListInputRepresentation') {
         for (let i = 0; i < obj_records.length; i++) {
             const obj_records_item = obj_records[i];
             const path_records_item = path_records + '[' + i + ']';
-            const referencepath_records_itemValidationError = validate$A(obj_records_item, path_records_item);
+            const referencepath_records_itemValidationError = validate$C(obj_records_item, path_records_item);
             if (referencepath_records_itemValidationError !== null) {
                 let message = 'Object doesn\'t match CarePlanInputRepresentation (at "' + path_records_item + '")\n';
                 message += referencepath_records_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -5041,14 +5041,14 @@ function validate$z(obj, path = 'CarePlanListInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$y(obj, path = 'CarePlanBulkInputRepresentation') {
+function validate$A(obj, path = 'CarePlanBulkInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
         }
         const obj_carePlans = obj.carePlans;
         const path_carePlans = path + '.carePlans';
-        const referencepath_carePlansValidationError = validate$z(obj_carePlans, path_carePlans);
+        const referencepath_carePlansValidationError = validate$B(obj_carePlans, path_carePlans);
         if (referencepath_carePlansValidationError !== null) {
             let message = 'Object doesn\'t match CarePlanListInputRepresentation (at "' + path_carePlans + '")\n';
             message += referencepath_carePlansValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -5058,9 +5058,9 @@ function validate$y(obj, path = 'CarePlanBulkInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$3 = 100;
-const VERSION$p = "83a45266096a71720e9049cb0f0477d6";
-function validate$x(obj, path = 'CarePlanBulkOutputRepresentation') {
+const TTL$4 = 100;
+const VERSION$q = "83a45266096a71720e9049cb0f0477d6";
+function validate$z(obj, path = 'CarePlanBulkOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5087,68 +5087,68 @@ function validate$x(obj, path = 'CarePlanBulkOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$c = 'CarePlanBulkOutputRepresentation';
-function keyBuilder$l(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$c + ':' + config.id;
+const RepresentationType$d = 'CarePlanBulkOutputRepresentation';
+function keyBuilder$n(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$d + ':' + config.id;
 }
 function keyBuilderFromType$3(luvio, object) {
     const keyParams = {
         id: object.statusCode
     };
-    return keyBuilder$l(luvio, keyParams);
+    return keyBuilder$n(luvio, keyParams);
 }
-function normalize$c(input, existing, path, luvio, store, timestamp) {
+function normalize$d(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$D = function CarePlanBulkOutputRepresentationSelect() {
+const select$F = function CarePlanBulkOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$p,
+        version: VERSION$q,
         private: [],
         opaque: true
     };
 };
-function equals$p(existing, incoming) {
+function equals$q(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$c = function CarePlanBulkOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$d = function CarePlanBulkOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$x(input);
+        const validateError = validate$z(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = keyBuilderFromType$3(luvio, input);
-    const ttlToUse = TTL$3;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$c, "education", VERSION$p, RepresentationType$c, equals$p);
+    const ttlToUse = TTL$4;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$d, "education", VERSION$q, RepresentationType$d, equals$q);
     return createLink(key);
 };
-function getTypeCacheKeys$c(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$d(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = keyBuilderFromType$3(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$c,
+        representationName: RepresentationType$d,
         mergeable: false
     });
 }
 
-function select$C(luvio, params) {
-    return select$D();
+function select$E(luvio, params) {
+    return select$F();
 }
-function getResponseCacheKeys$d(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$c(storeKeyMap, luvio, response);
+function getResponseCacheKeys$e(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$d(storeKeyMap, luvio, response);
 }
-function ingestSuccess$d(luvio, resourceParams, response) {
+function ingestSuccess$e(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$3(luvio, body);
-    luvio.storeIngest(key, ingest$c, body);
+    luvio.storeIngest(key, ingest$d, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$C(),
+        node: select$E(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -5159,7 +5159,7 @@ function ingestSuccess$d(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$d(config) {
+function createResourceRequest$e(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -5173,45 +5173,45 @@ function createResourceRequest$d(config) {
     };
 }
 
-const adapterName$d = 'createCarePlans';
+const adapterName$e = 'createCarePlans';
 const createCarePlans_ConfigPropertyMetadata = [
     generateParamConfigMetadata('carePlanBulkRecord', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const createCarePlans_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$d, createCarePlans_ConfigPropertyMetadata);
-const createResourceParams$d = /*#__PURE__*/ createResourceParams$n(createCarePlans_ConfigPropertyMetadata);
-function typeCheckConfig$d(untrustedConfig) {
+const createCarePlans_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$e, createCarePlans_ConfigPropertyMetadata);
+const createResourceParams$e = /*#__PURE__*/ createResourceParams$o(createCarePlans_ConfigPropertyMetadata);
+function typeCheckConfig$e(untrustedConfig) {
     const config = {};
     const untrustedConfig_carePlanBulkRecord = untrustedConfig.carePlanBulkRecord;
-    const referenceCarePlanBulkInputRepresentationValidationError = validate$y(untrustedConfig_carePlanBulkRecord);
+    const referenceCarePlanBulkInputRepresentationValidationError = validate$A(untrustedConfig_carePlanBulkRecord);
     if (referenceCarePlanBulkInputRepresentationValidationError === null) {
         config.carePlanBulkRecord = untrustedConfig_carePlanBulkRecord;
     }
     return config;
 }
-function validateAdapterConfig$d(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$e(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$d(untrustedConfig);
+    const config = typeCheckConfig$e(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$d(luvio, config, options) {
-    const resourceParams = createResourceParams$d(config);
-    const request = createResourceRequest$d(resourceParams);
+function buildNetworkSnapshot$e(luvio, config, options) {
+    const resourceParams = createResourceParams$e(config);
+    const request = createResourceRequest$e(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$d(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$e(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$d(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$e(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -5221,16 +5221,16 @@ function buildNetworkSnapshot$d(luvio, config, options) {
 }
 const createCarePlansAdapterFactory = (luvio) => {
     return function createCarePlans(untrustedConfig) {
-        const config = validateAdapterConfig$d(untrustedConfig, createCarePlans_ConfigPropertyNames);
+        const config = validateAdapterConfig$e(untrustedConfig, createCarePlans_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createCarePlans"');
         }
-        return buildNetworkSnapshot$d(luvio, config);
+        return buildNetworkSnapshot$e(luvio, config);
     };
 };
 
-function validate$w(obj, path = 'MentoringBenefitAssignment') {
+function validate$y(obj, path = 'MentoringBenefitAssignment') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5391,15 +5391,15 @@ function validate$w(obj, path = 'MentoringBenefitAssignment') {
     return v_error === undefined ? null : v_error;
 }
 
-const VERSION$o = "4056cc46e5eff095d36ae486ac5908bc";
-function validate$v(obj, path = 'MentoringBenefitAssignmentOutputRepresentation') {
+const VERSION$p = "4056cc46e5eff095d36ae486ac5908bc";
+function validate$x(obj, path = 'MentoringBenefitAssignmentOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
         }
         const obj_mentoringBenefitAssignment = obj.mentoringBenefitAssignment;
         const path_mentoringBenefitAssignment = path + '.mentoringBenefitAssignment';
-        const referencepath_mentoringBenefitAssignmentValidationError = validate$w(obj_mentoringBenefitAssignment, path_mentoringBenefitAssignment);
+        const referencepath_mentoringBenefitAssignmentValidationError = validate$y(obj_mentoringBenefitAssignment, path_mentoringBenefitAssignment);
         if (referencepath_mentoringBenefitAssignmentValidationError !== null) {
             let message = 'Object doesn\'t match MentoringBenefitAssignment (at "' + path_mentoringBenefitAssignment + '")\n';
             message += referencepath_mentoringBenefitAssignmentValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -5408,68 +5408,68 @@ function validate$v(obj, path = 'MentoringBenefitAssignmentOutputRepresentation'
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$b = 'MentoringBenefitAssignmentOutputRepresentation';
-function keyBuilder$k(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$b + ':' + config.id;
+const RepresentationType$c = 'MentoringBenefitAssignmentOutputRepresentation';
+function keyBuilder$m(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$c + ':' + config.id;
 }
 function keyBuilderFromType$2(luvio, object) {
     const keyParams = {
         id: object.mentoringBenefitAssignment.id
     };
-    return keyBuilder$k(luvio, keyParams);
+    return keyBuilder$m(luvio, keyParams);
 }
-function normalize$b(input, existing, path, luvio, store, timestamp) {
+function normalize$c(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$B = function MentoringBenefitAssignmentOutputRepresentationSelect() {
+const select$D = function MentoringBenefitAssignmentOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$o,
+        version: VERSION$p,
         private: [],
         opaque: true
     };
 };
-function equals$o(existing, incoming) {
+function equals$p(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$b = function MentoringBenefitAssignmentOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$c = function MentoringBenefitAssignmentOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$v(input);
+        const validateError = validate$x(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = keyBuilderFromType$2(luvio, input);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 360000;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$b, "education", VERSION$o, RepresentationType$b, equals$o);
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$c, "education", VERSION$p, RepresentationType$c, equals$p);
     return createLink(key);
 };
-function getTypeCacheKeys$b(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$c(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = keyBuilderFromType$2(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$b,
+        representationName: RepresentationType$c,
         mergeable: false
     });
 }
 
-function select$A(luvio, params) {
-    return select$B();
+function select$C(luvio, params) {
+    return select$D();
 }
-function getResponseCacheKeys$c(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$b(storeKeyMap, luvio, response);
+function getResponseCacheKeys$d(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$c(storeKeyMap, luvio, response);
 }
-function ingestSuccess$c(luvio, resourceParams, response) {
+function ingestSuccess$d(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$2(luvio, body);
-    luvio.storeIngest(key, ingest$b, body);
+    luvio.storeIngest(key, ingest$c, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$A(),
+        node: select$C(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -5480,7 +5480,7 @@ function ingestSuccess$c(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$c(config) {
+function createResourceRequest$d(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -5494,42 +5494,42 @@ function createResourceRequest$c(config) {
     };
 }
 
-const adapterName$c = 'postBenefitAssignment';
+const adapterName$d = 'postBenefitAssignment';
 const postBenefitAssignment_ConfigPropertyMetadata = [
     generateParamConfigMetadata('benefitAssignmentId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('providerId', true, 2 /* Body */, 0 /* String */),
 ];
-const postBenefitAssignment_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$c, postBenefitAssignment_ConfigPropertyMetadata);
-const createResourceParams$c = /*#__PURE__*/ createResourceParams$n(postBenefitAssignment_ConfigPropertyMetadata);
-function typeCheckConfig$c(untrustedConfig) {
+const postBenefitAssignment_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$d, postBenefitAssignment_ConfigPropertyMetadata);
+const createResourceParams$d = /*#__PURE__*/ createResourceParams$o(postBenefitAssignment_ConfigPropertyMetadata);
+function typeCheckConfig$d(untrustedConfig) {
     const config = {};
-    typeCheckConfig$n(untrustedConfig, config, postBenefitAssignment_ConfigPropertyMetadata);
+    typeCheckConfig$o(untrustedConfig, config, postBenefitAssignment_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$c(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$d(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$c(untrustedConfig);
+    const config = typeCheckConfig$d(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$c(luvio, config, options) {
-    const resourceParams = createResourceParams$c(config);
-    const request = createResourceRequest$c(resourceParams);
+function buildNetworkSnapshot$d(luvio, config, options) {
+    const resourceParams = createResourceParams$d(config);
+    const request = createResourceRequest$d(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$c(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$d(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$c(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$d(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -5539,16 +5539,16 @@ function buildNetworkSnapshot$c(luvio, config, options) {
 }
 const postBenefitAssignmentAdapterFactory = (luvio) => {
     return function postBenefitAssignment(untrustedConfig) {
-        const config = validateAdapterConfig$c(untrustedConfig, postBenefitAssignment_ConfigPropertyNames);
+        const config = validateAdapterConfig$d(untrustedConfig, postBenefitAssignment_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "postBenefitAssignment"');
         }
-        return buildNetworkSnapshot$c(luvio, config);
+        return buildNetworkSnapshot$d(luvio, config);
     };
 };
 
-function validate$u(obj, path = 'FilterConfig') {
+function validate$w(obj, path = 'FilterConfig') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5584,8 +5584,8 @@ function validate$u(obj, path = 'FilterConfig') {
     return v_error === undefined ? null : v_error;
 }
 
-const VERSION$n = "21bdda1d3836a2c358ee187ea8dee2b2";
-function validate$t(obj, path = 'MentoringProfileOption') {
+const VERSION$o = "21bdda1d3836a2c358ee187ea8dee2b2";
+function validate$v(obj, path = 'MentoringProfileOption') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5598,10 +5598,10 @@ function validate$t(obj, path = 'MentoringProfileOption') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$z = function MentoringProfileOptionSelect() {
+const select$B = function MentoringProfileOptionSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$n,
+        version: VERSION$o,
         private: [],
         selections: [
             {
@@ -5611,7 +5611,7 @@ const select$z = function MentoringProfileOptionSelect() {
         ]
     };
 };
-function equals$n(existing, incoming) {
+function equals$o(existing, incoming) {
     const existing_id = existing.id;
     const incoming_id = incoming.id;
     if (!(existing_id === incoming_id)) {
@@ -5620,9 +5620,9 @@ function equals$n(existing, incoming) {
     return true;
 }
 
-const TTL$2 = 500;
-const VERSION$m = "33fcd02404150683fc2b8c66cd715130";
-function validate$s(obj, path = 'MentoringMatchingSelectorOutputRepresentation') {
+const TTL$3 = 500;
+const VERSION$n = "33fcd02404150683fc2b8c66cd715130";
+function validate$u(obj, path = 'MentoringMatchingSelectorOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5635,7 +5635,7 @@ function validate$s(obj, path = 'MentoringMatchingSelectorOutputRepresentation')
         for (let i = 0; i < obj_mentoringProfiles.length; i++) {
             const obj_mentoringProfiles_item = obj_mentoringProfiles[i];
             const path_mentoringProfiles_item = path_mentoringProfiles + '[' + i + ']';
-            const referencepath_mentoringProfiles_itemValidationError = validate$t(obj_mentoringProfiles_item, path_mentoringProfiles_item);
+            const referencepath_mentoringProfiles_itemValidationError = validate$v(obj_mentoringProfiles_item, path_mentoringProfiles_item);
             if (referencepath_mentoringProfiles_itemValidationError !== null) {
                 let message = 'Object doesn\'t match MentoringProfileOption (at "' + path_mentoringProfiles_item + '")\n';
                 message += referencepath_mentoringProfiles_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -5645,15 +5645,15 @@ function validate$s(obj, path = 'MentoringMatchingSelectorOutputRepresentation')
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$a = 'MentoringMatchingSelectorOutputRepresentation';
-function normalize$a(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$b = 'MentoringMatchingSelectorOutputRepresentation';
+function normalize$b(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$y = function MentoringMatchingSelectorOutputRepresentationSelect() {
-    const { selections: MentoringProfileOption__selections, opaque: MentoringProfileOption__opaque, } = select$z();
+const select$A = function MentoringMatchingSelectorOutputRepresentationSelect() {
+    const { selections: MentoringProfileOption__selections, opaque: MentoringProfileOption__opaque, } = select$B();
     return {
         kind: 'Fragment',
-        version: VERSION$m,
+        version: VERSION$n,
         private: [],
         selections: [
             {
@@ -5665,11 +5665,11 @@ const select$y = function MentoringMatchingSelectorOutputRepresentationSelect()
         ]
     };
 };
-function equals$m(existing, incoming) {
+function equals$n(existing, incoming) {
     const existing_mentoringProfiles = existing.mentoringProfiles;
     const incoming_mentoringProfiles = incoming.mentoringProfiles;
     const equals_mentoringProfiles_items = equalsArray(existing_mentoringProfiles, incoming_mentoringProfiles, (existing_mentoringProfiles_item, incoming_mentoringProfiles_item) => {
-        if (!(equals$n(existing_mentoringProfiles_item, incoming_mentoringProfiles_item))) {
+        if (!(equals$o(existing_mentoringProfiles_item, incoming_mentoringProfiles_item))) {
             return false;
         }
     });
@@ -5678,7 +5678,248 @@ function equals$m(existing, incoming) {
     }
     return true;
 }
-const ingest$a = function MentoringMatchingSelectorOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$b = function MentoringMatchingSelectorOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$u(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = path.fullPath;
+    const ttlToUse = TTL$3;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$b, "education", VERSION$n, RepresentationType$b, equals$n);
+    return createLink(key);
+};
+function getTypeCacheKeys$b(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = fullPathFactory();
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$b,
+        mergeable: false
+    });
+}
+
+function select$z(luvio, params) {
+    return select$A();
+}
+function keyBuilder$l(luvio, params) {
+    return keyPrefix + '::MentoringMatchingSelectorOutputRepresentation:(' + 'benefitAssignmentId:' + params.urlParams.benefitAssignmentId + ',' + '[' + params.body.filtersConfig.map(element => 'filtersConfig.apiName:' + element.apiName + '::' + 'filtersConfig.fieldType:' + element.fieldType + '::' + 'filtersConfig.operator:' + element.operator + '::' + 'filtersConfig.filterValue:' + element.filterValue).join(',') + ']' + ')';
+}
+function getResponseCacheKeys$c(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$b(storeKeyMap, luvio, response, () => keyBuilder$l(luvio, resourceParams));
+}
+function ingestSuccess$c(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$l(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$b, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$z(),
+        variables: {},
+    }, snapshotRefresh);
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
+}
+function ingestError$9(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$l(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    const storeMetadataParams = {
+        ttl: TTL$3,
+        namespace: keyPrefix,
+        version: VERSION$n,
+        representationName: RepresentationType$b
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
+function createResourceRequest$c(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v62.0',
+        basePath: '/connect/education/mentoring/matching-selector/' + config.urlParams.benefitAssignmentId + '',
+        method: 'post',
+        body: config.body,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$c = 'postMatchingSelector';
+const postMatchingSelector_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('benefitAssignmentId', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('filtersConfig', true, 2 /* Body */, 4 /* Unsupported */, true),
+];
+const postMatchingSelector_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$c, postMatchingSelector_ConfigPropertyMetadata);
+const createResourceParams$c = /*#__PURE__*/ createResourceParams$o(postMatchingSelector_ConfigPropertyMetadata);
+function keyBuilder$k(luvio, config) {
+    const resourceParams = createResourceParams$c(config);
+    return keyBuilder$l(luvio, resourceParams);
+}
+function typeCheckConfig$c(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$o(untrustedConfig, config, postMatchingSelector_ConfigPropertyMetadata);
+    const untrustedConfig_filtersConfig = untrustedConfig.filtersConfig;
+    if (ArrayIsArray$1(untrustedConfig_filtersConfig)) {
+        const untrustedConfig_filtersConfig_array = [];
+        for (let i = 0, arrayLength = untrustedConfig_filtersConfig.length; i < arrayLength; i++) {
+            const untrustedConfig_filtersConfig_item = untrustedConfig_filtersConfig[i];
+            const referenceFilterConfigValidationError = validate$w(untrustedConfig_filtersConfig_item);
+            if (referenceFilterConfigValidationError === null) {
+                untrustedConfig_filtersConfig_array.push(untrustedConfig_filtersConfig_item);
+            }
+        }
+        config.filtersConfig = untrustedConfig_filtersConfig_array;
+    }
+    return config;
+}
+function validateAdapterConfig$c(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$c(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment$9(luvio, config) {
+    createResourceParams$c(config);
+    return select$z();
+}
+function onFetchResponseSuccess$9(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$c(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$c(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError$9(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$9(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$c(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$c(luvio, config, options) {
+    const resourceParams = createResourceParams$c(config);
+    const request = createResourceRequest$c(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$9(luvio, config, resourceParams, response), () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$c(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$9(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$g(context, coercedAdapterRequestContext, buildNetworkSnapshot$c, 'get', false);
+}
+function buildCachedSnapshotCachePolicy$9(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$k(luvio, config),
+        node: adapterFragment$9(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$c(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const postMatchingSelectorAdapterFactory = (luvio) => function education__postMatchingSelector(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$c(untrustedConfig, postMatchingSelector_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$9, buildNetworkSnapshotCachePolicy$9);
+};
+
+function validate$t(obj, path = 'PromptTemplate') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.id !== undefined) {
+            const obj_id = obj.id;
+            const path_id = path + '.id';
+            if (typeof obj_id !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_id + '" (at "' + path_id + '")');
+            }
+        }
+        if (obj.name !== undefined) {
+            const obj_name = obj.name;
+            const path_name = path + '.name';
+            if (typeof obj_name !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+const TTL$2 = 100;
+const VERSION$m = "a4f2950496cf124eea76894ec3679162";
+function validate$s(obj, path = 'PromptTemplateOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.promptTemplates !== undefined) {
+            const obj_promptTemplates = obj.promptTemplates;
+            const path_promptTemplates = path + '.promptTemplates';
+            if (!ArrayIsArray(obj_promptTemplates)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_promptTemplates + '" (at "' + path_promptTemplates + '")');
+            }
+            for (let i = 0; i < obj_promptTemplates.length; i++) {
+                const obj_promptTemplates_item = obj_promptTemplates[i];
+                const path_promptTemplates_item = path_promptTemplates + '[' + i + ']';
+                const referencepath_promptTemplates_itemValidationError = validate$t(obj_promptTemplates_item, path_promptTemplates_item);
+                if (referencepath_promptTemplates_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match PromptTemplate (at "' + path_promptTemplates_item + '")\n';
+                    message += referencepath_promptTemplates_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$a = 'PromptTemplateOutputRepresentation';
+function normalize$a(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$y = function PromptTemplateOutputRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$m,
+        private: [],
+        opaque: true
+    };
+};
+function equals$m(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
+const ingest$a = function PromptTemplateOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$s(input);
         if (validateError !== null) {
@@ -5704,7 +5945,7 @@ function select$x(luvio, params) {
     return select$y();
 }
 function keyBuilder$j(luvio, params) {
-    return keyPrefix + '::MentoringMatchingSelectorOutputRepresentation:(' + 'benefitAssignmentId:' + params.urlParams.benefitAssignmentId + ',' + '[' + params.body.filtersConfig.map(element => 'filtersConfig.apiName:' + element.apiName + '::' + 'filtersConfig.fieldType:' + element.fieldType + '::' + 'filtersConfig.operator:' + element.operator + '::' + 'filtersConfig.filterValue:' + element.filterValue).join(',') + ']' + ')';
+    return keyPrefix + '::PromptTemplateOutputRepresentation:(' + 'objectName:' + params.body.objectName + '::' + 'promptType:' + params.body.promptType + ')';
 }
 function getResponseCacheKeys$b(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$a(storeKeyMap, luvio, response, () => keyBuilder$j(luvio, resourceParams));
@@ -5742,42 +5983,30 @@ function createResourceRequest$b(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/connect/education/mentoring/matching-selector/' + config.urlParams.benefitAssignmentId + '',
+        basePath: '/connect/education/prompt-builder/prompt-templates',
         method: 'post',
         body: config.body,
-        urlParams: config.urlParams,
+        urlParams: {},
         queryParams: {},
         headers,
         priority: 'normal',
     };
 }
 
-const adapterName$b = 'postMatchingSelector';
-const postMatchingSelector_ConfigPropertyMetadata = [
-    generateParamConfigMetadata('benefitAssignmentId', true, 0 /* UrlParameter */, 0 /* String */),
-    generateParamConfigMetadata('filtersConfig', true, 2 /* Body */, 4 /* Unsupported */, true),
+const adapterName$b = 'getPromptTemplates';
+const getPromptTemplates_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('objectName', true, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('promptType', true, 2 /* Body */, 0 /* String */),
 ];
-const postMatchingSelector_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$b, postMatchingSelector_ConfigPropertyMetadata);
-const createResourceParams$b = /*#__PURE__*/ createResourceParams$n(postMatchingSelector_ConfigPropertyMetadata);
+const getPromptTemplates_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$b, getPromptTemplates_ConfigPropertyMetadata);
+const createResourceParams$b = /*#__PURE__*/ createResourceParams$o(getPromptTemplates_ConfigPropertyMetadata);
 function keyBuilder$i(luvio, config) {
     const resourceParams = createResourceParams$b(config);
     return keyBuilder$j(luvio, resourceParams);
 }
 function typeCheckConfig$b(untrustedConfig) {
     const config = {};
-    typeCheckConfig$n(untrustedConfig, config, postMatchingSelector_ConfigPropertyMetadata);
-    const untrustedConfig_filtersConfig = untrustedConfig.filtersConfig;
-    if (ArrayIsArray$1(untrustedConfig_filtersConfig)) {
-        const untrustedConfig_filtersConfig_array = [];
-        for (let i = 0, arrayLength = untrustedConfig_filtersConfig.length; i < arrayLength; i++) {
-            const untrustedConfig_filtersConfig_item = untrustedConfig_filtersConfig[i];
-            const referenceFilterConfigValidationError = validate$u(untrustedConfig_filtersConfig_item);
-            if (referenceFilterConfigValidationError === null) {
-                untrustedConfig_filtersConfig_array.push(untrustedConfig_filtersConfig_item);
-            }
-        }
-        config.filtersConfig = untrustedConfig_filtersConfig_array;
-    }
+    typeCheckConfig$o(untrustedConfig, config, getPromptTemplates_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$b(untrustedConfig, configPropertyNames) {
@@ -5826,7 +6055,7 @@ function buildNetworkSnapshot$b(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot$b, 'get', false);
+    return buildNetworkSnapshotCachePolicy$g(context, coercedAdapterRequestContext, buildNetworkSnapshot$b, 'get', false);
 }
 function buildCachedSnapshotCachePolicy$8(context, storeLookup) {
     const { luvio, config } = context;
@@ -5841,8 +6070,8 @@ function buildCachedSnapshotCachePolicy$8(context, storeLookup) {
     });
     return cacheSnapshot;
 }
-const postMatchingSelectorAdapterFactory = (luvio) => function education__postMatchingSelector(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$b(untrustedConfig, postMatchingSelector_ConfigPropertyNames);
+const getPromptTemplatesAdapterFactory = (luvio) => function education__getPromptTemplates(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$b(untrustedConfig, getPromptTemplates_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -5861,7 +6090,7 @@ function validate$r(obj, path = 'IndividualApplicationTaskOutputRepresentation')
         if (obj.result !== undefined) {
             const obj_result = obj.result;
             const path_result = path + '.result';
-            const referencepath_resultValidationError = validate$14(obj_result, path_result);
+            const referencepath_resultValidationError = validate$16(obj_result, path_result);
             if (referencepath_resultValidationError !== null) {
                 let message = 'Object doesn\'t match IndividualApplicationTask (at "' + path_result + '")\n';
                 message += referencepath_resultValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -5968,14 +6197,14 @@ const getIndividualApplicationTask_ConfigPropertyMetadata = [
     generateParamConfigMetadata('individualApplicationTaskId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getIndividualApplicationTask_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$a, getIndividualApplicationTask_ConfigPropertyMetadata);
-const createResourceParams$a = /*#__PURE__*/ createResourceParams$n(getIndividualApplicationTask_ConfigPropertyMetadata);
+const createResourceParams$a = /*#__PURE__*/ createResourceParams$o(getIndividualApplicationTask_ConfigPropertyMetadata);
 function keyBuilder$g(luvio, config) {
     const resourceParams = createResourceParams$a(config);
     return keyBuilder$h(luvio, resourceParams);
 }
 function typeCheckConfig$a(untrustedConfig) {
     const config = {};
-    typeCheckConfig$n(untrustedConfig, config, getIndividualApplicationTask_ConfigPropertyMetadata);
+    typeCheckConfig$o(untrustedConfig, config, getIndividualApplicationTask_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$a(untrustedConfig, configPropertyNames) {
@@ -6024,7 +6253,7 @@ function buildNetworkSnapshot$a(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot$a, undefined, false);
+    return buildNetworkSnapshotCachePolicy$g(context, coercedAdapterRequestContext, buildNetworkSnapshot$a, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
     const { luvio, config } = context;
@@ -6287,14 +6516,14 @@ const getAcademicTerms_ConfigPropertyMetadata = [
     generateParamConfigMetadata('academicLevel', true, 1 /* QueryParameter */, 0 /* String */),
 ];
 const getAcademicTerms_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$9, getAcademicTerms_ConfigPropertyMetadata);
-const createResourceParams$9 = /*#__PURE__*/ createResourceParams$n(getAcademicTerms_ConfigPropertyMetadata);
+const createResourceParams$9 = /*#__PURE__*/ createResourceParams$o(getAcademicTerms_ConfigPropertyMetadata);
 function keyBuilder$e(luvio, config) {
     const resourceParams = createResourceParams$9(config);
     return keyBuilder$f(luvio, resourceParams);
 }
 function typeCheckConfig$9(untrustedConfig) {
     const config = {};
-    typeCheckConfig$n(untrustedConfig, config, getAcademicTerms_ConfigPropertyMetadata);
+    typeCheckConfig$o(untrustedConfig, config, getAcademicTerms_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
@@ -6343,7 +6572,7 @@ function buildNetworkSnapshot$9(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot$9, undefined, false);
+    return buildNetworkSnapshotCachePolicy$g(context, coercedAdapterRequestContext, buildNetworkSnapshot$9, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
     const { luvio, config } = context;
@@ -6521,7 +6750,7 @@ const createPreliminaryApplicationReferences_ConfigPropertyMetadata = [
     generateParamConfigMetadata('preliminaryAppRefInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const createPreliminaryApplicationReferences_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$8, createPreliminaryApplicationReferences_ConfigPropertyMetadata);
-const createResourceParams$8 = /*#__PURE__*/ createResourceParams$n(createPreliminaryApplicationReferences_ConfigPropertyMetadata);
+const createResourceParams$8 = /*#__PURE__*/ createResourceParams$o(createPreliminaryApplicationReferences_ConfigPropertyMetadata);
 function typeCheckConfig$8(untrustedConfig) {
     const config = {};
     const untrustedConfig_preliminaryAppRefInput = untrustedConfig.preliminaryAppRefInput;
@@ -6677,7 +6906,7 @@ function validate$l(obj, path = 'GetNewApplicationPreliminaryDataResult') {
             for (let i = 0; i < obj_applicants.length; i++) {
                 const obj_applicants_item = obj_applicants[i];
                 const path_applicants_item = path_applicants + '[' + i + ']';
-                const referencepath_applicants_itemValidationError = validate$1a(obj_applicants_item, path_applicants_item);
+                const referencepath_applicants_itemValidationError = validate$1c(obj_applicants_item, path_applicants_item);
                 if (referencepath_applicants_itemValidationError !== null) {
                     let message = 'Object doesn\'t match Applicant (at "' + path_applicants_item + '")\n';
                     message += referencepath_applicants_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -6690,7 +6919,7 @@ function validate$l(obj, path = 'GetNewApplicationPreliminaryDataResult') {
 }
 const select$o = function GetNewApplicationPreliminaryDataResultSelect() {
     const { selections: ApplicationAcademicLevel__selections, opaque: ApplicationAcademicLevel__opaque, } = select$p();
-    const { selections: Applicant__selections, opaque: Applicant__opaque, } = select$14();
+    const { selections: Applicant__selections, opaque: Applicant__opaque, } = select$16();
     return {
         kind: 'Fragment',
         version: VERSION$g,
@@ -6742,7 +6971,7 @@ function equals$g(existing, incoming) {
             return false;
         }
         const equals_applicants_items = equalsArray(existing_applicants, incoming_applicants, (existing_applicants_item, incoming_applicants_item) => {
-            if (!(equals$H(existing_applicants_item, incoming_applicants_item))) {
+            if (!(equals$I(existing_applicants_item, incoming_applicants_item))) {
                 return false;
             }
         });
@@ -6881,14 +7110,14 @@ const getNewApplicationPreliminaryData_ConfigPropertyMetadata = [
     generateParamConfigMetadata('context', true, 1 /* QueryParameter */, 0 /* String */),
 ];
 const getNewApplicationPreliminaryData_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$7, getNewApplicationPreliminaryData_ConfigPropertyMetadata);
-const createResourceParams$7 = /*#__PURE__*/ createResourceParams$n(getNewApplicationPreliminaryData_ConfigPropertyMetadata);
+const createResourceParams$7 = /*#__PURE__*/ createResourceParams$o(getNewApplicationPreliminaryData_ConfigPropertyMetadata);
 function keyBuilder$b(luvio, config) {
     const resourceParams = createResourceParams$7(config);
     return keyBuilder$c(luvio, resourceParams);
 }
 function typeCheckConfig$7(untrustedConfig) {
     const config = {};
-    typeCheckConfig$n(untrustedConfig, config, getNewApplicationPreliminaryData_ConfigPropertyMetadata);
+    typeCheckConfig$o(untrustedConfig, config, getNewApplicationPreliminaryData_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
@@ -6937,7 +7166,7 @@ function buildNetworkSnapshot$7(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot$7, undefined, false);
+    return buildNetworkSnapshotCachePolicy$g(context, coercedAdapterRequestContext, buildNetworkSnapshot$7, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
     const { luvio, config } = context;
@@ -7201,14 +7430,14 @@ const getProgramTermApplicationTimelines_ConfigPropertyMetadata = [
     generateParamConfigMetadata('academicLevel', false, 1 /* QueryParameter */, 0 /* String */),
 ];
 const getProgramTermApplicationTimelines_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$6, getProgramTermApplicationTimelines_ConfigPropertyMetadata);
-const createResourceParams$6 = /*#__PURE__*/ createResourceParams$n(getProgramTermApplicationTimelines_ConfigPropertyMetadata);
+const createResourceParams$6 = /*#__PURE__*/ createResourceParams$o(getProgramTermApplicationTimelines_ConfigPropertyMetadata);
 function keyBuilder$9(luvio, config) {
     const resourceParams = createResourceParams$6(config);
     return keyBuilder$a(luvio, resourceParams);
 }
 function typeCheckConfig$6(untrustedConfig) {
     const config = {};
-    typeCheckConfig$n(untrustedConfig, config, getProgramTermApplicationTimelines_ConfigPropertyMetadata);
+    typeCheckConfig$o(untrustedConfig, config, getProgramTermApplicationTimelines_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
@@ -7257,7 +7486,7 @@ function buildNetworkSnapshot$6(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot$6, undefined, false);
+    return buildNetworkSnapshotCachePolicy$g(context, coercedAdapterRequestContext, buildNetworkSnapshot$6, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
     const { luvio, config } = context;
@@ -7674,14 +7903,14 @@ const getPersonPublicProfile_ConfigPropertyMetadata = [
     generateParamConfigMetadata('usageType', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getPersonPublicProfile_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, getPersonPublicProfile_ConfigPropertyMetadata);
-const createResourceParams$5 = /*#__PURE__*/ createResourceParams$n(getPersonPublicProfile_ConfigPropertyMetadata);
+const createResourceParams$5 = /*#__PURE__*/ createResourceParams$o(getPersonPublicProfile_ConfigPropertyMetadata);
 function keyBuilder$7(luvio, config) {
     const resourceParams = createResourceParams$5(config);
     return keyBuilder$8(luvio, resourceParams);
 }
 function typeCheckConfig$5(untrustedConfig) {
     const config = {};
-    typeCheckConfig$n(untrustedConfig, config, getPersonPublicProfile_ConfigPropertyMetadata);
+    typeCheckConfig$o(untrustedConfig, config, getPersonPublicProfile_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
@@ -7730,7 +7959,7 @@ function buildNetworkSnapshot$5(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot$5, undefined, false);
+    return buildNetworkSnapshotCachePolicy$g(context, coercedAdapterRequestContext, buildNetworkSnapshot$5, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
     const { luvio, config } = context;
@@ -8199,14 +8428,14 @@ const getSuccessTeam_ConfigPropertyMetadata = [
     generateParamConfigMetadata('teamTypes', false, 1 /* QueryParameter */, 0 /* String */, true),
 ];
 const getSuccessTeam_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, getSuccessTeam_ConfigPropertyMetadata);
-const createResourceParams$4 = /*#__PURE__*/ createResourceParams$n(getSuccessTeam_ConfigPropertyMetadata);
+const createResourceParams$4 = /*#__PURE__*/ createResourceParams$o(getSuccessTeam_ConfigPropertyMetadata);
 function keyBuilder$5(luvio, config) {
     const resourceParams = createResourceParams$4(config);
     return keyBuilder$6(luvio, resourceParams);
 }
 function typeCheckConfig$4(untrustedConfig) {
     const config = {};
-    typeCheckConfig$n(untrustedConfig, config, getSuccessTeam_ConfigPropertyMetadata);
+    typeCheckConfig$o(untrustedConfig, config, getSuccessTeam_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
@@ -8255,7 +8484,7 @@ function buildNetworkSnapshot$4(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$2(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot$4, undefined, false);
+    return buildNetworkSnapshotCachePolicy$g(context, coercedAdapterRequestContext, buildNetworkSnapshot$4, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
     const { luvio, config } = context;
@@ -8454,10 +8683,10 @@ const createTask_ConfigPropertyMetadata = [
     generateParamConfigMetadata('subject', false, 2 /* Body */, 0 /* String */),
 ];
 const createTask_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, createTask_ConfigPropertyMetadata);
-const createResourceParams$3 = /*#__PURE__*/ createResourceParams$n(createTask_ConfigPropertyMetadata);
+const createResourceParams$3 = /*#__PURE__*/ createResourceParams$o(createTask_ConfigPropertyMetadata);
 function typeCheckConfig$3(untrustedConfig) {
     const config = {};
-    typeCheckConfig$n(untrustedConfig, config, createTask_ConfigPropertyMetadata);
+    typeCheckConfig$o(untrustedConfig, config, createTask_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
@@ -8814,14 +9043,14 @@ const getPicklistValues_ConfigPropertyMetadata = [
     generateParamConfigMetadata('fieldNames', false, 1 /* QueryParameter */, 0 /* String */, true),
 ];
 const getPicklistValues_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, getPicklistValues_ConfigPropertyMetadata);
-const createResourceParams$2 = /*#__PURE__*/ createResourceParams$n(getPicklistValues_ConfigPropertyMetadata);
+const createResourceParams$2 = /*#__PURE__*/ createResourceParams$o(getPicklistValues_ConfigPropertyMetadata);
 function keyBuilder$2(luvio, config) {
     const resourceParams = createResourceParams$2(config);
     return keyBuilder$3(luvio, resourceParams);
 }
 function typeCheckConfig$2(untrustedConfig) {
     const config = {};
-    typeCheckConfig$n(untrustedConfig, config, getPicklistValues_ConfigPropertyMetadata);
+    typeCheckConfig$o(untrustedConfig, config, getPicklistValues_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
@@ -8870,7 +9099,7 @@ function buildNetworkSnapshot$2(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot$2, undefined, false);
+    return buildNetworkSnapshotCachePolicy$g(context, coercedAdapterRequestContext, buildNetworkSnapshot$2, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
     const { luvio, config } = context;
@@ -8944,10 +9173,10 @@ const updateTaskStatus_ConfigPropertyMetadata = [
     generateParamConfigMetadata('subject', false, 2 /* Body */, 0 /* String */),
 ];
 const updateTaskStatus_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, updateTaskStatus_ConfigPropertyMetadata);
-const createResourceParams$1 = /*#__PURE__*/ createResourceParams$n(updateTaskStatus_ConfigPropertyMetadata);
+const createResourceParams$1 = /*#__PURE__*/ createResourceParams$o(updateTaskStatus_ConfigPropertyMetadata);
 function typeCheckConfig$1(untrustedConfig) {
     const config = {};
-    typeCheckConfig$n(untrustedConfig, config, updateTaskStatus_ConfigPropertyMetadata);
+    typeCheckConfig$o(untrustedConfig, config, updateTaskStatus_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$1(untrustedConfig, configPropertyNames) {
@@ -10192,14 +10421,14 @@ const getAptsTasksPlans_ConfigPropertyMetadata = [
     generateParamConfigMetadata('objectType', false, 1 /* QueryParameter */, 0 /* String */),
 ];
 const getAptsTasksPlans_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, getAptsTasksPlans_ConfigPropertyMetadata);
-const createResourceParams = /*#__PURE__*/ createResourceParams$n(getAptsTasksPlans_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$o(getAptsTasksPlans_ConfigPropertyMetadata);
 function keyBuilder(luvio, config) {
     const resourceParams = createResourceParams(config);
     return keyBuilder$1(luvio, resourceParams);
 }
 function typeCheckConfig(untrustedConfig) {
     const config = {};
-    typeCheckConfig$n(untrustedConfig, config, getAptsTasksPlans_ConfigPropertyMetadata);
+    typeCheckConfig$o(untrustedConfig, config, getAptsTasksPlans_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig(untrustedConfig, configPropertyNames) {
@@ -10248,7 +10477,7 @@ function buildNetworkSnapshot(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot, undefined, false);
+    return buildNetworkSnapshotCachePolicy$g(context, coercedAdapterRequestContext, buildNetworkSnapshot, undefined, false);
 }
 function buildCachedSnapshotCachePolicy(context, storeLookup) {
     const { luvio, config } = context;
@@ -10273,4 +10502,4 @@ const getAptsTasksPlansAdapterFactory = (luvio) => function education__getAptsTa
     buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
 };
 
-export { createCarePlansAdapterFactory, createPreliminaryApplicationReferencesAdapterFactory, createTaskAdapterFactory, getAcademicTermsAdapterFactory, getApplicationDetailsAdapterFactory, getApplicationsAdapterFactory, getAptsTasksPlansAdapterFactory, getAvailableTimeSlotsAdapterFactory, getAvailableTopicsAdapterFactory, getIndividualApplicationTaskAdapterFactory, getLearnerProgressAdapterFactory, getNewApplicationPreliminaryDataAdapterFactory, getPersonPublicProfileAdapterFactory, getPicklistValuesAdapterFactory, getPreviewLearningProgramPlanAdapterFactory, getProgramTermApplicationTimelinesAdapterFactory, getSuccessTeamAdapterFactory, postBenefitAssignmentAdapterFactory, postCreateLearningAdapterFactory, postMatchingSelectorAdapterFactory, postPublishLearningProgramPlanAdapterFactory, updateLearningAdapterFactory, updateTaskStatusAdapterFactory };
+export { createCarePlansAdapterFactory, createPreliminaryApplicationReferencesAdapterFactory, createTaskAdapterFactory, getAcademicTermsAdapterFactory, getApplicationDetailsAdapterFactory, getApplicationsAdapterFactory, getAptsTasksPlansAdapterFactory, getAvailableTimeSlotsAdapterFactory, getAvailableTopicsAdapterFactory, getIndividualApplicationTaskAdapterFactory, getLearnerProgressAdapterFactory, getNewApplicationPreliminaryDataAdapterFactory, getPersonPublicProfileAdapterFactory, getPicklistValuesAdapterFactory, getPreviewLearningProgramPlanAdapterFactory, getProgramTermApplicationTimelinesAdapterFactory, getPromptTemplatesAdapterFactory, getSuccessTeamAdapterFactory, postBenefitAssignmentAdapterFactory, postCreateLearningAdapterFactory, postMatchingSelectorAdapterFactory, postPublishLearningProgramPlanAdapterFactory, updateLearningAdapterFactory, updateTaskStatusAdapterFactory };