@salesforce/lds-adapters-analytics-app-framework 1.332.0-dev2 → 1.332.0-dev21

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (11) hide show
  1. package/dist/es/es2018/analytics-app-framework.js +262 -139
  2. package/dist/es/es2018/types/src/generated/adapters/updateApp.d.ts +21 -0
  3. package/dist/es/es2018/types/src/generated/artifacts/main.d.ts +1 -0
  4. package/dist/es/es2018/types/src/generated/artifacts/sfdc.d.ts +2 -1
  5. package/dist/es/es2018/types/src/generated/resources/putAppFrameworkAppsByAppIdOrApiName.d.ts +20 -0
  6. package/dist/es/es2018/types/src/generated/types/AppRepresentation.d.ts +5 -2
  7. package/dist/es/es2018/types/src/generated/types/AppUpdateRepresentation.d.ts +41 -0
  8. package/package.json +3 -3
  9. package/sfdc/index.js +568 -442
  10. package/src/raml/api.raml +40 -1
  11. package/src/raml/luvio.raml +3 -0
package/sfdc/index.js CHANGED
@@ -14,7 +14,7 @@
14
14
  /* proxy-compat-disable */
15
15
  import { createInstrumentedAdapter, createLDSAdapter, createWireAdapterConstructor, createImperativeAdapter } from 'force/ldsBindings';
16
16
  import { withDefaultLuvio } from 'force/ldsEngine';
17
- import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, createResourceParams as createResourceParams$h, typeCheckConfig as typeCheckConfig$h, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$a } from 'force/luvioEngine';
17
+ import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, createResourceParams as createResourceParams$i, typeCheckConfig as typeCheckConfig$i, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$a } from 'force/luvioEngine';
18
18
 
19
19
  const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
20
20
  const { keys: ObjectKeys$1, create: ObjectCreate$1 } = Object;
@@ -167,7 +167,7 @@ function validate$z(obj, path = 'UserRepresentation') {
167
167
  })();
168
168
  return v_error === undefined ? null : v_error;
169
169
  }
170
- const select$K = function UserRepresentationSelect() {
170
+ const select$L = function UserRepresentationSelect() {
171
171
  return {
172
172
  kind: 'Fragment',
173
173
  version: VERSION$v,
@@ -227,7 +227,7 @@ function validate$y(obj, path = 'ScheduledTimezoneRepresentation') {
227
227
  })();
228
228
  return v_error === undefined ? null : v_error;
229
229
  }
230
- const select$J = function ScheduledTimezoneRepresentationSelect() {
230
+ const select$K = function ScheduledTimezoneRepresentationSelect() {
231
231
  return {
232
232
  kind: 'Fragment',
233
233
  version: VERSION$u,
@@ -294,8 +294,8 @@ function validate$x(obj, path = 'ScheduledTimeRepresentation') {
294
294
  })();
295
295
  return v_error === undefined ? null : v_error;
296
296
  }
297
- const select$I = function ScheduledTimeRepresentationSelect() {
298
- const { selections: ScheduledTimezoneRepresentation__selections, opaque: ScheduledTimezoneRepresentation__opaque, } = select$J();
297
+ const select$J = function ScheduledTimeRepresentationSelect() {
298
+ const { selections: ScheduledTimezoneRepresentation__selections, opaque: ScheduledTimezoneRepresentation__opaque, } = select$K();
299
299
  return {
300
300
  kind: 'Fragment',
301
301
  version: VERSION$t,
@@ -337,8 +337,8 @@ function equals$q(existing, incoming) {
337
337
  }
338
338
 
339
339
  const VERSION$s = "91838b86aa135ce828af6242b11ae888";
340
- const select$H = function HourlyScheduledItemRepresentationSelect() {
341
- const { selections: ScheduledItemRepresentationSelections } = select$E();
340
+ const select$I = function HourlyScheduledItemRepresentationSelect() {
341
+ const { selections: ScheduledItemRepresentationSelections } = select$F();
342
342
  return {
343
343
  kind: 'Fragment',
344
344
  version: VERSION$s,
@@ -359,8 +359,8 @@ const select$H = function HourlyScheduledItemRepresentationSelect() {
359
359
  };
360
360
 
361
361
  const VERSION$r = "46260a34f0b2c2d7adc7f8c150a8d8fb";
362
- const select$G = function WeeklyScheduledItemRepresentationSelect() {
363
- const { selections: ScheduledItemRepresentationSelections } = select$E();
362
+ const select$H = function WeeklyScheduledItemRepresentationSelect() {
363
+ const { selections: ScheduledItemRepresentationSelections } = select$F();
364
364
  return {
365
365
  kind: 'Fragment',
366
366
  version: VERSION$r,
@@ -377,8 +377,8 @@ const select$G = function WeeklyScheduledItemRepresentationSelect() {
377
377
  };
378
378
 
379
379
  const VERSION$q = "dcda6d015a01d9acde5fac241448cfe4";
380
- const select$F = function DailyScheduledItemRepresentationSelect() {
381
- const { selections: ScheduledItemRepresentationSelections } = select$E();
380
+ const select$G = function DailyScheduledItemRepresentationSelect() {
381
+ const { selections: ScheduledItemRepresentationSelections } = select$F();
382
382
  return {
383
383
  kind: 'Fragment',
384
384
  version: VERSION$q,
@@ -423,9 +423,9 @@ function validate$w(obj, path = 'ScheduledItemRepresentation') {
423
423
  return v_error === undefined ? null : v_error;
424
424
  }
425
425
  const selectChildren = function ScheduledItemRepresentationSelectChildren() {
426
- const hourlyScheduledItemRepresentationSelections = select$H();
427
- const weeklyScheduledItemRepresentationSelections = select$G();
428
- const dailyScheduledItemRepresentationSelections = select$F();
426
+ const hourlyScheduledItemRepresentationSelections = select$I();
427
+ const weeklyScheduledItemRepresentationSelections = select$H();
428
+ const dailyScheduledItemRepresentationSelections = select$G();
429
429
  return {
430
430
  kind: 'Fragment',
431
431
  union: true,
@@ -437,8 +437,8 @@ const selectChildren = function ScheduledItemRepresentationSelectChildren() {
437
437
  }
438
438
  };
439
439
  };
440
- const select$E = function ScheduledItemRepresentationSelect() {
441
- const { selections: ScheduledTimeRepresentation__selections, opaque: ScheduledTimeRepresentation__opaque, } = select$I();
440
+ const select$F = function ScheduledItemRepresentationSelect() {
441
+ const { selections: ScheduledTimeRepresentation__selections, opaque: ScheduledTimeRepresentation__opaque, } = select$J();
442
442
  return {
443
443
  kind: 'Fragment',
444
444
  version: VERSION$p,
@@ -543,7 +543,7 @@ function validate$v(obj, path = 'AppScheduleRepresentation') {
543
543
  })();
544
544
  return v_error === undefined ? null : v_error;
545
545
  }
546
- const select$D = function AppScheduleRepresentationSelect() {
546
+ const select$E = function AppScheduleRepresentationSelect() {
547
547
  const ScheduledItemRepresentation__unionSelections = selectChildren();
548
548
  return {
549
549
  kind: 'Fragment',
@@ -583,7 +583,7 @@ function equals$o(existing, incoming) {
583
583
  }
584
584
 
585
585
  const TTL$c = 5000;
586
- const VERSION$n = "be6294bb853a9581fb3b06a2d8caa5d5";
586
+ const VERSION$n = "18531c618e98e8d042ebd75a49a45b36";
587
587
  function validate$u(obj, path = 'AppRepresentation') {
588
588
  const v_error = (() => {
589
589
  if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -681,6 +681,11 @@ function validate$u(obj, path = 'AppRepresentation') {
681
681
  if (typeof obj_name !== 'string') {
682
682
  return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
683
683
  }
684
+ const obj_refreshUrl = obj.refreshUrl;
685
+ const path_refreshUrl = path + '.refreshUrl';
686
+ if (typeof obj_refreshUrl !== 'string') {
687
+ return new TypeError('Expected "string" but received "' + typeof obj_refreshUrl + '" (at "' + path_refreshUrl + '")');
688
+ }
684
689
  const obj_schedule = obj.schedule;
685
690
  const path_schedule = path + '.schedule';
686
691
  let obj_schedule_union0 = null;
@@ -760,9 +765,9 @@ function keyBuilderFromType$9(luvio, object) {
760
765
  function normalize$c(input, existing, path, luvio, store, timestamp) {
761
766
  return input;
762
767
  }
763
- const select$C = function AppRepresentationSelect() {
764
- const { selections: UserRepresentation__selections, opaque: UserRepresentation__opaque, } = select$K();
765
- const { selections: AppScheduleRepresentation__selections, opaque: AppScheduleRepresentation__opaque, } = select$D();
768
+ const select$D = function AppRepresentationSelect() {
769
+ const { selections: UserRepresentation__selections, opaque: UserRepresentation__opaque, } = select$L();
770
+ const { selections: AppScheduleRepresentation__selections, opaque: AppScheduleRepresentation__opaque, } = select$E();
766
771
  return {
767
772
  kind: 'Fragment',
768
773
  version: VERSION$n,
@@ -822,6 +827,10 @@ const select$C = function AppRepresentationSelect() {
822
827
  name: 'name',
823
828
  kind: 'Scalar'
824
829
  },
830
+ {
831
+ name: 'refreshUrl',
832
+ kind: 'Scalar'
833
+ },
825
834
  {
826
835
  name: 'schedule',
827
836
  kind: 'Object',
@@ -903,6 +912,11 @@ function equals$n(existing, incoming) {
903
912
  if (!(existing_name === incoming_name)) {
904
913
  return false;
905
914
  }
915
+ const existing_refreshUrl = existing.refreshUrl;
916
+ const incoming_refreshUrl = incoming.refreshUrl;
917
+ if (!(existing_refreshUrl === incoming_refreshUrl)) {
918
+ return false;
919
+ }
906
920
  const existing_templateSourceId = existing.templateSourceId;
907
921
  const incoming_templateSourceId = incoming.templateSourceId;
908
922
  if (!(existing_templateSourceId === incoming_templateSourceId)) {
@@ -1065,7 +1079,7 @@ function normalize$b(input, existing, path, luvio, store, timestamp) {
1065
1079
  }, luvio, store, timestamp);
1066
1080
  return input;
1067
1081
  }
1068
- const select$B = function AppResultRepresentationSelect() {
1082
+ const select$C = function AppResultRepresentationSelect() {
1069
1083
  return {
1070
1084
  kind: 'Fragment',
1071
1085
  version: VERSION$m,
@@ -1074,7 +1088,7 @@ const select$B = function AppResultRepresentationSelect() {
1074
1088
  {
1075
1089
  name: 'app',
1076
1090
  kind: 'Link',
1077
- fragment: select$C()
1091
+ fragment: select$D()
1078
1092
  },
1079
1093
  {
1080
1094
  name: 'failureMessage',
@@ -1143,19 +1157,19 @@ function getTypeCacheKeys$b(rootKeySet, luvio, input, fullPathFactory) {
1143
1157
  getTypeCacheKeys$c(rootKeySet, luvio, input.app);
1144
1158
  }
1145
1159
 
1146
- function select$A(luvio, params) {
1147
- return select$B();
1160
+ function select$B(luvio, params) {
1161
+ return select$C();
1148
1162
  }
1149
- function getResponseCacheKeys$g(storeKeyMap, luvio, resourceParams, response) {
1163
+ function getResponseCacheKeys$h(storeKeyMap, luvio, resourceParams, response) {
1150
1164
  getTypeCacheKeys$b(storeKeyMap, luvio, response);
1151
1165
  }
1152
- function ingestSuccess$e(luvio, resourceParams, response) {
1166
+ function ingestSuccess$f(luvio, resourceParams, response) {
1153
1167
  const { body } = response;
1154
1168
  const key = keyBuilderFromType$8(luvio, body);
1155
1169
  luvio.storeIngest(key, ingest$b, body);
1156
1170
  const snapshot = luvio.storeLookup({
1157
1171
  recordId: key,
1158
- node: select$A(),
1172
+ node: select$B(),
1159
1173
  variables: {},
1160
1174
  });
1161
1175
  if (process.env.NODE_ENV !== 'production') {
@@ -1166,7 +1180,7 @@ function ingestSuccess$e(luvio, resourceParams, response) {
1166
1180
  deepFreeze(snapshot.data);
1167
1181
  return snapshot;
1168
1182
  }
1169
- function createResourceRequest$g(config) {
1183
+ function createResourceRequest$h(config) {
1170
1184
  const headers = {};
1171
1185
  return {
1172
1186
  baseUri: '/services/data/v63.0',
@@ -1180,7 +1194,7 @@ function createResourceRequest$g(config) {
1180
1194
  };
1181
1195
  }
1182
1196
 
1183
- const adapterName$g = 'createApp';
1197
+ const adapterName$h = 'createApp';
1184
1198
  const createApp_ConfigPropertyMetadata = [
1185
1199
  generateParamConfigMetadata('assetIcon', false, 2 /* Body */, 0 /* String */),
1186
1200
  generateParamConfigMetadata('description', false, 2 /* Body */, 0 /* String */),
@@ -1193,11 +1207,11 @@ const createApp_ConfigPropertyMetadata = [
1193
1207
  generateParamConfigMetadata('templateValues', false, 2 /* Body */, 4 /* Unsupported */),
1194
1208
  generateParamConfigMetadata('templateVersion', false, 2 /* Body */, 0 /* String */),
1195
1209
  ];
1196
- const createApp_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$g, createApp_ConfigPropertyMetadata);
1197
- const createResourceParams$g = /*#__PURE__*/ createResourceParams$h(createApp_ConfigPropertyMetadata);
1198
- function typeCheckConfig$g(untrustedConfig) {
1210
+ const createApp_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$h, createApp_ConfigPropertyMetadata);
1211
+ const createResourceParams$h = /*#__PURE__*/ createResourceParams$i(createApp_ConfigPropertyMetadata);
1212
+ function typeCheckConfig$h(untrustedConfig) {
1199
1213
  const config = {};
1200
- typeCheckConfig$h(untrustedConfig, config, createApp_ConfigPropertyMetadata);
1214
+ typeCheckConfig$i(untrustedConfig, config, createApp_ConfigPropertyMetadata);
1201
1215
  const untrustedConfig_templateValues = untrustedConfig.templateValues;
1202
1216
  if (untrustedIsObject(untrustedConfig_templateValues)) {
1203
1217
  const untrustedConfig_templateValues_object = {};
@@ -1215,30 +1229,30 @@ function typeCheckConfig$g(untrustedConfig) {
1215
1229
  }
1216
1230
  return config;
1217
1231
  }
1218
- function validateAdapterConfig$g(untrustedConfig, configPropertyNames) {
1232
+ function validateAdapterConfig$h(untrustedConfig, configPropertyNames) {
1219
1233
  if (!untrustedIsObject(untrustedConfig)) {
1220
1234
  return null;
1221
1235
  }
1222
1236
  if (process.env.NODE_ENV !== 'production') {
1223
1237
  validateConfig(untrustedConfig, configPropertyNames);
1224
1238
  }
1225
- const config = typeCheckConfig$g(untrustedConfig);
1239
+ const config = typeCheckConfig$h(untrustedConfig);
1226
1240
  if (!areRequiredParametersPresent(config, configPropertyNames)) {
1227
1241
  return null;
1228
1242
  }
1229
1243
  return config;
1230
1244
  }
1231
- function buildNetworkSnapshot$g(luvio, config, options) {
1232
- const resourceParams = createResourceParams$g(config);
1233
- const request = createResourceRequest$g(resourceParams);
1245
+ function buildNetworkSnapshot$h(luvio, config, options) {
1246
+ const resourceParams = createResourceParams$h(config);
1247
+ const request = createResourceRequest$h(resourceParams);
1234
1248
  return luvio.dispatchResourceRequest(request, options)
1235
1249
  .then((response) => {
1236
1250
  return luvio.handleSuccessResponse(() => {
1237
- const snapshot = ingestSuccess$e(luvio, resourceParams, response);
1251
+ const snapshot = ingestSuccess$f(luvio, resourceParams, response);
1238
1252
  return luvio.storeBroadcast().then(() => snapshot);
1239
1253
  }, () => {
1240
1254
  const cache = new StoreKeyMap();
1241
- getResponseCacheKeys$g(cache, luvio, resourceParams, response.body);
1255
+ getResponseCacheKeys$h(cache, luvio, resourceParams, response.body);
1242
1256
  return cache;
1243
1257
  });
1244
1258
  }, (response) => {
@@ -1248,12 +1262,12 @@ function buildNetworkSnapshot$g(luvio, config, options) {
1248
1262
  }
1249
1263
  const createAppAdapterFactory = (luvio) => {
1250
1264
  return function createApp(untrustedConfig) {
1251
- const config = validateAdapterConfig$g(untrustedConfig, createApp_ConfigPropertyNames);
1265
+ const config = validateAdapterConfig$h(untrustedConfig, createApp_ConfigPropertyNames);
1252
1266
  // Invalid or incomplete config
1253
1267
  if (config === null) {
1254
1268
  throw new Error('Invalid config for "createApp"');
1255
1269
  }
1256
- return buildNetworkSnapshot$g(luvio, config);
1270
+ return buildNetworkSnapshot$h(luvio, config);
1257
1271
  };
1258
1272
  };
1259
1273
 
@@ -1492,7 +1506,7 @@ function validate$m(obj, path = 'ChainDefinitionRepresentation') {
1492
1506
  })();
1493
1507
  return v_error === undefined ? null : v_error;
1494
1508
  }
1495
- const select$z = function ChainDefinitionRepresentationSelect() {
1509
+ const select$A = function ChainDefinitionRepresentationSelect() {
1496
1510
  return {
1497
1511
  kind: 'Fragment',
1498
1512
  version: VERSION$l,
@@ -1585,7 +1599,7 @@ function validate$l(obj, path = 'ImageReferenceRepresentation') {
1585
1599
  })();
1586
1600
  return v_error === undefined ? null : v_error;
1587
1601
  }
1588
- const select$y = function ImageReferenceRepresentationSelect() {
1602
+ const select$z = function ImageReferenceRepresentationSelect() {
1589
1603
  return {
1590
1604
  kind: 'Fragment',
1591
1605
  version: VERSION$k,
@@ -1853,7 +1867,7 @@ function validate$k(obj, path = 'TemplatePreviewRepresentation') {
1853
1867
  })();
1854
1868
  return v_error === undefined ? null : v_error;
1855
1869
  }
1856
- const select$x = function TemplatePreviewRepresentationSelect() {
1870
+ const select$y = function TemplatePreviewRepresentationSelect() {
1857
1871
  return {
1858
1872
  kind: 'Fragment',
1859
1873
  version: VERSION$j,
@@ -2002,9 +2016,9 @@ function validate$j(obj, path = 'TemplateIconsRepresentation') {
2002
2016
  })();
2003
2017
  return v_error === undefined ? null : v_error;
2004
2018
  }
2005
- const select$w = function TemplateIconsRepresentationSelect() {
2006
- const { selections: ImageReferenceRepresentation__selections, opaque: ImageReferenceRepresentation__opaque, } = select$y();
2007
- const { selections: TemplatePreviewRepresentation__selections, opaque: TemplatePreviewRepresentation__opaque, } = select$x();
2019
+ const select$x = function TemplateIconsRepresentationSelect() {
2020
+ const { selections: ImageReferenceRepresentation__selections, opaque: ImageReferenceRepresentation__opaque, } = select$z();
2021
+ const { selections: TemplatePreviewRepresentation__selections, opaque: TemplatePreviewRepresentation__opaque, } = select$y();
2008
2022
  return {
2009
2023
  kind: 'Fragment',
2010
2024
  version: VERSION$i,
@@ -2101,7 +2115,7 @@ function validate$i(obj, path = 'ReleaseInfoRepresentation') {
2101
2115
  })();
2102
2116
  return v_error === undefined ? null : v_error;
2103
2117
  }
2104
- const select$v = function ReleaseInfoRepresentationSelect() {
2118
+ const select$w = function ReleaseInfoRepresentationSelect() {
2105
2119
  return {
2106
2120
  kind: 'Fragment',
2107
2121
  version: VERSION$h,
@@ -2151,7 +2165,7 @@ function validate$h(obj, path = 'RuleInfoRepresentation') {
2151
2165
  })();
2152
2166
  return v_error === undefined ? null : v_error;
2153
2167
  }
2154
- const select$u = function RuleInfoRepresentationSelect() {
2168
+ const select$v = function RuleInfoRepresentationSelect() {
2155
2169
  return {
2156
2170
  kind: 'Fragment',
2157
2171
  version: VERSION$g,
@@ -2576,11 +2590,11 @@ function keyBuilderFromType$7(luvio, object) {
2576
2590
  function normalize$a(input, existing, path, luvio, store, timestamp) {
2577
2591
  return input;
2578
2592
  }
2579
- const select$t = function TemplateRepresentationSelect() {
2580
- const { selections: ChainDefinitionRepresentation__selections, opaque: ChainDefinitionRepresentation__opaque, } = select$z();
2581
- const { selections: TemplateIconsRepresentation__selections, opaque: TemplateIconsRepresentation__opaque, } = select$w();
2582
- const { selections: ReleaseInfoRepresentation__selections, opaque: ReleaseInfoRepresentation__opaque, } = select$v();
2583
- const { selections: RuleInfoRepresentation__selections, opaque: RuleInfoRepresentation__opaque, } = select$u();
2593
+ const select$u = function TemplateRepresentationSelect() {
2594
+ const { selections: ChainDefinitionRepresentation__selections, opaque: ChainDefinitionRepresentation__opaque, } = select$A();
2595
+ const { selections: TemplateIconsRepresentation__selections, opaque: TemplateIconsRepresentation__opaque, } = select$x();
2596
+ const { selections: ReleaseInfoRepresentation__selections, opaque: ReleaseInfoRepresentation__opaque, } = select$w();
2597
+ const { selections: RuleInfoRepresentation__selections, opaque: RuleInfoRepresentation__opaque, } = select$v();
2584
2598
  return {
2585
2599
  kind: 'Fragment',
2586
2600
  version: VERSION$f,
@@ -2833,19 +2847,19 @@ function getTypeCacheKeys$a(rootKeySet, luvio, input, fullPathFactory) {
2833
2847
  });
2834
2848
  }
2835
2849
 
2836
- function select$s(luvio, params) {
2837
- return select$t();
2850
+ function select$t(luvio, params) {
2851
+ return select$u();
2838
2852
  }
2839
- function getResponseCacheKeys$f(storeKeyMap, luvio, resourceParams, response) {
2853
+ function getResponseCacheKeys$g(storeKeyMap, luvio, resourceParams, response) {
2840
2854
  getTypeCacheKeys$a(storeKeyMap, luvio, response);
2841
2855
  }
2842
- function ingestSuccess$d(luvio, resourceParams, response) {
2856
+ function ingestSuccess$e(luvio, resourceParams, response) {
2843
2857
  const { body } = response;
2844
2858
  const key = keyBuilderFromType$7(luvio, body);
2845
2859
  luvio.storeIngest(key, ingest$a, body);
2846
2860
  const snapshot = luvio.storeLookup({
2847
2861
  recordId: key,
2848
- node: select$s(),
2862
+ node: select$t(),
2849
2863
  variables: {},
2850
2864
  });
2851
2865
  if (process.env.NODE_ENV !== 'production') {
@@ -2856,7 +2870,7 @@ function ingestSuccess$d(luvio, resourceParams, response) {
2856
2870
  deepFreeze(snapshot.data);
2857
2871
  return snapshot;
2858
2872
  }
2859
- function createResourceRequest$f(config) {
2873
+ function createResourceRequest$g(config) {
2860
2874
  const headers = {};
2861
2875
  return {
2862
2876
  baseUri: '/services/data/v63.0',
@@ -2870,7 +2884,7 @@ function createResourceRequest$f(config) {
2870
2884
  };
2871
2885
  }
2872
2886
 
2873
- const adapterName$f = 'createTemplate';
2887
+ const adapterName$g = 'createTemplate';
2874
2888
  const createTemplate_ConfigPropertyMetadata = [
2875
2889
  generateParamConfigMetadata('assetVersion', false, 2 /* Body */, 2 /* Number */),
2876
2890
  generateParamConfigMetadata('chainDefinitions', false, 2 /* Body */, 4 /* Unsupported */, true),
@@ -2888,11 +2902,11 @@ const createTemplate_ConfigPropertyMetadata = [
2888
2902
  generateParamConfigMetadata('templateType', true, 2 /* Body */, 0 /* String */),
2889
2903
  generateParamConfigMetadata('variableDefinition', false, 2 /* Body */, 0 /* String */),
2890
2904
  ];
2891
- const createTemplate_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$f, createTemplate_ConfigPropertyMetadata);
2892
- const createResourceParams$f = /*#__PURE__*/ createResourceParams$h(createTemplate_ConfigPropertyMetadata);
2893
- function typeCheckConfig$f(untrustedConfig) {
2905
+ const createTemplate_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$g, createTemplate_ConfigPropertyMetadata);
2906
+ const createResourceParams$g = /*#__PURE__*/ createResourceParams$i(createTemplate_ConfigPropertyMetadata);
2907
+ function typeCheckConfig$g(untrustedConfig) {
2894
2908
  const config = {};
2895
- typeCheckConfig$h(untrustedConfig, config, createTemplate_ConfigPropertyMetadata);
2909
+ typeCheckConfig$i(untrustedConfig, config, createTemplate_ConfigPropertyMetadata);
2896
2910
  const untrustedConfig_chainDefinitions = untrustedConfig.chainDefinitions;
2897
2911
  if (ArrayIsArray$1(untrustedConfig_chainDefinitions)) {
2898
2912
  const untrustedConfig_chainDefinitions_array = [];
@@ -2944,30 +2958,30 @@ function typeCheckConfig$f(untrustedConfig) {
2944
2958
  }
2945
2959
  return config;
2946
2960
  }
2947
- function validateAdapterConfig$f(untrustedConfig, configPropertyNames) {
2961
+ function validateAdapterConfig$g(untrustedConfig, configPropertyNames) {
2948
2962
  if (!untrustedIsObject(untrustedConfig)) {
2949
2963
  return null;
2950
2964
  }
2951
2965
  if (process.env.NODE_ENV !== 'production') {
2952
2966
  validateConfig(untrustedConfig, configPropertyNames);
2953
2967
  }
2954
- const config = typeCheckConfig$f(untrustedConfig);
2968
+ const config = typeCheckConfig$g(untrustedConfig);
2955
2969
  if (!areRequiredParametersPresent(config, configPropertyNames)) {
2956
2970
  return null;
2957
2971
  }
2958
2972
  return config;
2959
2973
  }
2960
- function buildNetworkSnapshot$f(luvio, config, options) {
2961
- const resourceParams = createResourceParams$f(config);
2962
- const request = createResourceRequest$f(resourceParams);
2974
+ function buildNetworkSnapshot$g(luvio, config, options) {
2975
+ const resourceParams = createResourceParams$g(config);
2976
+ const request = createResourceRequest$g(resourceParams);
2963
2977
  return luvio.dispatchResourceRequest(request, options)
2964
2978
  .then((response) => {
2965
2979
  return luvio.handleSuccessResponse(() => {
2966
- const snapshot = ingestSuccess$d(luvio, resourceParams, response);
2980
+ const snapshot = ingestSuccess$e(luvio, resourceParams, response);
2967
2981
  return luvio.storeBroadcast().then(() => snapshot);
2968
2982
  }, () => {
2969
2983
  const cache = new StoreKeyMap();
2970
- getResponseCacheKeys$f(cache, luvio, resourceParams, response.body);
2984
+ getResponseCacheKeys$g(cache, luvio, resourceParams, response.body);
2971
2985
  return cache;
2972
2986
  });
2973
2987
  }, (response) => {
@@ -2977,12 +2991,12 @@ function buildNetworkSnapshot$f(luvio, config, options) {
2977
2991
  }
2978
2992
  const createTemplateAdapterFactory = (luvio) => {
2979
2993
  return function createTemplate(untrustedConfig) {
2980
- const config = validateAdapterConfig$f(untrustedConfig, createTemplate_ConfigPropertyNames);
2994
+ const config = validateAdapterConfig$g(untrustedConfig, createTemplate_ConfigPropertyNames);
2981
2995
  // Invalid or incomplete config
2982
2996
  if (config === null) {
2983
2997
  throw new Error('Invalid config for "createTemplate"');
2984
2998
  }
2985
- return buildNetworkSnapshot$f(luvio, config);
2999
+ return buildNetworkSnapshot$g(luvio, config);
2986
3000
  };
2987
3001
  };
2988
3002
 
@@ -2991,7 +3005,7 @@ function keyBuilder$s(luvio, params) {
2991
3005
  id: params.urlParams.appIdOrApiName
2992
3006
  });
2993
3007
  }
2994
- function getResponseCacheKeys$e(cacheKeyMap, luvio, resourceParams) {
3008
+ function getResponseCacheKeys$f(cacheKeyMap, luvio, resourceParams) {
2995
3009
  const key = keyBuilder$s(luvio, resourceParams);
2996
3010
  cacheKeyMap.set(key, {
2997
3011
  namespace: keyPrefix,
@@ -3003,7 +3017,7 @@ function evictSuccess$1(luvio, resourceParams) {
3003
3017
  const key = keyBuilder$s(luvio, resourceParams);
3004
3018
  luvio.storeEvict(key);
3005
3019
  }
3006
- function createResourceRequest$e(config) {
3020
+ function createResourceRequest$f(config) {
3007
3021
  const headers = {};
3008
3022
  return {
3009
3023
  baseUri: '/services/data/v63.0',
@@ -3017,33 +3031,33 @@ function createResourceRequest$e(config) {
3017
3031
  };
3018
3032
  }
3019
3033
 
3020
- const adapterName$e = 'deleteApp';
3034
+ const adapterName$f = 'deleteApp';
3021
3035
  const deleteApp_ConfigPropertyMetadata = [
3022
3036
  generateParamConfigMetadata('appIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
3023
3037
  ];
3024
- const deleteApp_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$e, deleteApp_ConfigPropertyMetadata);
3025
- const createResourceParams$e = /*#__PURE__*/ createResourceParams$h(deleteApp_ConfigPropertyMetadata);
3026
- function typeCheckConfig$e(untrustedConfig) {
3038
+ const deleteApp_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$f, deleteApp_ConfigPropertyMetadata);
3039
+ const createResourceParams$f = /*#__PURE__*/ createResourceParams$i(deleteApp_ConfigPropertyMetadata);
3040
+ function typeCheckConfig$f(untrustedConfig) {
3027
3041
  const config = {};
3028
- typeCheckConfig$h(untrustedConfig, config, deleteApp_ConfigPropertyMetadata);
3042
+ typeCheckConfig$i(untrustedConfig, config, deleteApp_ConfigPropertyMetadata);
3029
3043
  return config;
3030
3044
  }
3031
- function validateAdapterConfig$e(untrustedConfig, configPropertyNames) {
3045
+ function validateAdapterConfig$f(untrustedConfig, configPropertyNames) {
3032
3046
  if (!untrustedIsObject(untrustedConfig)) {
3033
3047
  return null;
3034
3048
  }
3035
3049
  if (process.env.NODE_ENV !== 'production') {
3036
3050
  validateConfig(untrustedConfig, configPropertyNames);
3037
3051
  }
3038
- const config = typeCheckConfig$e(untrustedConfig);
3052
+ const config = typeCheckConfig$f(untrustedConfig);
3039
3053
  if (!areRequiredParametersPresent(config, configPropertyNames)) {
3040
3054
  return null;
3041
3055
  }
3042
3056
  return config;
3043
3057
  }
3044
- function buildNetworkSnapshot$e(luvio, config, options) {
3045
- const resourceParams = createResourceParams$e(config);
3046
- const request = createResourceRequest$e(resourceParams);
3058
+ function buildNetworkSnapshot$f(luvio, config, options) {
3059
+ const resourceParams = createResourceParams$f(config);
3060
+ const request = createResourceRequest$f(resourceParams);
3047
3061
  return luvio.dispatchResourceRequest(request, options)
3048
3062
  .then(() => {
3049
3063
  return luvio.handleSuccessResponse(() => {
@@ -3051,7 +3065,7 @@ function buildNetworkSnapshot$e(luvio, config, options) {
3051
3065
  return luvio.storeBroadcast();
3052
3066
  }, () => {
3053
3067
  const cache = new StoreKeyMap();
3054
- getResponseCacheKeys$e(cache, luvio, resourceParams);
3068
+ getResponseCacheKeys$f(cache, luvio, resourceParams);
3055
3069
  return cache;
3056
3070
  });
3057
3071
  }, (response) => {
@@ -3061,12 +3075,12 @@ function buildNetworkSnapshot$e(luvio, config, options) {
3061
3075
  }
3062
3076
  const deleteAppAdapterFactory = (luvio) => {
3063
3077
  return function AppFrameworkdeleteApp(untrustedConfig) {
3064
- const config = validateAdapterConfig$e(untrustedConfig, deleteApp_ConfigPropertyNames);
3078
+ const config = validateAdapterConfig$f(untrustedConfig, deleteApp_ConfigPropertyNames);
3065
3079
  // Invalid or incomplete config
3066
3080
  if (config === null) {
3067
- throw new Error(`Invalid config for "${adapterName$e}"`);
3081
+ throw new Error(`Invalid config for "${adapterName$f}"`);
3068
3082
  }
3069
- return buildNetworkSnapshot$e(luvio, config);
3083
+ return buildNetworkSnapshot$f(luvio, config);
3070
3084
  };
3071
3085
  };
3072
3086
 
@@ -3075,7 +3089,7 @@ function keyBuilder$r(luvio, params) {
3075
3089
  id: params.urlParams.templateIdOrApiName
3076
3090
  });
3077
3091
  }
3078
- function getResponseCacheKeys$d(cacheKeyMap, luvio, resourceParams) {
3092
+ function getResponseCacheKeys$e(cacheKeyMap, luvio, resourceParams) {
3079
3093
  const key = keyBuilder$r(luvio, resourceParams);
3080
3094
  cacheKeyMap.set(key, {
3081
3095
  namespace: keyPrefix,
@@ -3087,7 +3101,7 @@ function evictSuccess(luvio, resourceParams) {
3087
3101
  const key = keyBuilder$r(luvio, resourceParams);
3088
3102
  luvio.storeEvict(key);
3089
3103
  }
3090
- function createResourceRequest$d(config) {
3104
+ function createResourceRequest$e(config) {
3091
3105
  const headers = {};
3092
3106
  return {
3093
3107
  baseUri: '/services/data/v63.0',
@@ -3101,33 +3115,33 @@ function createResourceRequest$d(config) {
3101
3115
  };
3102
3116
  }
3103
3117
 
3104
- const adapterName$d = 'deleteTemplate';
3118
+ const adapterName$e = 'deleteTemplate';
3105
3119
  const deleteTemplate_ConfigPropertyMetadata = [
3106
3120
  generateParamConfigMetadata('templateIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
3107
3121
  ];
3108
- const deleteTemplate_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$d, deleteTemplate_ConfigPropertyMetadata);
3109
- const createResourceParams$d = /*#__PURE__*/ createResourceParams$h(deleteTemplate_ConfigPropertyMetadata);
3110
- function typeCheckConfig$d(untrustedConfig) {
3122
+ const deleteTemplate_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$e, deleteTemplate_ConfigPropertyMetadata);
3123
+ const createResourceParams$e = /*#__PURE__*/ createResourceParams$i(deleteTemplate_ConfigPropertyMetadata);
3124
+ function typeCheckConfig$e(untrustedConfig) {
3111
3125
  const config = {};
3112
- typeCheckConfig$h(untrustedConfig, config, deleteTemplate_ConfigPropertyMetadata);
3126
+ typeCheckConfig$i(untrustedConfig, config, deleteTemplate_ConfigPropertyMetadata);
3113
3127
  return config;
3114
3128
  }
3115
- function validateAdapterConfig$d(untrustedConfig, configPropertyNames) {
3129
+ function validateAdapterConfig$e(untrustedConfig, configPropertyNames) {
3116
3130
  if (!untrustedIsObject(untrustedConfig)) {
3117
3131
  return null;
3118
3132
  }
3119
3133
  if (process.env.NODE_ENV !== 'production') {
3120
3134
  validateConfig(untrustedConfig, configPropertyNames);
3121
3135
  }
3122
- const config = typeCheckConfig$d(untrustedConfig);
3136
+ const config = typeCheckConfig$e(untrustedConfig);
3123
3137
  if (!areRequiredParametersPresent(config, configPropertyNames)) {
3124
3138
  return null;
3125
3139
  }
3126
3140
  return config;
3127
3141
  }
3128
- function buildNetworkSnapshot$d(luvio, config, options) {
3129
- const resourceParams = createResourceParams$d(config);
3130
- const request = createResourceRequest$d(resourceParams);
3142
+ function buildNetworkSnapshot$e(luvio, config, options) {
3143
+ const resourceParams = createResourceParams$e(config);
3144
+ const request = createResourceRequest$e(resourceParams);
3131
3145
  return luvio.dispatchResourceRequest(request, options)
3132
3146
  .then(() => {
3133
3147
  return luvio.handleSuccessResponse(() => {
@@ -3135,7 +3149,7 @@ function buildNetworkSnapshot$d(luvio, config, options) {
3135
3149
  return luvio.storeBroadcast();
3136
3150
  }, () => {
3137
3151
  const cache = new StoreKeyMap();
3138
- getResponseCacheKeys$d(cache, luvio, resourceParams);
3152
+ getResponseCacheKeys$e(cache, luvio, resourceParams);
3139
3153
  return cache;
3140
3154
  });
3141
3155
  }, (response) => {
@@ -3145,33 +3159,33 @@ function buildNetworkSnapshot$d(luvio, config, options) {
3145
3159
  }
3146
3160
  const deleteTemplateAdapterFactory = (luvio) => {
3147
3161
  return function AppFrameworkdeleteTemplate(untrustedConfig) {
3148
- const config = validateAdapterConfig$d(untrustedConfig, deleteTemplate_ConfigPropertyNames);
3162
+ const config = validateAdapterConfig$e(untrustedConfig, deleteTemplate_ConfigPropertyNames);
3149
3163
  // Invalid or incomplete config
3150
3164
  if (config === null) {
3151
- throw new Error(`Invalid config for "${adapterName$d}"`);
3165
+ throw new Error(`Invalid config for "${adapterName$e}"`);
3152
3166
  }
3153
- return buildNetworkSnapshot$d(luvio, config);
3167
+ return buildNetworkSnapshot$e(luvio, config);
3154
3168
  };
3155
3169
  };
3156
3170
 
3157
- function select$r(luvio, params) {
3158
- return select$C();
3171
+ function select$s(luvio, params) {
3172
+ return select$D();
3159
3173
  }
3160
3174
  function keyBuilder$q(luvio, params) {
3161
3175
  return keyBuilder$v(luvio, {
3162
3176
  id: params.urlParams.appIdOrApiName
3163
3177
  });
3164
3178
  }
3165
- function getResponseCacheKeys$c(storeKeyMap, luvio, resourceParams, response) {
3179
+ function getResponseCacheKeys$d(storeKeyMap, luvio, resourceParams, response) {
3166
3180
  getTypeCacheKeys$c(storeKeyMap, luvio, response);
3167
3181
  }
3168
- function ingestSuccess$c(luvio, resourceParams, response, snapshotRefresh) {
3182
+ function ingestSuccess$d(luvio, resourceParams, response, snapshotRefresh) {
3169
3183
  const { body } = response;
3170
3184
  const key = keyBuilder$q(luvio, resourceParams);
3171
3185
  luvio.storeIngest(key, ingest$c, body);
3172
3186
  const snapshot = luvio.storeLookup({
3173
3187
  recordId: key,
3174
- node: select$r(),
3188
+ node: select$s(),
3175
3189
  variables: {},
3176
3190
  }, snapshotRefresh);
3177
3191
  if (process.env.NODE_ENV !== 'production') {
@@ -3194,7 +3208,7 @@ function ingestError$9(luvio, params, error, snapshotRefresh) {
3194
3208
  luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
3195
3209
  return errorSnapshot;
3196
3210
  }
3197
- function createResourceRequest$c(config) {
3211
+ function createResourceRequest$d(config) {
3198
3212
  const headers = {};
3199
3213
  return {
3200
3214
  baseUri: '/services/data/v63.0',
@@ -3212,63 +3226,63 @@ function createResourceRequestFromRepresentation$6(representation) {
3212
3226
  urlParams: {},
3213
3227
  };
3214
3228
  config.urlParams.appIdOrApiName = representation.id;
3215
- return createResourceRequest$c(config);
3229
+ return createResourceRequest$d(config);
3216
3230
  }
3217
3231
 
3218
- const adapterName$c = 'getApp';
3232
+ const adapterName$d = 'getApp';
3219
3233
  const getApp_ConfigPropertyMetadata = [
3220
3234
  generateParamConfigMetadata('appIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
3221
3235
  ];
3222
- const getApp_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$c, getApp_ConfigPropertyMetadata);
3223
- const createResourceParams$c = /*#__PURE__*/ createResourceParams$h(getApp_ConfigPropertyMetadata);
3236
+ const getApp_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$d, getApp_ConfigPropertyMetadata);
3237
+ const createResourceParams$d = /*#__PURE__*/ createResourceParams$i(getApp_ConfigPropertyMetadata);
3224
3238
  function keyBuilder$p(luvio, config) {
3225
- const resourceParams = createResourceParams$c(config);
3239
+ const resourceParams = createResourceParams$d(config);
3226
3240
  return keyBuilder$q(luvio, resourceParams);
3227
3241
  }
3228
- function typeCheckConfig$c(untrustedConfig) {
3242
+ function typeCheckConfig$d(untrustedConfig) {
3229
3243
  const config = {};
3230
- typeCheckConfig$h(untrustedConfig, config, getApp_ConfigPropertyMetadata);
3244
+ typeCheckConfig$i(untrustedConfig, config, getApp_ConfigPropertyMetadata);
3231
3245
  return config;
3232
3246
  }
3233
- function validateAdapterConfig$c(untrustedConfig, configPropertyNames) {
3247
+ function validateAdapterConfig$d(untrustedConfig, configPropertyNames) {
3234
3248
  if (!untrustedIsObject(untrustedConfig)) {
3235
3249
  return null;
3236
3250
  }
3237
3251
  if (process.env.NODE_ENV !== 'production') {
3238
3252
  validateConfig(untrustedConfig, configPropertyNames);
3239
3253
  }
3240
- const config = typeCheckConfig$c(untrustedConfig);
3254
+ const config = typeCheckConfig$d(untrustedConfig);
3241
3255
  if (!areRequiredParametersPresent(config, configPropertyNames)) {
3242
3256
  return null;
3243
3257
  }
3244
3258
  return config;
3245
3259
  }
3246
3260
  function adapterFragment$9(luvio, config) {
3247
- createResourceParams$c(config);
3248
- return select$r();
3261
+ createResourceParams$d(config);
3262
+ return select$s();
3249
3263
  }
3250
3264
  function onFetchResponseSuccess$9(luvio, config, resourceParams, response) {
3251
- const snapshot = ingestSuccess$c(luvio, resourceParams, response, {
3265
+ const snapshot = ingestSuccess$d(luvio, resourceParams, response, {
3252
3266
  config,
3253
- resolve: () => buildNetworkSnapshot$c(luvio, config, snapshotRefreshOptions)
3267
+ resolve: () => buildNetworkSnapshot$d(luvio, config, snapshotRefreshOptions)
3254
3268
  });
3255
3269
  return luvio.storeBroadcast().then(() => snapshot);
3256
3270
  }
3257
3271
  function onFetchResponseError$9(luvio, config, resourceParams, response) {
3258
3272
  const snapshot = ingestError$9(luvio, resourceParams, response, {
3259
3273
  config,
3260
- resolve: () => buildNetworkSnapshot$c(luvio, config, snapshotRefreshOptions)
3274
+ resolve: () => buildNetworkSnapshot$d(luvio, config, snapshotRefreshOptions)
3261
3275
  });
3262
3276
  return luvio.storeBroadcast().then(() => snapshot);
3263
3277
  }
3264
- function buildNetworkSnapshot$c(luvio, config, options) {
3265
- const resourceParams = createResourceParams$c(config);
3266
- const request = createResourceRequest$c(resourceParams);
3278
+ function buildNetworkSnapshot$d(luvio, config, options) {
3279
+ const resourceParams = createResourceParams$d(config);
3280
+ const request = createResourceRequest$d(resourceParams);
3267
3281
  return luvio.dispatchResourceRequest(request, options)
3268
3282
  .then((response) => {
3269
3283
  return luvio.handleSuccessResponse(() => onFetchResponseSuccess$9(luvio, config, resourceParams, response), () => {
3270
3284
  const cache = new StoreKeyMap();
3271
- getResponseCacheKeys$c(cache, luvio, resourceParams, response.body);
3285
+ getResponseCacheKeys$d(cache, luvio, resourceParams, response.body);
3272
3286
  return cache;
3273
3287
  });
3274
3288
  }, (response) => {
@@ -3276,7 +3290,7 @@ function buildNetworkSnapshot$c(luvio, config, options) {
3276
3290
  });
3277
3291
  }
3278
3292
  function buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext) {
3279
- return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$c, undefined, false);
3293
+ return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$d, undefined, false);
3280
3294
  }
3281
3295
  function buildCachedSnapshotCachePolicy$9(context, storeLookup) {
3282
3296
  const { luvio, config } = context;
@@ -3287,12 +3301,12 @@ function buildCachedSnapshotCachePolicy$9(context, storeLookup) {
3287
3301
  };
3288
3302
  const cacheSnapshot = storeLookup(selector, {
3289
3303
  config,
3290
- resolve: () => buildNetworkSnapshot$c(luvio, config, snapshotRefreshOptions)
3304
+ resolve: () => buildNetworkSnapshot$d(luvio, config, snapshotRefreshOptions)
3291
3305
  });
3292
3306
  return cacheSnapshot;
3293
3307
  }
3294
3308
  const getAppAdapterFactory = (luvio) => function AppFramework__getApp(untrustedConfig, requestContext) {
3295
- const config = validateAdapterConfig$c(untrustedConfig, getApp_ConfigPropertyNames);
3309
+ const config = validateAdapterConfig$d(untrustedConfig, getApp_ConfigPropertyNames);
3296
3310
  // Invalid or incomplete config
3297
3311
  if (config === null) {
3298
3312
  return null;
@@ -3393,7 +3407,7 @@ function keyBuilderFromType$6(luvio, object) {
3393
3407
  function normalize$9(input, existing, path, luvio, store, timestamp) {
3394
3408
  return input;
3395
3409
  }
3396
- const select$q = function AppActivityItemRepresentationSelect() {
3410
+ const select$r = function AppActivityItemRepresentationSelect() {
3397
3411
  return {
3398
3412
  kind: 'Fragment',
3399
3413
  version: VERSION$e,
@@ -3534,7 +3548,7 @@ function normalize$8(input, existing, path, luvio, store, timestamp) {
3534
3548
  }
3535
3549
  return input;
3536
3550
  }
3537
- const select$p = function AppActivityCollectionRepresentationSelect() {
3551
+ const select$q = function AppActivityCollectionRepresentationSelect() {
3538
3552
  return {
3539
3553
  kind: 'Fragment',
3540
3554
  version: VERSION$d,
@@ -3548,7 +3562,7 @@ const select$p = function AppActivityCollectionRepresentationSelect() {
3548
3562
  name: 'items',
3549
3563
  kind: 'Link',
3550
3564
  plural: true,
3551
- fragment: select$q()
3565
+ fragment: select$r()
3552
3566
  }
3553
3567
  ]
3554
3568
  };
@@ -3597,24 +3611,24 @@ function getTypeCacheKeys$8(rootKeySet, luvio, input, fullPathFactory) {
3597
3611
  }
3598
3612
  }
3599
3613
 
3600
- function select$o(luvio, params) {
3601
- return select$p();
3614
+ function select$p(luvio, params) {
3615
+ return select$q();
3602
3616
  }
3603
3617
  function keyBuilder$m(luvio, params) {
3604
3618
  return keyBuilder$n(luvio, {
3605
3619
  appId: params.urlParams.appIdOrApiName
3606
3620
  });
3607
3621
  }
3608
- function getResponseCacheKeys$b(storeKeyMap, luvio, resourceParams, response) {
3622
+ function getResponseCacheKeys$c(storeKeyMap, luvio, resourceParams, response) {
3609
3623
  getTypeCacheKeys$8(storeKeyMap, luvio, response);
3610
3624
  }
3611
- function ingestSuccess$b(luvio, resourceParams, response, snapshotRefresh) {
3625
+ function ingestSuccess$c(luvio, resourceParams, response, snapshotRefresh) {
3612
3626
  const { body } = response;
3613
3627
  const key = keyBuilder$m(luvio, resourceParams);
3614
3628
  luvio.storeIngest(key, ingest$8, body);
3615
3629
  const snapshot = luvio.storeLookup({
3616
3630
  recordId: key,
3617
- node: select$o(),
3631
+ node: select$p(),
3618
3632
  variables: {},
3619
3633
  }, snapshotRefresh);
3620
3634
  if (process.env.NODE_ENV !== 'production') {
@@ -3637,7 +3651,7 @@ function ingestError$8(luvio, params, error, snapshotRefresh) {
3637
3651
  luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
3638
3652
  return errorSnapshot;
3639
3653
  }
3640
- function createResourceRequest$b(config) {
3654
+ function createResourceRequest$c(config) {
3641
3655
  const headers = {};
3642
3656
  return {
3643
3657
  baseUri: '/services/data/v63.0',
@@ -3655,63 +3669,63 @@ function createResourceRequestFromRepresentation$5(representation) {
3655
3669
  urlParams: {},
3656
3670
  };
3657
3671
  config.urlParams.appIdOrApiName = representation.appId;
3658
- return createResourceRequest$b(config);
3672
+ return createResourceRequest$c(config);
3659
3673
  }
3660
3674
 
3661
- const adapterName$b = 'getAppActivities';
3675
+ const adapterName$c = 'getAppActivities';
3662
3676
  const getAppActivities_ConfigPropertyMetadata = [
3663
3677
  generateParamConfigMetadata('appIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
3664
3678
  ];
3665
- const getAppActivities_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$b, getAppActivities_ConfigPropertyMetadata);
3666
- const createResourceParams$b = /*#__PURE__*/ createResourceParams$h(getAppActivities_ConfigPropertyMetadata);
3679
+ const getAppActivities_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$c, getAppActivities_ConfigPropertyMetadata);
3680
+ const createResourceParams$c = /*#__PURE__*/ createResourceParams$i(getAppActivities_ConfigPropertyMetadata);
3667
3681
  function keyBuilder$l(luvio, config) {
3668
- const resourceParams = createResourceParams$b(config);
3682
+ const resourceParams = createResourceParams$c(config);
3669
3683
  return keyBuilder$m(luvio, resourceParams);
3670
3684
  }
3671
- function typeCheckConfig$b(untrustedConfig) {
3685
+ function typeCheckConfig$c(untrustedConfig) {
3672
3686
  const config = {};
3673
- typeCheckConfig$h(untrustedConfig, config, getAppActivities_ConfigPropertyMetadata);
3687
+ typeCheckConfig$i(untrustedConfig, config, getAppActivities_ConfigPropertyMetadata);
3674
3688
  return config;
3675
3689
  }
3676
- function validateAdapterConfig$b(untrustedConfig, configPropertyNames) {
3690
+ function validateAdapterConfig$c(untrustedConfig, configPropertyNames) {
3677
3691
  if (!untrustedIsObject(untrustedConfig)) {
3678
3692
  return null;
3679
3693
  }
3680
3694
  if (process.env.NODE_ENV !== 'production') {
3681
3695
  validateConfig(untrustedConfig, configPropertyNames);
3682
3696
  }
3683
- const config = typeCheckConfig$b(untrustedConfig);
3697
+ const config = typeCheckConfig$c(untrustedConfig);
3684
3698
  if (!areRequiredParametersPresent(config, configPropertyNames)) {
3685
3699
  return null;
3686
3700
  }
3687
3701
  return config;
3688
3702
  }
3689
3703
  function adapterFragment$8(luvio, config) {
3690
- createResourceParams$b(config);
3691
- return select$o();
3704
+ createResourceParams$c(config);
3705
+ return select$p();
3692
3706
  }
3693
3707
  function onFetchResponseSuccess$8(luvio, config, resourceParams, response) {
3694
- const snapshot = ingestSuccess$b(luvio, resourceParams, response, {
3708
+ const snapshot = ingestSuccess$c(luvio, resourceParams, response, {
3695
3709
  config,
3696
- resolve: () => buildNetworkSnapshot$b(luvio, config, snapshotRefreshOptions)
3710
+ resolve: () => buildNetworkSnapshot$c(luvio, config, snapshotRefreshOptions)
3697
3711
  });
3698
3712
  return luvio.storeBroadcast().then(() => snapshot);
3699
3713
  }
3700
3714
  function onFetchResponseError$8(luvio, config, resourceParams, response) {
3701
3715
  const snapshot = ingestError$8(luvio, resourceParams, response, {
3702
3716
  config,
3703
- resolve: () => buildNetworkSnapshot$b(luvio, config, snapshotRefreshOptions)
3717
+ resolve: () => buildNetworkSnapshot$c(luvio, config, snapshotRefreshOptions)
3704
3718
  });
3705
3719
  return luvio.storeBroadcast().then(() => snapshot);
3706
3720
  }
3707
- function buildNetworkSnapshot$b(luvio, config, options) {
3708
- const resourceParams = createResourceParams$b(config);
3709
- const request = createResourceRequest$b(resourceParams);
3721
+ function buildNetworkSnapshot$c(luvio, config, options) {
3722
+ const resourceParams = createResourceParams$c(config);
3723
+ const request = createResourceRequest$c(resourceParams);
3710
3724
  return luvio.dispatchResourceRequest(request, options)
3711
3725
  .then((response) => {
3712
3726
  return luvio.handleSuccessResponse(() => onFetchResponseSuccess$8(luvio, config, resourceParams, response), () => {
3713
3727
  const cache = new StoreKeyMap();
3714
- getResponseCacheKeys$b(cache, luvio, resourceParams, response.body);
3728
+ getResponseCacheKeys$c(cache, luvio, resourceParams, response.body);
3715
3729
  return cache;
3716
3730
  });
3717
3731
  }, (response) => {
@@ -3719,7 +3733,7 @@ function buildNetworkSnapshot$b(luvio, config, options) {
3719
3733
  });
3720
3734
  }
3721
3735
  function buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext) {
3722
- return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$b, undefined, false);
3736
+ return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$c, undefined, false);
3723
3737
  }
3724
3738
  function buildCachedSnapshotCachePolicy$8(context, storeLookup) {
3725
3739
  const { luvio, config } = context;
@@ -3730,12 +3744,12 @@ function buildCachedSnapshotCachePolicy$8(context, storeLookup) {
3730
3744
  };
3731
3745
  const cacheSnapshot = storeLookup(selector, {
3732
3746
  config,
3733
- resolve: () => buildNetworkSnapshot$b(luvio, config, snapshotRefreshOptions)
3747
+ resolve: () => buildNetworkSnapshot$c(luvio, config, snapshotRefreshOptions)
3734
3748
  });
3735
3749
  return cacheSnapshot;
3736
3750
  }
3737
3751
  const getAppActivitiesAdapterFactory = (luvio) => function AppFramework__getAppActivities(untrustedConfig, requestContext) {
3738
- const config = validateAdapterConfig$b(untrustedConfig, getAppActivities_ConfigPropertyNames);
3752
+ const config = validateAdapterConfig$c(untrustedConfig, getAppActivities_ConfigPropertyNames);
3739
3753
  // Invalid or incomplete config
3740
3754
  if (config === null) {
3741
3755
  return null;
@@ -3778,8 +3792,8 @@ const notifyChangeFactory$5 = (luvio, options) => {
3778
3792
  };
3779
3793
  };
3780
3794
 
3781
- function select$n(luvio, params) {
3782
- return select$q();
3795
+ function select$o(luvio, params) {
3796
+ return select$r();
3783
3797
  }
3784
3798
  function keyBuilder$k(luvio, params) {
3785
3799
  return keyBuilder$o(luvio, {
@@ -3787,16 +3801,16 @@ function keyBuilder$k(luvio, params) {
3787
3801
  id: params.urlParams.id
3788
3802
  });
3789
3803
  }
3790
- function getResponseCacheKeys$a(storeKeyMap, luvio, resourceParams, response) {
3804
+ function getResponseCacheKeys$b(storeKeyMap, luvio, resourceParams, response) {
3791
3805
  getTypeCacheKeys$9(storeKeyMap, luvio, response);
3792
3806
  }
3793
- function ingestSuccess$a(luvio, resourceParams, response, snapshotRefresh) {
3807
+ function ingestSuccess$b(luvio, resourceParams, response, snapshotRefresh) {
3794
3808
  const { body } = response;
3795
3809
  const key = keyBuilder$k(luvio, resourceParams);
3796
3810
  luvio.storeIngest(key, ingest$9, body);
3797
3811
  const snapshot = luvio.storeLookup({
3798
3812
  recordId: key,
3799
- node: select$n(),
3813
+ node: select$o(),
3800
3814
  variables: {},
3801
3815
  }, snapshotRefresh);
3802
3816
  if (process.env.NODE_ENV !== 'production') {
@@ -3819,7 +3833,7 @@ function ingestError$7(luvio, params, error, snapshotRefresh) {
3819
3833
  luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
3820
3834
  return errorSnapshot;
3821
3835
  }
3822
- function createResourceRequest$a(config) {
3836
+ function createResourceRequest$b(config) {
3823
3837
  const headers = {};
3824
3838
  return {
3825
3839
  baseUri: '/services/data/v63.0',
@@ -3838,64 +3852,64 @@ function createResourceRequestFromRepresentation$4(representation) {
3838
3852
  };
3839
3853
  config.urlParams.appIdOrApiName = representation.appId;
3840
3854
  config.urlParams.id = representation.id;
3841
- return createResourceRequest$a(config);
3855
+ return createResourceRequest$b(config);
3842
3856
  }
3843
3857
 
3844
- const adapterName$a = 'getAppActivity';
3858
+ const adapterName$b = 'getAppActivity';
3845
3859
  const getAppActivity_ConfigPropertyMetadata = [
3846
3860
  generateParamConfigMetadata('appIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
3847
3861
  generateParamConfigMetadata('id', true, 0 /* UrlParameter */, 0 /* String */),
3848
3862
  ];
3849
- const getAppActivity_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$a, getAppActivity_ConfigPropertyMetadata);
3850
- const createResourceParams$a = /*#__PURE__*/ createResourceParams$h(getAppActivity_ConfigPropertyMetadata);
3863
+ const getAppActivity_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$b, getAppActivity_ConfigPropertyMetadata);
3864
+ const createResourceParams$b = /*#__PURE__*/ createResourceParams$i(getAppActivity_ConfigPropertyMetadata);
3851
3865
  function keyBuilder$j(luvio, config) {
3852
- const resourceParams = createResourceParams$a(config);
3866
+ const resourceParams = createResourceParams$b(config);
3853
3867
  return keyBuilder$k(luvio, resourceParams);
3854
3868
  }
3855
- function typeCheckConfig$a(untrustedConfig) {
3869
+ function typeCheckConfig$b(untrustedConfig) {
3856
3870
  const config = {};
3857
- typeCheckConfig$h(untrustedConfig, config, getAppActivity_ConfigPropertyMetadata);
3871
+ typeCheckConfig$i(untrustedConfig, config, getAppActivity_ConfigPropertyMetadata);
3858
3872
  return config;
3859
3873
  }
3860
- function validateAdapterConfig$a(untrustedConfig, configPropertyNames) {
3874
+ function validateAdapterConfig$b(untrustedConfig, configPropertyNames) {
3861
3875
  if (!untrustedIsObject(untrustedConfig)) {
3862
3876
  return null;
3863
3877
  }
3864
3878
  if (process.env.NODE_ENV !== 'production') {
3865
3879
  validateConfig(untrustedConfig, configPropertyNames);
3866
3880
  }
3867
- const config = typeCheckConfig$a(untrustedConfig);
3881
+ const config = typeCheckConfig$b(untrustedConfig);
3868
3882
  if (!areRequiredParametersPresent(config, configPropertyNames)) {
3869
3883
  return null;
3870
3884
  }
3871
3885
  return config;
3872
3886
  }
3873
3887
  function adapterFragment$7(luvio, config) {
3874
- createResourceParams$a(config);
3875
- return select$n();
3888
+ createResourceParams$b(config);
3889
+ return select$o();
3876
3890
  }
3877
3891
  function onFetchResponseSuccess$7(luvio, config, resourceParams, response) {
3878
- const snapshot = ingestSuccess$a(luvio, resourceParams, response, {
3892
+ const snapshot = ingestSuccess$b(luvio, resourceParams, response, {
3879
3893
  config,
3880
- resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
3894
+ resolve: () => buildNetworkSnapshot$b(luvio, config, snapshotRefreshOptions)
3881
3895
  });
3882
3896
  return luvio.storeBroadcast().then(() => snapshot);
3883
3897
  }
3884
3898
  function onFetchResponseError$7(luvio, config, resourceParams, response) {
3885
3899
  const snapshot = ingestError$7(luvio, resourceParams, response, {
3886
3900
  config,
3887
- resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
3901
+ resolve: () => buildNetworkSnapshot$b(luvio, config, snapshotRefreshOptions)
3888
3902
  });
3889
3903
  return luvio.storeBroadcast().then(() => snapshot);
3890
3904
  }
3891
- function buildNetworkSnapshot$a(luvio, config, options) {
3892
- const resourceParams = createResourceParams$a(config);
3893
- const request = createResourceRequest$a(resourceParams);
3905
+ function buildNetworkSnapshot$b(luvio, config, options) {
3906
+ const resourceParams = createResourceParams$b(config);
3907
+ const request = createResourceRequest$b(resourceParams);
3894
3908
  return luvio.dispatchResourceRequest(request, options)
3895
3909
  .then((response) => {
3896
3910
  return luvio.handleSuccessResponse(() => onFetchResponseSuccess$7(luvio, config, resourceParams, response), () => {
3897
3911
  const cache = new StoreKeyMap();
3898
- getResponseCacheKeys$a(cache, luvio, resourceParams, response.body);
3912
+ getResponseCacheKeys$b(cache, luvio, resourceParams, response.body);
3899
3913
  return cache;
3900
3914
  });
3901
3915
  }, (response) => {
@@ -3903,7 +3917,7 @@ function buildNetworkSnapshot$a(luvio, config, options) {
3903
3917
  });
3904
3918
  }
3905
3919
  function buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext) {
3906
- return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$a, undefined, false);
3920
+ return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$b, undefined, false);
3907
3921
  }
3908
3922
  function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
3909
3923
  const { luvio, config } = context;
@@ -3914,12 +3928,12 @@ function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
3914
3928
  };
3915
3929
  const cacheSnapshot = storeLookup(selector, {
3916
3930
  config,
3917
- resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
3931
+ resolve: () => buildNetworkSnapshot$b(luvio, config, snapshotRefreshOptions)
3918
3932
  });
3919
3933
  return cacheSnapshot;
3920
3934
  }
3921
3935
  const getAppActivityAdapterFactory = (luvio) => function AppFramework__getAppActivity(untrustedConfig, requestContext) {
3922
- const config = validateAdapterConfig$a(untrustedConfig, getAppActivity_ConfigPropertyNames);
3936
+ const config = validateAdapterConfig$b(untrustedConfig, getAppActivity_ConfigPropertyNames);
3923
3937
  // Invalid or incomplete config
3924
3938
  if (config === null) {
3925
3939
  return null;
@@ -4130,7 +4144,7 @@ function keyBuilderFromType$4(luvio, object) {
4130
4144
  function normalize$7(input, existing, path, luvio, store, timestamp) {
4131
4145
  return input;
4132
4146
  }
4133
- const select$m = function AssetRepresentationSelect() {
4147
+ const select$n = function AssetRepresentationSelect() {
4134
4148
  return {
4135
4149
  kind: 'Fragment',
4136
4150
  version: VERSION$c,
@@ -4292,7 +4306,7 @@ function normalize$6(input, existing, path, luvio, store, timestamp) {
4292
4306
  }
4293
4307
  return input;
4294
4308
  }
4295
- const select$l = function AssetCollectionRepresentationSelect() {
4309
+ const select$m = function AssetCollectionRepresentationSelect() {
4296
4310
  return {
4297
4311
  kind: 'Fragment',
4298
4312
  version: VERSION$b,
@@ -4306,7 +4320,7 @@ const select$l = function AssetCollectionRepresentationSelect() {
4306
4320
  name: 'assets',
4307
4321
  kind: 'Link',
4308
4322
  plural: true,
4309
- fragment: select$m()
4323
+ fragment: select$n()
4310
4324
  }
4311
4325
  ]
4312
4326
  };
@@ -4355,24 +4369,24 @@ function getTypeCacheKeys$6(rootKeySet, luvio, input, fullPathFactory) {
4355
4369
  }
4356
4370
  }
4357
4371
 
4358
- function select$k(luvio, params) {
4359
- return select$l();
4372
+ function select$l(luvio, params) {
4373
+ return select$m();
4360
4374
  }
4361
4375
  function keyBuilder$g(luvio, params) {
4362
4376
  return keyBuilder$h(luvio, {
4363
4377
  appId: params.urlParams.appIdOrApiName
4364
4378
  });
4365
4379
  }
4366
- function getResponseCacheKeys$9(storeKeyMap, luvio, resourceParams, response) {
4380
+ function getResponseCacheKeys$a(storeKeyMap, luvio, resourceParams, response) {
4367
4381
  getTypeCacheKeys$6(storeKeyMap, luvio, response);
4368
4382
  }
4369
- function ingestSuccess$9(luvio, resourceParams, response, snapshotRefresh) {
4383
+ function ingestSuccess$a(luvio, resourceParams, response, snapshotRefresh) {
4370
4384
  const { body } = response;
4371
4385
  const key = keyBuilder$g(luvio, resourceParams);
4372
4386
  luvio.storeIngest(key, ingest$6, body);
4373
4387
  const snapshot = luvio.storeLookup({
4374
4388
  recordId: key,
4375
- node: select$k(),
4389
+ node: select$l(),
4376
4390
  variables: {},
4377
4391
  }, snapshotRefresh);
4378
4392
  if (process.env.NODE_ENV !== 'production') {
@@ -4395,7 +4409,7 @@ function ingestError$6(luvio, params, error, snapshotRefresh) {
4395
4409
  luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
4396
4410
  return errorSnapshot;
4397
4411
  }
4398
- function createResourceRequest$9(config) {
4412
+ function createResourceRequest$a(config) {
4399
4413
  const headers = {};
4400
4414
  return {
4401
4415
  baseUri: '/services/data/v63.0',
@@ -4414,65 +4428,65 @@ function createResourceRequestFromRepresentation$3(representation) {
4414
4428
  queryParams: {},
4415
4429
  };
4416
4430
  config.urlParams.appIdOrApiName = representation.appId;
4417
- return createResourceRequest$9(config);
4431
+ return createResourceRequest$a(config);
4418
4432
  }
4419
4433
 
4420
- const adapterName$9 = 'getAppAssets';
4434
+ const adapterName$a = 'getAppAssets';
4421
4435
  const getAppAssets_ConfigPropertyMetadata = [
4422
4436
  generateParamConfigMetadata('appIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
4423
4437
  generateParamConfigMetadata('assetType', false, 1 /* QueryParameter */, 0 /* String */),
4424
4438
  generateParamConfigMetadata('templateAssetName', false, 1 /* QueryParameter */, 0 /* String */),
4425
4439
  ];
4426
- const getAppAssets_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$9, getAppAssets_ConfigPropertyMetadata);
4427
- const createResourceParams$9 = /*#__PURE__*/ createResourceParams$h(getAppAssets_ConfigPropertyMetadata);
4440
+ const getAppAssets_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$a, getAppAssets_ConfigPropertyMetadata);
4441
+ const createResourceParams$a = /*#__PURE__*/ createResourceParams$i(getAppAssets_ConfigPropertyMetadata);
4428
4442
  function keyBuilder$f(luvio, config) {
4429
- const resourceParams = createResourceParams$9(config);
4443
+ const resourceParams = createResourceParams$a(config);
4430
4444
  return keyBuilder$g(luvio, resourceParams);
4431
4445
  }
4432
- function typeCheckConfig$9(untrustedConfig) {
4446
+ function typeCheckConfig$a(untrustedConfig) {
4433
4447
  const config = {};
4434
- typeCheckConfig$h(untrustedConfig, config, getAppAssets_ConfigPropertyMetadata);
4448
+ typeCheckConfig$i(untrustedConfig, config, getAppAssets_ConfigPropertyMetadata);
4435
4449
  return config;
4436
4450
  }
4437
- function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
4451
+ function validateAdapterConfig$a(untrustedConfig, configPropertyNames) {
4438
4452
  if (!untrustedIsObject(untrustedConfig)) {
4439
4453
  return null;
4440
4454
  }
4441
4455
  if (process.env.NODE_ENV !== 'production') {
4442
4456
  validateConfig(untrustedConfig, configPropertyNames);
4443
4457
  }
4444
- const config = typeCheckConfig$9(untrustedConfig);
4458
+ const config = typeCheckConfig$a(untrustedConfig);
4445
4459
  if (!areRequiredParametersPresent(config, configPropertyNames)) {
4446
4460
  return null;
4447
4461
  }
4448
4462
  return config;
4449
4463
  }
4450
4464
  function adapterFragment$6(luvio, config) {
4451
- createResourceParams$9(config);
4452
- return select$k();
4465
+ createResourceParams$a(config);
4466
+ return select$l();
4453
4467
  }
4454
4468
  function onFetchResponseSuccess$6(luvio, config, resourceParams, response) {
4455
- const snapshot = ingestSuccess$9(luvio, resourceParams, response, {
4469
+ const snapshot = ingestSuccess$a(luvio, resourceParams, response, {
4456
4470
  config,
4457
- resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
4471
+ resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
4458
4472
  });
4459
4473
  return luvio.storeBroadcast().then(() => snapshot);
4460
4474
  }
4461
4475
  function onFetchResponseError$6(luvio, config, resourceParams, response) {
4462
4476
  const snapshot = ingestError$6(luvio, resourceParams, response, {
4463
4477
  config,
4464
- resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
4478
+ resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
4465
4479
  });
4466
4480
  return luvio.storeBroadcast().then(() => snapshot);
4467
4481
  }
4468
- function buildNetworkSnapshot$9(luvio, config, options) {
4469
- const resourceParams = createResourceParams$9(config);
4470
- const request = createResourceRequest$9(resourceParams);
4482
+ function buildNetworkSnapshot$a(luvio, config, options) {
4483
+ const resourceParams = createResourceParams$a(config);
4484
+ const request = createResourceRequest$a(resourceParams);
4471
4485
  return luvio.dispatchResourceRequest(request, options)
4472
4486
  .then((response) => {
4473
4487
  return luvio.handleSuccessResponse(() => onFetchResponseSuccess$6(luvio, config, resourceParams, response), () => {
4474
4488
  const cache = new StoreKeyMap();
4475
- getResponseCacheKeys$9(cache, luvio, resourceParams, response.body);
4489
+ getResponseCacheKeys$a(cache, luvio, resourceParams, response.body);
4476
4490
  return cache;
4477
4491
  });
4478
4492
  }, (response) => {
@@ -4480,7 +4494,7 @@ function buildNetworkSnapshot$9(luvio, config, options) {
4480
4494
  });
4481
4495
  }
4482
4496
  function buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext) {
4483
- return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$9, undefined, false);
4497
+ return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$a, undefined, false);
4484
4498
  }
4485
4499
  function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
4486
4500
  const { luvio, config } = context;
@@ -4491,12 +4505,12 @@ function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
4491
4505
  };
4492
4506
  const cacheSnapshot = storeLookup(selector, {
4493
4507
  config,
4494
- resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
4508
+ resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
4495
4509
  });
4496
4510
  return cacheSnapshot;
4497
4511
  }
4498
4512
  const getAppAssetsAdapterFactory = (luvio) => function AppFramework__getAppAssets(untrustedConfig, requestContext) {
4499
- const config = validateAdapterConfig$9(untrustedConfig, getAppAssets_ConfigPropertyNames);
4513
+ const config = validateAdapterConfig$a(untrustedConfig, getAppAssets_ConfigPropertyNames);
4500
4514
  // Invalid or incomplete config
4501
4515
  if (config === null) {
4502
4516
  return null;
@@ -4581,7 +4595,7 @@ function normalize$5(input, existing, path, luvio, store, timestamp) {
4581
4595
  }
4582
4596
  return input;
4583
4597
  }
4584
- const select$j = function AppCollectionRepresentationSelect() {
4598
+ const select$k = function AppCollectionRepresentationSelect() {
4585
4599
  return {
4586
4600
  kind: 'Fragment',
4587
4601
  version: VERSION$a,
@@ -4591,7 +4605,7 @@ const select$j = function AppCollectionRepresentationSelect() {
4591
4605
  name: 'apps',
4592
4606
  kind: 'Link',
4593
4607
  plural: true,
4594
- fragment: select$C()
4608
+ fragment: select$D()
4595
4609
  }
4596
4610
  ]
4597
4611
  };
@@ -4635,22 +4649,22 @@ function getTypeCacheKeys$5(rootKeySet, luvio, input, fullPathFactory) {
4635
4649
  }
4636
4650
  }
4637
4651
 
4638
- function select$i(luvio, params) {
4639
- return select$j();
4652
+ function select$j(luvio, params) {
4653
+ return select$k();
4640
4654
  }
4641
4655
  function keyBuilder$e(luvio, params) {
4642
4656
  return keyPrefix + '::AppCollectionRepresentation:(' + 'templateSourceId:' + params.queryParams.templateSourceId + ',' + 'type:' + params.queryParams.type + ')';
4643
4657
  }
4644
- function getResponseCacheKeys$8(storeKeyMap, luvio, resourceParams, response) {
4658
+ function getResponseCacheKeys$9(storeKeyMap, luvio, resourceParams, response) {
4645
4659
  getTypeCacheKeys$5(storeKeyMap, luvio, response, () => keyBuilder$e(luvio, resourceParams));
4646
4660
  }
4647
- function ingestSuccess$8(luvio, resourceParams, response, snapshotRefresh) {
4661
+ function ingestSuccess$9(luvio, resourceParams, response, snapshotRefresh) {
4648
4662
  const { body } = response;
4649
4663
  const key = keyBuilder$e(luvio, resourceParams);
4650
4664
  luvio.storeIngest(key, ingest$5, body);
4651
4665
  const snapshot = luvio.storeLookup({
4652
4666
  recordId: key,
4653
- node: select$i(),
4667
+ node: select$j(),
4654
4668
  variables: {},
4655
4669
  }, snapshotRefresh);
4656
4670
  if (process.env.NODE_ENV !== 'production') {
@@ -4673,7 +4687,7 @@ function ingestError$5(luvio, params, error, snapshotRefresh) {
4673
4687
  luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
4674
4688
  return errorSnapshot;
4675
4689
  }
4676
- function createResourceRequest$8(config) {
4690
+ function createResourceRequest$9(config) {
4677
4691
  const headers = {};
4678
4692
  return {
4679
4693
  baseUri: '/services/data/v63.0',
@@ -4687,61 +4701,61 @@ function createResourceRequest$8(config) {
4687
4701
  };
4688
4702
  }
4689
4703
 
4690
- const adapterName$8 = 'getApps';
4704
+ const adapterName$9 = 'getApps';
4691
4705
  const getApps_ConfigPropertyMetadata = [
4692
4706
  generateParamConfigMetadata('templateSourceId', false, 1 /* QueryParameter */, 0 /* String */),
4693
4707
  generateParamConfigMetadata('type', false, 1 /* QueryParameter */, 0 /* String */),
4694
4708
  ];
4695
- const getApps_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$8, getApps_ConfigPropertyMetadata);
4696
- const createResourceParams$8 = /*#__PURE__*/ createResourceParams$h(getApps_ConfigPropertyMetadata);
4709
+ const getApps_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$9, getApps_ConfigPropertyMetadata);
4710
+ const createResourceParams$9 = /*#__PURE__*/ createResourceParams$i(getApps_ConfigPropertyMetadata);
4697
4711
  function keyBuilder$d(luvio, config) {
4698
- const resourceParams = createResourceParams$8(config);
4712
+ const resourceParams = createResourceParams$9(config);
4699
4713
  return keyBuilder$e(luvio, resourceParams);
4700
4714
  }
4701
- function typeCheckConfig$8(untrustedConfig) {
4715
+ function typeCheckConfig$9(untrustedConfig) {
4702
4716
  const config = {};
4703
- typeCheckConfig$h(untrustedConfig, config, getApps_ConfigPropertyMetadata);
4717
+ typeCheckConfig$i(untrustedConfig, config, getApps_ConfigPropertyMetadata);
4704
4718
  return config;
4705
4719
  }
4706
- function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
4720
+ function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
4707
4721
  if (!untrustedIsObject(untrustedConfig)) {
4708
4722
  return null;
4709
4723
  }
4710
4724
  if (process.env.NODE_ENV !== 'production') {
4711
4725
  validateConfig(untrustedConfig, configPropertyNames);
4712
4726
  }
4713
- const config = typeCheckConfig$8(untrustedConfig);
4727
+ const config = typeCheckConfig$9(untrustedConfig);
4714
4728
  if (!areRequiredParametersPresent(config, configPropertyNames)) {
4715
4729
  return null;
4716
4730
  }
4717
4731
  return config;
4718
4732
  }
4719
4733
  function adapterFragment$5(luvio, config) {
4720
- createResourceParams$8(config);
4721
- return select$i();
4734
+ createResourceParams$9(config);
4735
+ return select$j();
4722
4736
  }
4723
4737
  function onFetchResponseSuccess$5(luvio, config, resourceParams, response) {
4724
- const snapshot = ingestSuccess$8(luvio, resourceParams, response, {
4738
+ const snapshot = ingestSuccess$9(luvio, resourceParams, response, {
4725
4739
  config,
4726
- resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
4740
+ resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
4727
4741
  });
4728
4742
  return luvio.storeBroadcast().then(() => snapshot);
4729
4743
  }
4730
4744
  function onFetchResponseError$5(luvio, config, resourceParams, response) {
4731
4745
  const snapshot = ingestError$5(luvio, resourceParams, response, {
4732
4746
  config,
4733
- resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
4747
+ resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
4734
4748
  });
4735
4749
  return luvio.storeBroadcast().then(() => snapshot);
4736
4750
  }
4737
- function buildNetworkSnapshot$8(luvio, config, options) {
4738
- const resourceParams = createResourceParams$8(config);
4739
- const request = createResourceRequest$8(resourceParams);
4751
+ function buildNetworkSnapshot$9(luvio, config, options) {
4752
+ const resourceParams = createResourceParams$9(config);
4753
+ const request = createResourceRequest$9(resourceParams);
4740
4754
  return luvio.dispatchResourceRequest(request, options)
4741
4755
  .then((response) => {
4742
4756
  return luvio.handleSuccessResponse(() => onFetchResponseSuccess$5(luvio, config, resourceParams, response), () => {
4743
4757
  const cache = new StoreKeyMap();
4744
- getResponseCacheKeys$8(cache, luvio, resourceParams, response.body);
4758
+ getResponseCacheKeys$9(cache, luvio, resourceParams, response.body);
4745
4759
  return cache;
4746
4760
  });
4747
4761
  }, (response) => {
@@ -4749,7 +4763,7 @@ function buildNetworkSnapshot$8(luvio, config, options) {
4749
4763
  });
4750
4764
  }
4751
4765
  function buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext) {
4752
- return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$8, undefined, false);
4766
+ return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$9, undefined, false);
4753
4767
  }
4754
4768
  function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
4755
4769
  const { luvio, config } = context;
@@ -4760,12 +4774,12 @@ function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
4760
4774
  };
4761
4775
  const cacheSnapshot = storeLookup(selector, {
4762
4776
  config,
4763
- resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
4777
+ resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
4764
4778
  });
4765
4779
  return cacheSnapshot;
4766
4780
  }
4767
4781
  const getAppsAdapterFactory = (luvio) => function AppFramework__getApps(untrustedConfig, requestContext) {
4768
- const config = validateAdapterConfig$8(untrustedConfig, getApps_ConfigPropertyNames);
4782
+ const config = validateAdapterConfig$9(untrustedConfig, getApps_ConfigPropertyNames);
4769
4783
  // Invalid or incomplete config
4770
4784
  if (config === null) {
4771
4785
  return null;
@@ -4816,7 +4830,7 @@ function normalize$4(input, existing, path, luvio, store, timestamp) {
4816
4830
  }
4817
4831
  return input;
4818
4832
  }
4819
- const select$h = function InstalledAssetCollectionRepresentationSelect() {
4833
+ const select$i = function InstalledAssetCollectionRepresentationSelect() {
4820
4834
  return {
4821
4835
  kind: 'Fragment',
4822
4836
  version: VERSION$9,
@@ -4826,7 +4840,7 @@ const select$h = function InstalledAssetCollectionRepresentationSelect() {
4826
4840
  name: 'assets',
4827
4841
  kind: 'Link',
4828
4842
  plural: true,
4829
- fragment: select$m()
4843
+ fragment: select$n()
4830
4844
  }
4831
4845
  ]
4832
4846
  };
@@ -4870,22 +4884,22 @@ function getTypeCacheKeys$4(rootKeySet, luvio, input, fullPathFactory) {
4870
4884
  }
4871
4885
  }
4872
4886
 
4873
- function select$g(luvio, params) {
4874
- return select$h();
4887
+ function select$h(luvio, params) {
4888
+ return select$i();
4875
4889
  }
4876
4890
  function keyBuilder$c(luvio, params) {
4877
4891
  return keyPrefix + '::InstalledAssetCollectionRepresentation:(' + 'assetIdOrName:' + params.queryParams.assetIdOrName + ',' + 'assetType:' + params.queryParams.assetType + ')';
4878
4892
  }
4879
- function getResponseCacheKeys$7(storeKeyMap, luvio, resourceParams, response) {
4893
+ function getResponseCacheKeys$8(storeKeyMap, luvio, resourceParams, response) {
4880
4894
  getTypeCacheKeys$4(storeKeyMap, luvio, response, () => keyBuilder$c(luvio, resourceParams));
4881
4895
  }
4882
- function ingestSuccess$7(luvio, resourceParams, response, snapshotRefresh) {
4896
+ function ingestSuccess$8(luvio, resourceParams, response, snapshotRefresh) {
4883
4897
  const { body } = response;
4884
4898
  const key = keyBuilder$c(luvio, resourceParams);
4885
4899
  luvio.storeIngest(key, ingest$4, body);
4886
4900
  const snapshot = luvio.storeLookup({
4887
4901
  recordId: key,
4888
- node: select$g(),
4902
+ node: select$h(),
4889
4903
  variables: {},
4890
4904
  }, snapshotRefresh);
4891
4905
  if (process.env.NODE_ENV !== 'production') {
@@ -4908,7 +4922,7 @@ function ingestError$4(luvio, params, error, snapshotRefresh) {
4908
4922
  luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
4909
4923
  return errorSnapshot;
4910
4924
  }
4911
- function createResourceRequest$7(config) {
4925
+ function createResourceRequest$8(config) {
4912
4926
  const headers = {};
4913
4927
  return {
4914
4928
  baseUri: '/services/data/v63.0',
@@ -4922,61 +4936,61 @@ function createResourceRequest$7(config) {
4922
4936
  };
4923
4937
  }
4924
4938
 
4925
- const adapterName$7 = 'getInstalledAssets';
4939
+ const adapterName$8 = 'getInstalledAssets';
4926
4940
  const getInstalledAssets_ConfigPropertyMetadata = [
4927
4941
  generateParamConfigMetadata('assetIdOrName', false, 1 /* QueryParameter */, 0 /* String */),
4928
4942
  generateParamConfigMetadata('assetType', false, 1 /* QueryParameter */, 0 /* String */),
4929
4943
  ];
4930
- const getInstalledAssets_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$7, getInstalledAssets_ConfigPropertyMetadata);
4931
- const createResourceParams$7 = /*#__PURE__*/ createResourceParams$h(getInstalledAssets_ConfigPropertyMetadata);
4944
+ const getInstalledAssets_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$8, getInstalledAssets_ConfigPropertyMetadata);
4945
+ const createResourceParams$8 = /*#__PURE__*/ createResourceParams$i(getInstalledAssets_ConfigPropertyMetadata);
4932
4946
  function keyBuilder$b(luvio, config) {
4933
- const resourceParams = createResourceParams$7(config);
4947
+ const resourceParams = createResourceParams$8(config);
4934
4948
  return keyBuilder$c(luvio, resourceParams);
4935
4949
  }
4936
- function typeCheckConfig$7(untrustedConfig) {
4950
+ function typeCheckConfig$8(untrustedConfig) {
4937
4951
  const config = {};
4938
- typeCheckConfig$h(untrustedConfig, config, getInstalledAssets_ConfigPropertyMetadata);
4952
+ typeCheckConfig$i(untrustedConfig, config, getInstalledAssets_ConfigPropertyMetadata);
4939
4953
  return config;
4940
4954
  }
4941
- function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
4955
+ function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
4942
4956
  if (!untrustedIsObject(untrustedConfig)) {
4943
4957
  return null;
4944
4958
  }
4945
4959
  if (process.env.NODE_ENV !== 'production') {
4946
4960
  validateConfig(untrustedConfig, configPropertyNames);
4947
4961
  }
4948
- const config = typeCheckConfig$7(untrustedConfig);
4962
+ const config = typeCheckConfig$8(untrustedConfig);
4949
4963
  if (!areRequiredParametersPresent(config, configPropertyNames)) {
4950
4964
  return null;
4951
4965
  }
4952
4966
  return config;
4953
4967
  }
4954
4968
  function adapterFragment$4(luvio, config) {
4955
- createResourceParams$7(config);
4956
- return select$g();
4969
+ createResourceParams$8(config);
4970
+ return select$h();
4957
4971
  }
4958
4972
  function onFetchResponseSuccess$4(luvio, config, resourceParams, response) {
4959
- const snapshot = ingestSuccess$7(luvio, resourceParams, response, {
4973
+ const snapshot = ingestSuccess$8(luvio, resourceParams, response, {
4960
4974
  config,
4961
- resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
4975
+ resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
4962
4976
  });
4963
4977
  return luvio.storeBroadcast().then(() => snapshot);
4964
4978
  }
4965
4979
  function onFetchResponseError$4(luvio, config, resourceParams, response) {
4966
4980
  const snapshot = ingestError$4(luvio, resourceParams, response, {
4967
4981
  config,
4968
- resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
4982
+ resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
4969
4983
  });
4970
4984
  return luvio.storeBroadcast().then(() => snapshot);
4971
4985
  }
4972
- function buildNetworkSnapshot$7(luvio, config, options) {
4973
- const resourceParams = createResourceParams$7(config);
4974
- const request = createResourceRequest$7(resourceParams);
4986
+ function buildNetworkSnapshot$8(luvio, config, options) {
4987
+ const resourceParams = createResourceParams$8(config);
4988
+ const request = createResourceRequest$8(resourceParams);
4975
4989
  return luvio.dispatchResourceRequest(request, options)
4976
4990
  .then((response) => {
4977
4991
  return luvio.handleSuccessResponse(() => onFetchResponseSuccess$4(luvio, config, resourceParams, response), () => {
4978
4992
  const cache = new StoreKeyMap();
4979
- getResponseCacheKeys$7(cache, luvio, resourceParams, response.body);
4993
+ getResponseCacheKeys$8(cache, luvio, resourceParams, response.body);
4980
4994
  return cache;
4981
4995
  });
4982
4996
  }, (response) => {
@@ -4984,7 +4998,7 @@ function buildNetworkSnapshot$7(luvio, config, options) {
4984
4998
  });
4985
4999
  }
4986
5000
  function buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext) {
4987
- return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$7, undefined, false);
5001
+ return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$8, undefined, false);
4988
5002
  }
4989
5003
  function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
4990
5004
  const { luvio, config } = context;
@@ -4995,12 +5009,12 @@ function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
4995
5009
  };
4996
5010
  const cacheSnapshot = storeLookup(selector, {
4997
5011
  config,
4998
- resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
5012
+ resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
4999
5013
  });
5000
5014
  return cacheSnapshot;
5001
5015
  }
5002
5016
  const getInstalledAssetsAdapterFactory = (luvio) => function AppFramework__getInstalledAssets(untrustedConfig, requestContext) {
5003
- const config = validateAdapterConfig$7(untrustedConfig, getInstalledAssets_ConfigPropertyNames);
5017
+ const config = validateAdapterConfig$8(untrustedConfig, getInstalledAssets_ConfigPropertyNames);
5004
5018
  // Invalid or incomplete config
5005
5019
  if (config === null) {
5006
5020
  return null;
@@ -5051,7 +5065,7 @@ function keyBuilderFromType$2(luvio, object) {
5051
5065
  function normalize$3(input, existing, path, luvio, store, timestamp) {
5052
5066
  return input;
5053
5067
  }
5054
- const select$f = function TemplateTagCollectionRepresentationSelect() {
5068
+ const select$g = function TemplateTagCollectionRepresentationSelect() {
5055
5069
  return {
5056
5070
  kind: 'Fragment',
5057
5071
  version: VERSION$8,
@@ -5109,24 +5123,24 @@ function getTypeCacheKeys$3(rootKeySet, luvio, input, fullPathFactory) {
5109
5123
  });
5110
5124
  }
5111
5125
 
5112
- function select$e(luvio, params) {
5113
- return select$f();
5126
+ function select$f(luvio, params) {
5127
+ return select$g();
5114
5128
  }
5115
5129
  function keyBuilder$9(luvio, params) {
5116
5130
  return keyBuilder$a(luvio, {
5117
5131
  id: params.urlParams.templateIdOrApiName
5118
5132
  });
5119
5133
  }
5120
- function getResponseCacheKeys$6(storeKeyMap, luvio, resourceParams, response) {
5134
+ function getResponseCacheKeys$7(storeKeyMap, luvio, resourceParams, response) {
5121
5135
  getTypeCacheKeys$3(storeKeyMap, luvio, response);
5122
5136
  }
5123
- function ingestSuccess$6(luvio, resourceParams, response, snapshotRefresh) {
5137
+ function ingestSuccess$7(luvio, resourceParams, response, snapshotRefresh) {
5124
5138
  const { body } = response;
5125
5139
  const key = keyBuilder$9(luvio, resourceParams);
5126
5140
  luvio.storeIngest(key, ingest$3, body);
5127
5141
  const snapshot = luvio.storeLookup({
5128
5142
  recordId: key,
5129
- node: select$e(),
5143
+ node: select$f(),
5130
5144
  variables: {},
5131
5145
  }, snapshotRefresh);
5132
5146
  if (process.env.NODE_ENV !== 'production') {
@@ -5149,7 +5163,7 @@ function ingestError$3(luvio, params, error, snapshotRefresh) {
5149
5163
  luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
5150
5164
  return errorSnapshot;
5151
5165
  }
5152
- function createResourceRequest$6(config) {
5166
+ function createResourceRequest$7(config) {
5153
5167
  const headers = {};
5154
5168
  return {
5155
5169
  baseUri: '/services/data/v63.0',
@@ -5167,63 +5181,63 @@ function createResourceRequestFromRepresentation$2(representation) {
5167
5181
  urlParams: {},
5168
5182
  };
5169
5183
  config.urlParams.templateIdOrApiName = representation.templateId;
5170
- return createResourceRequest$6(config);
5184
+ return createResourceRequest$7(config);
5171
5185
  }
5172
5186
 
5173
- const adapterName$6 = 'getTags';
5187
+ const adapterName$7 = 'getTags';
5174
5188
  const getTags_ConfigPropertyMetadata = [
5175
5189
  generateParamConfigMetadata('templateIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
5176
5190
  ];
5177
- const getTags_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$6, getTags_ConfigPropertyMetadata);
5178
- const createResourceParams$6 = /*#__PURE__*/ createResourceParams$h(getTags_ConfigPropertyMetadata);
5191
+ const getTags_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$7, getTags_ConfigPropertyMetadata);
5192
+ const createResourceParams$7 = /*#__PURE__*/ createResourceParams$i(getTags_ConfigPropertyMetadata);
5179
5193
  function keyBuilder$8(luvio, config) {
5180
- const resourceParams = createResourceParams$6(config);
5194
+ const resourceParams = createResourceParams$7(config);
5181
5195
  return keyBuilder$9(luvio, resourceParams);
5182
5196
  }
5183
- function typeCheckConfig$6(untrustedConfig) {
5197
+ function typeCheckConfig$7(untrustedConfig) {
5184
5198
  const config = {};
5185
- typeCheckConfig$h(untrustedConfig, config, getTags_ConfigPropertyMetadata);
5199
+ typeCheckConfig$i(untrustedConfig, config, getTags_ConfigPropertyMetadata);
5186
5200
  return config;
5187
5201
  }
5188
- function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
5202
+ function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
5189
5203
  if (!untrustedIsObject(untrustedConfig)) {
5190
5204
  return null;
5191
5205
  }
5192
5206
  if (process.env.NODE_ENV !== 'production') {
5193
5207
  validateConfig(untrustedConfig, configPropertyNames);
5194
5208
  }
5195
- const config = typeCheckConfig$6(untrustedConfig);
5209
+ const config = typeCheckConfig$7(untrustedConfig);
5196
5210
  if (!areRequiredParametersPresent(config, configPropertyNames)) {
5197
5211
  return null;
5198
5212
  }
5199
5213
  return config;
5200
5214
  }
5201
5215
  function adapterFragment$3(luvio, config) {
5202
- createResourceParams$6(config);
5203
- return select$e();
5216
+ createResourceParams$7(config);
5217
+ return select$f();
5204
5218
  }
5205
5219
  function onFetchResponseSuccess$3(luvio, config, resourceParams, response) {
5206
- const snapshot = ingestSuccess$6(luvio, resourceParams, response, {
5220
+ const snapshot = ingestSuccess$7(luvio, resourceParams, response, {
5207
5221
  config,
5208
- resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
5222
+ resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
5209
5223
  });
5210
5224
  return luvio.storeBroadcast().then(() => snapshot);
5211
5225
  }
5212
5226
  function onFetchResponseError$3(luvio, config, resourceParams, response) {
5213
5227
  const snapshot = ingestError$3(luvio, resourceParams, response, {
5214
5228
  config,
5215
- resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
5229
+ resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
5216
5230
  });
5217
5231
  return luvio.storeBroadcast().then(() => snapshot);
5218
5232
  }
5219
- function buildNetworkSnapshot$6(luvio, config, options) {
5220
- const resourceParams = createResourceParams$6(config);
5221
- const request = createResourceRequest$6(resourceParams);
5233
+ function buildNetworkSnapshot$7(luvio, config, options) {
5234
+ const resourceParams = createResourceParams$7(config);
5235
+ const request = createResourceRequest$7(resourceParams);
5222
5236
  return luvio.dispatchResourceRequest(request, options)
5223
5237
  .then((response) => {
5224
5238
  return luvio.handleSuccessResponse(() => onFetchResponseSuccess$3(luvio, config, resourceParams, response), () => {
5225
5239
  const cache = new StoreKeyMap();
5226
- getResponseCacheKeys$6(cache, luvio, resourceParams, response.body);
5240
+ getResponseCacheKeys$7(cache, luvio, resourceParams, response.body);
5227
5241
  return cache;
5228
5242
  });
5229
5243
  }, (response) => {
@@ -5231,7 +5245,7 @@ function buildNetworkSnapshot$6(luvio, config, options) {
5231
5245
  });
5232
5246
  }
5233
5247
  function buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext) {
5234
- return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$6, undefined, false);
5248
+ return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$7, undefined, false);
5235
5249
  }
5236
5250
  function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
5237
5251
  const { luvio, config } = context;
@@ -5242,12 +5256,12 @@ function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
5242
5256
  };
5243
5257
  const cacheSnapshot = storeLookup(selector, {
5244
5258
  config,
5245
- resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
5259
+ resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
5246
5260
  });
5247
5261
  return cacheSnapshot;
5248
5262
  }
5249
5263
  const getTagsAdapterFactory = (luvio) => function AppFramework__getTags(untrustedConfig, requestContext) {
5250
- const config = validateAdapterConfig$6(untrustedConfig, getTags_ConfigPropertyNames);
5264
+ const config = validateAdapterConfig$7(untrustedConfig, getTags_ConfigPropertyNames);
5251
5265
  // Invalid or incomplete config
5252
5266
  if (config === null) {
5253
5267
  return null;
@@ -5290,24 +5304,24 @@ const notifyChangeFactory$2 = (luvio, options) => {
5290
5304
  };
5291
5305
  };
5292
5306
 
5293
- function select$d(luvio, params) {
5294
- return select$t();
5307
+ function select$e(luvio, params) {
5308
+ return select$u();
5295
5309
  }
5296
5310
  function keyBuilder$7(luvio, params) {
5297
5311
  return keyBuilder$t(luvio, {
5298
5312
  id: params.urlParams.templateIdOrApiName
5299
5313
  });
5300
5314
  }
5301
- function getResponseCacheKeys$5(storeKeyMap, luvio, resourceParams, response) {
5315
+ function getResponseCacheKeys$6(storeKeyMap, luvio, resourceParams, response) {
5302
5316
  getTypeCacheKeys$a(storeKeyMap, luvio, response);
5303
5317
  }
5304
- function ingestSuccess$5(luvio, resourceParams, response, snapshotRefresh) {
5318
+ function ingestSuccess$6(luvio, resourceParams, response, snapshotRefresh) {
5305
5319
  const { body } = response;
5306
5320
  const key = keyBuilder$7(luvio, resourceParams);
5307
5321
  luvio.storeIngest(key, ingest$a, body);
5308
5322
  const snapshot = luvio.storeLookup({
5309
5323
  recordId: key,
5310
- node: select$d(),
5324
+ node: select$e(),
5311
5325
  variables: {},
5312
5326
  }, snapshotRefresh);
5313
5327
  if (process.env.NODE_ENV !== 'production') {
@@ -5330,7 +5344,7 @@ function ingestError$2(luvio, params, error, snapshotRefresh) {
5330
5344
  luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
5331
5345
  return errorSnapshot;
5332
5346
  }
5333
- function createResourceRequest$5(config) {
5347
+ function createResourceRequest$6(config) {
5334
5348
  const headers = {};
5335
5349
  return {
5336
5350
  baseUri: '/services/data/v63.0',
@@ -5348,63 +5362,63 @@ function createResourceRequestFromRepresentation$1(representation) {
5348
5362
  urlParams: {},
5349
5363
  };
5350
5364
  config.urlParams.templateIdOrApiName = representation.id;
5351
- return createResourceRequest$5(config);
5365
+ return createResourceRequest$6(config);
5352
5366
  }
5353
5367
 
5354
- const adapterName$5 = 'getTemplate';
5368
+ const adapterName$6 = 'getTemplate';
5355
5369
  const getTemplate_ConfigPropertyMetadata = [
5356
5370
  generateParamConfigMetadata('templateIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
5357
5371
  ];
5358
- const getTemplate_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, getTemplate_ConfigPropertyMetadata);
5359
- const createResourceParams$5 = /*#__PURE__*/ createResourceParams$h(getTemplate_ConfigPropertyMetadata);
5372
+ const getTemplate_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$6, getTemplate_ConfigPropertyMetadata);
5373
+ const createResourceParams$6 = /*#__PURE__*/ createResourceParams$i(getTemplate_ConfigPropertyMetadata);
5360
5374
  function keyBuilder$6(luvio, config) {
5361
- const resourceParams = createResourceParams$5(config);
5375
+ const resourceParams = createResourceParams$6(config);
5362
5376
  return keyBuilder$7(luvio, resourceParams);
5363
5377
  }
5364
- function typeCheckConfig$5(untrustedConfig) {
5378
+ function typeCheckConfig$6(untrustedConfig) {
5365
5379
  const config = {};
5366
- typeCheckConfig$h(untrustedConfig, config, getTemplate_ConfigPropertyMetadata);
5380
+ typeCheckConfig$i(untrustedConfig, config, getTemplate_ConfigPropertyMetadata);
5367
5381
  return config;
5368
5382
  }
5369
- function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
5383
+ function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
5370
5384
  if (!untrustedIsObject(untrustedConfig)) {
5371
5385
  return null;
5372
5386
  }
5373
5387
  if (process.env.NODE_ENV !== 'production') {
5374
5388
  validateConfig(untrustedConfig, configPropertyNames);
5375
5389
  }
5376
- const config = typeCheckConfig$5(untrustedConfig);
5390
+ const config = typeCheckConfig$6(untrustedConfig);
5377
5391
  if (!areRequiredParametersPresent(config, configPropertyNames)) {
5378
5392
  return null;
5379
5393
  }
5380
5394
  return config;
5381
5395
  }
5382
5396
  function adapterFragment$2(luvio, config) {
5383
- createResourceParams$5(config);
5384
- return select$d();
5397
+ createResourceParams$6(config);
5398
+ return select$e();
5385
5399
  }
5386
5400
  function onFetchResponseSuccess$2(luvio, config, resourceParams, response) {
5387
- const snapshot = ingestSuccess$5(luvio, resourceParams, response, {
5401
+ const snapshot = ingestSuccess$6(luvio, resourceParams, response, {
5388
5402
  config,
5389
- resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
5403
+ resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
5390
5404
  });
5391
5405
  return luvio.storeBroadcast().then(() => snapshot);
5392
5406
  }
5393
5407
  function onFetchResponseError$2(luvio, config, resourceParams, response) {
5394
5408
  const snapshot = ingestError$2(luvio, resourceParams, response, {
5395
5409
  config,
5396
- resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
5410
+ resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
5397
5411
  });
5398
5412
  return luvio.storeBroadcast().then(() => snapshot);
5399
5413
  }
5400
- function buildNetworkSnapshot$5(luvio, config, options) {
5401
- const resourceParams = createResourceParams$5(config);
5402
- const request = createResourceRequest$5(resourceParams);
5414
+ function buildNetworkSnapshot$6(luvio, config, options) {
5415
+ const resourceParams = createResourceParams$6(config);
5416
+ const request = createResourceRequest$6(resourceParams);
5403
5417
  return luvio.dispatchResourceRequest(request, options)
5404
5418
  .then((response) => {
5405
5419
  return luvio.handleSuccessResponse(() => onFetchResponseSuccess$2(luvio, config, resourceParams, response), () => {
5406
5420
  const cache = new StoreKeyMap();
5407
- getResponseCacheKeys$5(cache, luvio, resourceParams, response.body);
5421
+ getResponseCacheKeys$6(cache, luvio, resourceParams, response.body);
5408
5422
  return cache;
5409
5423
  });
5410
5424
  }, (response) => {
@@ -5412,7 +5426,7 @@ function buildNetworkSnapshot$5(luvio, config, options) {
5412
5426
  });
5413
5427
  }
5414
5428
  function buildNetworkSnapshotCachePolicy$2(context, coercedAdapterRequestContext) {
5415
- return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$5, undefined, false);
5429
+ return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$6, undefined, false);
5416
5430
  }
5417
5431
  function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
5418
5432
  const { luvio, config } = context;
@@ -5423,12 +5437,12 @@ function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
5423
5437
  };
5424
5438
  const cacheSnapshot = storeLookup(selector, {
5425
5439
  config,
5426
- resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
5440
+ resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
5427
5441
  });
5428
5442
  return cacheSnapshot;
5429
5443
  }
5430
5444
  const getTemplateAdapterFactory = (luvio) => function AppFramework__getTemplate(untrustedConfig, requestContext) {
5431
- const config = validateAdapterConfig$5(untrustedConfig, getTemplate_ConfigPropertyNames);
5445
+ const config = validateAdapterConfig$6(untrustedConfig, getTemplate_ConfigPropertyNames);
5432
5446
  // Invalid or incomplete config
5433
5447
  if (config === null) {
5434
5448
  return null;
@@ -5528,8 +5542,8 @@ function validate$8(obj, path = 'GuidancePanelRepresentation') {
5528
5542
  })();
5529
5543
  return v_error === undefined ? null : v_error;
5530
5544
  }
5531
- const select$c = function GuidancePanelRepresentationSelect() {
5532
- const { selections: ImageReferenceRepresentation__selections, opaque: ImageReferenceRepresentation__opaque, } = select$y();
5545
+ const select$d = function GuidancePanelRepresentationSelect() {
5546
+ const { selections: ImageReferenceRepresentation__selections, opaque: ImageReferenceRepresentation__opaque, } = select$z();
5533
5547
  return {
5534
5548
  kind: 'Fragment',
5535
5549
  version: VERSION$7,
@@ -5608,7 +5622,7 @@ function validate$7(obj, path = 'PageNavigationInfoRepresentation') {
5608
5622
  })();
5609
5623
  return v_error === undefined ? null : v_error;
5610
5624
  }
5611
- const select$b = function PageNavigationInfoRepresentationSelect() {
5625
+ const select$c = function PageNavigationInfoRepresentationSelect() {
5612
5626
  return {
5613
5627
  kind: 'Fragment',
5614
5628
  version: VERSION$6,
@@ -5686,9 +5700,9 @@ function validate$6(obj, path = 'AppDetailsRepresentation') {
5686
5700
  })();
5687
5701
  return v_error === undefined ? null : v_error;
5688
5702
  }
5689
- const select$a = function AppDetailsRepresentationSelect() {
5690
- const { selections: GuidancePanelRepresentation__selections, opaque: GuidancePanelRepresentation__opaque, } = select$c();
5691
- const { selections: PageNavigationInfoRepresentation__selections, opaque: PageNavigationInfoRepresentation__opaque, } = select$b();
5703
+ const select$b = function AppDetailsRepresentationSelect() {
5704
+ const { selections: GuidancePanelRepresentation__selections, opaque: GuidancePanelRepresentation__opaque, } = select$d();
5705
+ const { selections: PageNavigationInfoRepresentation__selections, opaque: PageNavigationInfoRepresentation__opaque, } = select$c();
5692
5706
  return {
5693
5707
  kind: 'Fragment',
5694
5708
  version: VERSION$5,
@@ -5753,7 +5767,7 @@ function validate$5(obj, path = 'NavigationPanelRepresentation') {
5753
5767
  })();
5754
5768
  return v_error === undefined ? null : v_error;
5755
5769
  }
5756
- const select$9 = function NavigationPanelRepresentationSelect() {
5770
+ const select$a = function NavigationPanelRepresentationSelect() {
5757
5771
  return {
5758
5772
  kind: 'Fragment',
5759
5773
  version: VERSION$4,
@@ -5828,9 +5842,9 @@ function validate$4(obj, path = 'UiLayoutDefinitionRepresentation') {
5828
5842
  })();
5829
5843
  return v_error === undefined ? null : v_error;
5830
5844
  }
5831
- const select$8 = function UiLayoutDefinitionRepresentationSelect() {
5832
- const { selections: AppDetailsRepresentation__selections, opaque: AppDetailsRepresentation__opaque, } = select$a();
5833
- const { selections: NavigationPanelRepresentation__selections, opaque: NavigationPanelRepresentation__opaque, } = select$9();
5845
+ const select$9 = function UiLayoutDefinitionRepresentationSelect() {
5846
+ const { selections: AppDetailsRepresentation__selections, opaque: AppDetailsRepresentation__opaque, } = select$b();
5847
+ const { selections: NavigationPanelRepresentation__selections, opaque: NavigationPanelRepresentation__opaque, } = select$a();
5834
5848
  return {
5835
5849
  kind: 'Fragment',
5836
5850
  version: VERSION$3,
@@ -5987,8 +6001,8 @@ function keyBuilderFromType$1(luvio, object) {
5987
6001
  function normalize$2(input, existing, path, luvio, store, timestamp) {
5988
6002
  return input;
5989
6003
  }
5990
- const select$7 = function TemplateConfigurationRepresentationSelect() {
5991
- const { selections: UiLayoutDefinitionRepresentation__selections, opaque: UiLayoutDefinitionRepresentation__opaque, } = select$8();
6004
+ const select$8 = function TemplateConfigurationRepresentationSelect() {
6005
+ const { selections: UiLayoutDefinitionRepresentation__selections, opaque: UiLayoutDefinitionRepresentation__opaque, } = select$9();
5992
6006
  return {
5993
6007
  kind: 'Fragment',
5994
6008
  version: VERSION$2,
@@ -6069,24 +6083,24 @@ function getTypeCacheKeys$2(rootKeySet, luvio, input, fullPathFactory) {
6069
6083
  });
6070
6084
  }
6071
6085
 
6072
- function select$6(luvio, params) {
6073
- return select$7();
6086
+ function select$7(luvio, params) {
6087
+ return select$8();
6074
6088
  }
6075
6089
  function keyBuilder$4(luvio, params) {
6076
6090
  return keyBuilder$5(luvio, {
6077
6091
  id: params.urlParams.templateIdOrApiName
6078
6092
  });
6079
6093
  }
6080
- function getResponseCacheKeys$4(storeKeyMap, luvio, resourceParams, response) {
6094
+ function getResponseCacheKeys$5(storeKeyMap, luvio, resourceParams, response) {
6081
6095
  getTypeCacheKeys$2(storeKeyMap, luvio, response);
6082
6096
  }
6083
- function ingestSuccess$4(luvio, resourceParams, response, snapshotRefresh) {
6097
+ function ingestSuccess$5(luvio, resourceParams, response, snapshotRefresh) {
6084
6098
  const { body } = response;
6085
6099
  const key = keyBuilder$4(luvio, resourceParams);
6086
6100
  luvio.storeIngest(key, ingest$2, body);
6087
6101
  const snapshot = luvio.storeLookup({
6088
6102
  recordId: key,
6089
- node: select$6(),
6103
+ node: select$7(),
6090
6104
  variables: {},
6091
6105
  }, snapshotRefresh);
6092
6106
  if (process.env.NODE_ENV !== 'production') {
@@ -6109,7 +6123,7 @@ function ingestError$1(luvio, params, error, snapshotRefresh) {
6109
6123
  luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
6110
6124
  return errorSnapshot;
6111
6125
  }
6112
- function createResourceRequest$4(config) {
6126
+ function createResourceRequest$5(config) {
6113
6127
  const headers = {};
6114
6128
  return {
6115
6129
  baseUri: '/services/data/v63.0',
@@ -6127,63 +6141,63 @@ function createResourceRequestFromRepresentation(representation) {
6127
6141
  urlParams: {},
6128
6142
  };
6129
6143
  config.urlParams.templateIdOrApiName = representation.id;
6130
- return createResourceRequest$4(config);
6144
+ return createResourceRequest$5(config);
6131
6145
  }
6132
6146
 
6133
- const adapterName$4 = 'getTemplateConfig';
6147
+ const adapterName$5 = 'getTemplateConfig';
6134
6148
  const getTemplateConfig_ConfigPropertyMetadata = [
6135
6149
  generateParamConfigMetadata('templateIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
6136
6150
  ];
6137
- const getTemplateConfig_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, getTemplateConfig_ConfigPropertyMetadata);
6138
- const createResourceParams$4 = /*#__PURE__*/ createResourceParams$h(getTemplateConfig_ConfigPropertyMetadata);
6151
+ const getTemplateConfig_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, getTemplateConfig_ConfigPropertyMetadata);
6152
+ const createResourceParams$5 = /*#__PURE__*/ createResourceParams$i(getTemplateConfig_ConfigPropertyMetadata);
6139
6153
  function keyBuilder$3(luvio, config) {
6140
- const resourceParams = createResourceParams$4(config);
6154
+ const resourceParams = createResourceParams$5(config);
6141
6155
  return keyBuilder$4(luvio, resourceParams);
6142
6156
  }
6143
- function typeCheckConfig$4(untrustedConfig) {
6157
+ function typeCheckConfig$5(untrustedConfig) {
6144
6158
  const config = {};
6145
- typeCheckConfig$h(untrustedConfig, config, getTemplateConfig_ConfigPropertyMetadata);
6159
+ typeCheckConfig$i(untrustedConfig, config, getTemplateConfig_ConfigPropertyMetadata);
6146
6160
  return config;
6147
6161
  }
6148
- function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
6162
+ function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
6149
6163
  if (!untrustedIsObject(untrustedConfig)) {
6150
6164
  return null;
6151
6165
  }
6152
6166
  if (process.env.NODE_ENV !== 'production') {
6153
6167
  validateConfig(untrustedConfig, configPropertyNames);
6154
6168
  }
6155
- const config = typeCheckConfig$4(untrustedConfig);
6169
+ const config = typeCheckConfig$5(untrustedConfig);
6156
6170
  if (!areRequiredParametersPresent(config, configPropertyNames)) {
6157
6171
  return null;
6158
6172
  }
6159
6173
  return config;
6160
6174
  }
6161
6175
  function adapterFragment$1(luvio, config) {
6162
- createResourceParams$4(config);
6163
- return select$6();
6176
+ createResourceParams$5(config);
6177
+ return select$7();
6164
6178
  }
6165
6179
  function onFetchResponseSuccess$1(luvio, config, resourceParams, response) {
6166
- const snapshot = ingestSuccess$4(luvio, resourceParams, response, {
6180
+ const snapshot = ingestSuccess$5(luvio, resourceParams, response, {
6167
6181
  config,
6168
- resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
6182
+ resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
6169
6183
  });
6170
6184
  return luvio.storeBroadcast().then(() => snapshot);
6171
6185
  }
6172
6186
  function onFetchResponseError$1(luvio, config, resourceParams, response) {
6173
6187
  const snapshot = ingestError$1(luvio, resourceParams, response, {
6174
6188
  config,
6175
- resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
6189
+ resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
6176
6190
  });
6177
6191
  return luvio.storeBroadcast().then(() => snapshot);
6178
6192
  }
6179
- function buildNetworkSnapshot$4(luvio, config, options) {
6180
- const resourceParams = createResourceParams$4(config);
6181
- const request = createResourceRequest$4(resourceParams);
6193
+ function buildNetworkSnapshot$5(luvio, config, options) {
6194
+ const resourceParams = createResourceParams$5(config);
6195
+ const request = createResourceRequest$5(resourceParams);
6182
6196
  return luvio.dispatchResourceRequest(request, options)
6183
6197
  .then((response) => {
6184
6198
  return luvio.handleSuccessResponse(() => onFetchResponseSuccess$1(luvio, config, resourceParams, response), () => {
6185
6199
  const cache = new StoreKeyMap();
6186
- getResponseCacheKeys$4(cache, luvio, resourceParams, response.body);
6200
+ getResponseCacheKeys$5(cache, luvio, resourceParams, response.body);
6187
6201
  return cache;
6188
6202
  });
6189
6203
  }, (response) => {
@@ -6191,7 +6205,7 @@ function buildNetworkSnapshot$4(luvio, config, options) {
6191
6205
  });
6192
6206
  }
6193
6207
  function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext) {
6194
- return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$4, undefined, false);
6208
+ return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$5, undefined, false);
6195
6209
  }
6196
6210
  function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
6197
6211
  const { luvio, config } = context;
@@ -6202,12 +6216,12 @@ function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
6202
6216
  };
6203
6217
  const cacheSnapshot = storeLookup(selector, {
6204
6218
  config,
6205
- resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
6219
+ resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
6206
6220
  });
6207
6221
  return cacheSnapshot;
6208
6222
  }
6209
6223
  const getTemplateConfigAdapterFactory = (luvio) => function AppFramework__getTemplateConfig(untrustedConfig, requestContext) {
6210
- const config = validateAdapterConfig$4(untrustedConfig, getTemplateConfig_ConfigPropertyNames);
6224
+ const config = validateAdapterConfig$5(untrustedConfig, getTemplateConfig_ConfigPropertyNames);
6211
6225
  // Invalid or incomplete config
6212
6226
  if (config === null) {
6213
6227
  return null;
@@ -6292,7 +6306,7 @@ function normalize$1(input, existing, path, luvio, store, timestamp) {
6292
6306
  }
6293
6307
  return input;
6294
6308
  }
6295
- const select$5 = function TemplateCollectionRepresentationSelect() {
6309
+ const select$6 = function TemplateCollectionRepresentationSelect() {
6296
6310
  return {
6297
6311
  kind: 'Fragment',
6298
6312
  version: VERSION$1,
@@ -6302,7 +6316,7 @@ const select$5 = function TemplateCollectionRepresentationSelect() {
6302
6316
  name: 'templates',
6303
6317
  kind: 'Link',
6304
6318
  plural: true,
6305
- fragment: select$t()
6319
+ fragment: select$u()
6306
6320
  }
6307
6321
  ]
6308
6322
  };
@@ -6346,22 +6360,22 @@ function getTypeCacheKeys$1(rootKeySet, luvio, input, fullPathFactory) {
6346
6360
  }
6347
6361
  }
6348
6362
 
6349
- function select$4(luvio, params) {
6350
- return select$5();
6363
+ function select$5(luvio, params) {
6364
+ return select$6();
6351
6365
  }
6352
6366
  function keyBuilder$2(luvio, params) {
6353
6367
  return keyPrefix + '::TemplateCollectionRepresentation:(' + ')';
6354
6368
  }
6355
- function getResponseCacheKeys$3(storeKeyMap, luvio, resourceParams, response) {
6369
+ function getResponseCacheKeys$4(storeKeyMap, luvio, resourceParams, response) {
6356
6370
  getTypeCacheKeys$1(storeKeyMap, luvio, response, () => keyBuilder$2());
6357
6371
  }
6358
- function ingestSuccess$3(luvio, resourceParams, response, snapshotRefresh) {
6372
+ function ingestSuccess$4(luvio, resourceParams, response, snapshotRefresh) {
6359
6373
  const { body } = response;
6360
6374
  const key = keyBuilder$2();
6361
6375
  luvio.storeIngest(key, ingest$1, body);
6362
6376
  const snapshot = luvio.storeLookup({
6363
6377
  recordId: key,
6364
- node: select$4(),
6378
+ node: select$5(),
6365
6379
  variables: {},
6366
6380
  }, snapshotRefresh);
6367
6381
  if (process.env.NODE_ENV !== 'production') {
@@ -6384,7 +6398,7 @@ function ingestError(luvio, params, error, snapshotRefresh) {
6384
6398
  luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
6385
6399
  return errorSnapshot;
6386
6400
  }
6387
- function createResourceRequest$3(config) {
6401
+ function createResourceRequest$4(config) {
6388
6402
  const headers = {};
6389
6403
  return {
6390
6404
  baseUri: '/services/data/v63.0',
@@ -6398,57 +6412,57 @@ function createResourceRequest$3(config) {
6398
6412
  };
6399
6413
  }
6400
6414
 
6401
- const adapterName$3 = 'getTemplates';
6415
+ const adapterName$4 = 'getTemplates';
6402
6416
  const getTemplates_ConfigPropertyMetadata = [];
6403
- const getTemplates_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, getTemplates_ConfigPropertyMetadata);
6404
- const createResourceParams$3 = /*#__PURE__*/ createResourceParams$h(getTemplates_ConfigPropertyMetadata);
6417
+ const getTemplates_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, getTemplates_ConfigPropertyMetadata);
6418
+ const createResourceParams$4 = /*#__PURE__*/ createResourceParams$i(getTemplates_ConfigPropertyMetadata);
6405
6419
  function keyBuilder$1(luvio, config) {
6406
- createResourceParams$3(config);
6420
+ createResourceParams$4(config);
6407
6421
  return keyBuilder$2();
6408
6422
  }
6409
- function typeCheckConfig$3(untrustedConfig) {
6423
+ function typeCheckConfig$4(untrustedConfig) {
6410
6424
  const config = {};
6411
6425
  return config;
6412
6426
  }
6413
- function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
6427
+ function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
6414
6428
  if (!untrustedIsObject(untrustedConfig)) {
6415
6429
  return null;
6416
6430
  }
6417
6431
  if (process.env.NODE_ENV !== 'production') {
6418
6432
  validateConfig(untrustedConfig, configPropertyNames);
6419
6433
  }
6420
- const config = typeCheckConfig$3();
6434
+ const config = typeCheckConfig$4();
6421
6435
  if (!areRequiredParametersPresent(config, configPropertyNames)) {
6422
6436
  return null;
6423
6437
  }
6424
6438
  return config;
6425
6439
  }
6426
6440
  function adapterFragment(luvio, config) {
6427
- createResourceParams$3(config);
6428
- return select$4();
6441
+ createResourceParams$4(config);
6442
+ return select$5();
6429
6443
  }
6430
6444
  function onFetchResponseSuccess(luvio, config, resourceParams, response) {
6431
- const snapshot = ingestSuccess$3(luvio, resourceParams, response, {
6445
+ const snapshot = ingestSuccess$4(luvio, resourceParams, response, {
6432
6446
  config,
6433
- resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
6447
+ resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
6434
6448
  });
6435
6449
  return luvio.storeBroadcast().then(() => snapshot);
6436
6450
  }
6437
6451
  function onFetchResponseError(luvio, config, resourceParams, response) {
6438
6452
  const snapshot = ingestError(luvio, resourceParams, response, {
6439
6453
  config,
6440
- resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
6454
+ resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
6441
6455
  });
6442
6456
  return luvio.storeBroadcast().then(() => snapshot);
6443
6457
  }
6444
- function buildNetworkSnapshot$3(luvio, config, options) {
6445
- const resourceParams = createResourceParams$3(config);
6446
- const request = createResourceRequest$3();
6458
+ function buildNetworkSnapshot$4(luvio, config, options) {
6459
+ const resourceParams = createResourceParams$4(config);
6460
+ const request = createResourceRequest$4();
6447
6461
  return luvio.dispatchResourceRequest(request, options)
6448
6462
  .then((response) => {
6449
6463
  return luvio.handleSuccessResponse(() => onFetchResponseSuccess(luvio, config, resourceParams, response), () => {
6450
6464
  const cache = new StoreKeyMap();
6451
- getResponseCacheKeys$3(cache, luvio, resourceParams, response.body);
6465
+ getResponseCacheKeys$4(cache, luvio, resourceParams, response.body);
6452
6466
  return cache;
6453
6467
  });
6454
6468
  }, (response) => {
@@ -6456,7 +6470,7 @@ function buildNetworkSnapshot$3(luvio, config, options) {
6456
6470
  });
6457
6471
  }
6458
6472
  function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
6459
- return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$3, undefined, false);
6473
+ return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$4, undefined, false);
6460
6474
  }
6461
6475
  function buildCachedSnapshotCachePolicy(context, storeLookup) {
6462
6476
  const { luvio, config } = context;
@@ -6467,12 +6481,12 @@ function buildCachedSnapshotCachePolicy(context, storeLookup) {
6467
6481
  };
6468
6482
  const cacheSnapshot = storeLookup(selector, {
6469
6483
  config,
6470
- resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
6484
+ resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
6471
6485
  });
6472
6486
  return cacheSnapshot;
6473
6487
  }
6474
6488
  const getTemplatesAdapterFactory = (luvio) => function AppFramework__getTemplates(untrustedConfig, requestContext) {
6475
- const config = validateAdapterConfig$3(untrustedConfig, getTemplates_ConfigPropertyNames);
6489
+ const config = validateAdapterConfig$4(untrustedConfig, getTemplates_ConfigPropertyNames);
6476
6490
  // Invalid or incomplete config
6477
6491
  if (config === null) {
6478
6492
  return null;
@@ -6673,7 +6687,7 @@ function keyBuilderFromType(luvio, object) {
6673
6687
  function normalize(input, existing, path, luvio, store, timestamp) {
6674
6688
  return input;
6675
6689
  }
6676
- const select$3 = function TemplateReadinessRepresentationSelect() {
6690
+ const select$4 = function TemplateReadinessRepresentationSelect() {
6677
6691
  return {
6678
6692
  kind: 'Fragment',
6679
6693
  version: VERSION,
@@ -6709,19 +6723,19 @@ function getTypeCacheKeys(rootKeySet, luvio, input, fullPathFactory) {
6709
6723
  });
6710
6724
  }
6711
6725
 
6712
- function select$2(luvio, params) {
6713
- return select$3();
6726
+ function select$3(luvio, params) {
6727
+ return select$4();
6714
6728
  }
6715
- function getResponseCacheKeys$2(storeKeyMap, luvio, resourceParams, response) {
6729
+ function getResponseCacheKeys$3(storeKeyMap, luvio, resourceParams, response) {
6716
6730
  getTypeCacheKeys(storeKeyMap, luvio, response);
6717
6731
  }
6718
- function ingestSuccess$2(luvio, resourceParams, response) {
6732
+ function ingestSuccess$3(luvio, resourceParams, response) {
6719
6733
  const { body } = response;
6720
6734
  const key = keyBuilderFromType(luvio, body);
6721
6735
  luvio.storeIngest(key, ingest, body);
6722
6736
  const snapshot = luvio.storeLookup({
6723
6737
  recordId: key,
6724
- node: select$2(),
6738
+ node: select$3(),
6725
6739
  variables: {},
6726
6740
  });
6727
6741
  if (process.env.NODE_ENV !== 'production') {
@@ -6732,7 +6746,7 @@ function ingestSuccess$2(luvio, resourceParams, response) {
6732
6746
  deepFreeze(snapshot.data);
6733
6747
  return snapshot;
6734
6748
  }
6735
- function createResourceRequest$2(config) {
6749
+ function createResourceRequest$3(config) {
6736
6750
  const headers = {};
6737
6751
  return {
6738
6752
  baseUri: '/services/data/v63.0',
@@ -6746,17 +6760,17 @@ function createResourceRequest$2(config) {
6746
6760
  };
6747
6761
  }
6748
6762
 
6749
- const adapterName$2 = 'readinessCheck';
6763
+ const adapterName$3 = 'readinessCheck';
6750
6764
  const readinessCheck_ConfigPropertyMetadata = [
6751
6765
  generateParamConfigMetadata('templateIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
6752
6766
  generateParamConfigMetadata('logLevel', false, 2 /* Body */, 0 /* String */),
6753
6767
  generateParamConfigMetadata('templateValues', false, 2 /* Body */, 4 /* Unsupported */),
6754
6768
  ];
6755
- const readinessCheck_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, readinessCheck_ConfigPropertyMetadata);
6756
- const createResourceParams$2 = /*#__PURE__*/ createResourceParams$h(readinessCheck_ConfigPropertyMetadata);
6757
- function typeCheckConfig$2(untrustedConfig) {
6769
+ const readinessCheck_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, readinessCheck_ConfigPropertyMetadata);
6770
+ const createResourceParams$3 = /*#__PURE__*/ createResourceParams$i(readinessCheck_ConfigPropertyMetadata);
6771
+ function typeCheckConfig$3(untrustedConfig) {
6758
6772
  const config = {};
6759
- typeCheckConfig$h(untrustedConfig, config, readinessCheck_ConfigPropertyMetadata);
6773
+ typeCheckConfig$i(untrustedConfig, config, readinessCheck_ConfigPropertyMetadata);
6760
6774
  const untrustedConfig_templateValues = untrustedConfig.templateValues;
6761
6775
  if (untrustedIsObject(untrustedConfig_templateValues)) {
6762
6776
  const untrustedConfig_templateValues_object = {};
@@ -6774,30 +6788,30 @@ function typeCheckConfig$2(untrustedConfig) {
6774
6788
  }
6775
6789
  return config;
6776
6790
  }
6777
- function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
6791
+ function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
6778
6792
  if (!untrustedIsObject(untrustedConfig)) {
6779
6793
  return null;
6780
6794
  }
6781
6795
  if (process.env.NODE_ENV !== 'production') {
6782
6796
  validateConfig(untrustedConfig, configPropertyNames);
6783
6797
  }
6784
- const config = typeCheckConfig$2(untrustedConfig);
6798
+ const config = typeCheckConfig$3(untrustedConfig);
6785
6799
  if (!areRequiredParametersPresent(config, configPropertyNames)) {
6786
6800
  return null;
6787
6801
  }
6788
6802
  return config;
6789
6803
  }
6790
- function buildNetworkSnapshot$2(luvio, config, options) {
6791
- const resourceParams = createResourceParams$2(config);
6792
- const request = createResourceRequest$2(resourceParams);
6804
+ function buildNetworkSnapshot$3(luvio, config, options) {
6805
+ const resourceParams = createResourceParams$3(config);
6806
+ const request = createResourceRequest$3(resourceParams);
6793
6807
  return luvio.dispatchResourceRequest(request, options)
6794
6808
  .then((response) => {
6795
6809
  return luvio.handleSuccessResponse(() => {
6796
- const snapshot = ingestSuccess$2(luvio, resourceParams, response);
6810
+ const snapshot = ingestSuccess$3(luvio, resourceParams, response);
6797
6811
  return luvio.storeBroadcast().then(() => snapshot);
6798
6812
  }, () => {
6799
6813
  const cache = new StoreKeyMap();
6800
- getResponseCacheKeys$2(cache, luvio, resourceParams, response.body);
6814
+ getResponseCacheKeys$3(cache, luvio, resourceParams, response.body);
6801
6815
  return cache;
6802
6816
  });
6803
6817
  }, (response) => {
@@ -6807,28 +6821,28 @@ function buildNetworkSnapshot$2(luvio, config, options) {
6807
6821
  }
6808
6822
  const readinessCheckAdapterFactory = (luvio) => {
6809
6823
  return function readinessCheck(untrustedConfig) {
6810
- const config = validateAdapterConfig$2(untrustedConfig, readinessCheck_ConfigPropertyNames);
6824
+ const config = validateAdapterConfig$3(untrustedConfig, readinessCheck_ConfigPropertyNames);
6811
6825
  // Invalid or incomplete config
6812
6826
  if (config === null) {
6813
6827
  throw new Error('Invalid config for "readinessCheck"');
6814
6828
  }
6815
- return buildNetworkSnapshot$2(luvio, config);
6829
+ return buildNetworkSnapshot$3(luvio, config);
6816
6830
  };
6817
6831
  };
6818
6832
 
6819
- function select$1(luvio, params) {
6820
- return select$f();
6833
+ function select$2(luvio, params) {
6834
+ return select$g();
6821
6835
  }
6822
- function getResponseCacheKeys$1(storeKeyMap, luvio, resourceParams, response) {
6836
+ function getResponseCacheKeys$2(storeKeyMap, luvio, resourceParams, response) {
6823
6837
  getTypeCacheKeys$3(storeKeyMap, luvio, response);
6824
6838
  }
6825
- function ingestSuccess$1(luvio, resourceParams, response) {
6839
+ function ingestSuccess$2(luvio, resourceParams, response) {
6826
6840
  const { body } = response;
6827
6841
  const key = keyBuilderFromType$2(luvio, body);
6828
6842
  luvio.storeIngest(key, ingest$3, body);
6829
6843
  const snapshot = luvio.storeLookup({
6830
6844
  recordId: key,
6831
- node: select$1(),
6845
+ node: select$2(),
6832
6846
  variables: {},
6833
6847
  });
6834
6848
  if (process.env.NODE_ENV !== 'production') {
@@ -6839,7 +6853,7 @@ function ingestSuccess$1(luvio, resourceParams, response) {
6839
6853
  deepFreeze(snapshot.data);
6840
6854
  return snapshot;
6841
6855
  }
6842
- function createResourceRequest$1(config) {
6856
+ function createResourceRequest$2(config) {
6843
6857
  const headers = {};
6844
6858
  return {
6845
6859
  baseUri: '/services/data/v63.0',
@@ -6853,16 +6867,16 @@ function createResourceRequest$1(config) {
6853
6867
  };
6854
6868
  }
6855
6869
 
6856
- const adapterName$1 = 'setTags';
6870
+ const adapterName$2 = 'setTags';
6857
6871
  const setTags_ConfigPropertyMetadata = [
6858
6872
  generateParamConfigMetadata('templateIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
6859
6873
  generateParamConfigMetadata('tags', false, 2 /* Body */, 4 /* Unsupported */),
6860
6874
  ];
6861
- const setTags_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, setTags_ConfigPropertyMetadata);
6862
- const createResourceParams$1 = /*#__PURE__*/ createResourceParams$h(setTags_ConfigPropertyMetadata);
6863
- function typeCheckConfig$1(untrustedConfig) {
6875
+ const setTags_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, setTags_ConfigPropertyMetadata);
6876
+ const createResourceParams$2 = /*#__PURE__*/ createResourceParams$i(setTags_ConfigPropertyMetadata);
6877
+ function typeCheckConfig$2(untrustedConfig) {
6864
6878
  const config = {};
6865
- typeCheckConfig$h(untrustedConfig, config, setTags_ConfigPropertyMetadata);
6879
+ typeCheckConfig$i(untrustedConfig, config, setTags_ConfigPropertyMetadata);
6866
6880
  const untrustedConfig_tags = untrustedConfig.tags;
6867
6881
  if (untrustedIsObject(untrustedConfig_tags)) {
6868
6882
  const untrustedConfig_tags_object = {};
@@ -6880,6 +6894,115 @@ function typeCheckConfig$1(untrustedConfig) {
6880
6894
  }
6881
6895
  return config;
6882
6896
  }
6897
+ function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
6898
+ if (!untrustedIsObject(untrustedConfig)) {
6899
+ return null;
6900
+ }
6901
+ if (process.env.NODE_ENV !== 'production') {
6902
+ validateConfig(untrustedConfig, configPropertyNames);
6903
+ }
6904
+ const config = typeCheckConfig$2(untrustedConfig);
6905
+ if (!areRequiredParametersPresent(config, configPropertyNames)) {
6906
+ return null;
6907
+ }
6908
+ return config;
6909
+ }
6910
+ function buildNetworkSnapshot$2(luvio, config, options) {
6911
+ const resourceParams = createResourceParams$2(config);
6912
+ const request = createResourceRequest$2(resourceParams);
6913
+ return luvio.dispatchResourceRequest(request, options)
6914
+ .then((response) => {
6915
+ return luvio.handleSuccessResponse(() => {
6916
+ const snapshot = ingestSuccess$2(luvio, resourceParams, response);
6917
+ return luvio.storeBroadcast().then(() => snapshot);
6918
+ }, () => {
6919
+ const cache = new StoreKeyMap();
6920
+ getResponseCacheKeys$2(cache, luvio, resourceParams, response.body);
6921
+ return cache;
6922
+ });
6923
+ }, (response) => {
6924
+ deepFreeze(response);
6925
+ throw response;
6926
+ });
6927
+ }
6928
+ const setTagsAdapterFactory = (luvio) => {
6929
+ return function setTags(untrustedConfig) {
6930
+ const config = validateAdapterConfig$2(untrustedConfig, setTags_ConfigPropertyNames);
6931
+ // Invalid or incomplete config
6932
+ if (config === null) {
6933
+ throw new Error('Invalid config for "setTags"');
6934
+ }
6935
+ return buildNetworkSnapshot$2(luvio, config);
6936
+ };
6937
+ };
6938
+
6939
+ function select$1(luvio, params) {
6940
+ return select$C();
6941
+ }
6942
+ function getResponseCacheKeys$1(storeKeyMap, luvio, resourceParams, response) {
6943
+ getTypeCacheKeys$b(storeKeyMap, luvio, response);
6944
+ }
6945
+ function ingestSuccess$1(luvio, resourceParams, response) {
6946
+ const { body } = response;
6947
+ const key = keyBuilderFromType$8(luvio, body);
6948
+ luvio.storeIngest(key, ingest$b, body);
6949
+ const snapshot = luvio.storeLookup({
6950
+ recordId: key,
6951
+ node: select$1(),
6952
+ variables: {},
6953
+ });
6954
+ if (process.env.NODE_ENV !== 'production') {
6955
+ if (snapshot.state !== 'Fulfilled') {
6956
+ throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
6957
+ }
6958
+ }
6959
+ deepFreeze(snapshot.data);
6960
+ return snapshot;
6961
+ }
6962
+ function createResourceRequest$1(config) {
6963
+ const headers = {};
6964
+ return {
6965
+ baseUri: '/services/data/v63.0',
6966
+ basePath: '/app-framework/apps/' + config.urlParams.appIdOrApiName + '',
6967
+ method: 'put',
6968
+ body: config.body,
6969
+ urlParams: config.urlParams,
6970
+ queryParams: {},
6971
+ headers,
6972
+ priority: 'normal',
6973
+ };
6974
+ }
6975
+
6976
+ const adapterName$1 = 'updateApp';
6977
+ const updateApp_ConfigPropertyMetadata = [
6978
+ generateParamConfigMetadata('appIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
6979
+ generateParamConfigMetadata('logLevel', false, 2 /* Body */, 0 /* String */),
6980
+ generateParamConfigMetadata('runtimeMethod', false, 2 /* Body */, 0 /* String */),
6981
+ generateParamConfigMetadata('templateSourceId', true, 2 /* Body */, 0 /* String */),
6982
+ generateParamConfigMetadata('templateValues', false, 2 /* Body */, 4 /* Unsupported */),
6983
+ ];
6984
+ const updateApp_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, updateApp_ConfigPropertyMetadata);
6985
+ const createResourceParams$1 = /*#__PURE__*/ createResourceParams$i(updateApp_ConfigPropertyMetadata);
6986
+ function typeCheckConfig$1(untrustedConfig) {
6987
+ const config = {};
6988
+ typeCheckConfig$i(untrustedConfig, config, updateApp_ConfigPropertyMetadata);
6989
+ const untrustedConfig_templateValues = untrustedConfig.templateValues;
6990
+ if (untrustedIsObject(untrustedConfig_templateValues)) {
6991
+ const untrustedConfig_templateValues_object = {};
6992
+ const untrustedConfig_templateValues_keys = Object.keys(untrustedConfig_templateValues);
6993
+ for (let i = 0, arrayLength = untrustedConfig_templateValues_keys.length; i < arrayLength; i++) {
6994
+ const key = untrustedConfig_templateValues_keys[i];
6995
+ const untrustedConfig_templateValues_prop = untrustedConfig_templateValues[key];
6996
+ if (untrustedConfig_templateValues_object !== undefined) {
6997
+ untrustedConfig_templateValues_object[key] = untrustedConfig_templateValues_prop;
6998
+ }
6999
+ }
7000
+ if (untrustedConfig_templateValues_object !== undefined && Object.keys(untrustedConfig_templateValues_object).length >= 0) {
7001
+ config.templateValues = untrustedConfig_templateValues_object;
7002
+ }
7003
+ }
7004
+ return config;
7005
+ }
6883
7006
  function validateAdapterConfig$1(untrustedConfig, configPropertyNames) {
6884
7007
  if (!untrustedIsObject(untrustedConfig)) {
6885
7008
  return null;
@@ -6911,19 +7034,19 @@ function buildNetworkSnapshot$1(luvio, config, options) {
6911
7034
  throw response;
6912
7035
  });
6913
7036
  }
6914
- const setTagsAdapterFactory = (luvio) => {
6915
- return function setTags(untrustedConfig) {
6916
- const config = validateAdapterConfig$1(untrustedConfig, setTags_ConfigPropertyNames);
7037
+ const updateAppAdapterFactory = (luvio) => {
7038
+ return function updateApp(untrustedConfig) {
7039
+ const config = validateAdapterConfig$1(untrustedConfig, updateApp_ConfigPropertyNames);
6917
7040
  // Invalid or incomplete config
6918
7041
  if (config === null) {
6919
- throw new Error('Invalid config for "setTags"');
7042
+ throw new Error('Invalid config for "updateApp"');
6920
7043
  }
6921
7044
  return buildNetworkSnapshot$1(luvio, config);
6922
7045
  };
6923
7046
  };
6924
7047
 
6925
7048
  function select(luvio, params) {
6926
- return select$t();
7049
+ return select$u();
6927
7050
  }
6928
7051
  function getResponseCacheKeys(storeKeyMap, luvio, resourceParams, response) {
6929
7052
  getTypeCacheKeys$a(storeKeyMap, luvio, response);
@@ -6967,10 +7090,10 @@ const updateTemplate_ConfigPropertyMetadata = [
6967
7090
  generateParamConfigMetadata('label', false, 2 /* Body */, 0 /* String */),
6968
7091
  ];
6969
7092
  const updateTemplate_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, updateTemplate_ConfigPropertyMetadata);
6970
- const createResourceParams = /*#__PURE__*/ createResourceParams$h(updateTemplate_ConfigPropertyMetadata);
7093
+ const createResourceParams = /*#__PURE__*/ createResourceParams$i(updateTemplate_ConfigPropertyMetadata);
6971
7094
  function typeCheckConfig(untrustedConfig) {
6972
7095
  const config = {};
6973
- typeCheckConfig$h(untrustedConfig, config, updateTemplate_ConfigPropertyMetadata);
7096
+ typeCheckConfig$i(untrustedConfig, config, updateTemplate_ConfigPropertyMetadata);
6974
7097
  const untrustedConfig_releaseInfo = untrustedConfig.releaseInfo;
6975
7098
  const referenceReleaseInfoInputRepresentationValidationError = validate$o(untrustedConfig_releaseInfo);
6976
7099
  if (referenceReleaseInfoInputRepresentationValidationError === null) {
@@ -7043,6 +7166,7 @@ let getTemplateNotifyChange;
7043
7166
  let getTemplates;
7044
7167
  let readinessCheck;
7045
7168
  let setTags;
7169
+ let updateApp;
7046
7170
  let updateTemplate;
7047
7171
  // Imperative GET Adapters
7048
7172
  let getApp_imperative;
@@ -7093,8 +7217,8 @@ function bindExportsTo(luvio) {
7093
7217
  return {
7094
7218
  createApp: unwrapSnapshotData(createAppAdapterFactory),
7095
7219
  createTemplate: unwrapSnapshotData(createTemplateAdapterFactory),
7096
- deleteApp: createLDSAdapter(luvio, adapterName$e, deleteAppAdapterFactory),
7097
- deleteTemplate: createLDSAdapter(luvio, adapterName$d, deleteTemplateAdapterFactory),
7220
+ deleteApp: createLDSAdapter(luvio, adapterName$f, deleteAppAdapterFactory),
7221
+ deleteTemplate: createLDSAdapter(luvio, adapterName$e, deleteTemplateAdapterFactory),
7098
7222
  getApp: createWireAdapterConstructor(luvio, getApp_ldsAdapter, getAppMetadata),
7099
7223
  getAppActivities: createWireAdapterConstructor(luvio, getAppActivities_ldsAdapter, getAppActivitiesMetadata),
7100
7224
  getAppActivitiesNotifyChange: createLDSAdapter(luvio, 'getAppActivitiesNotifyChange', notifyChangeFactory$5),
@@ -7114,6 +7238,7 @@ function bindExportsTo(luvio) {
7114
7238
  getTemplates: createWireAdapterConstructor(luvio, getTemplates_ldsAdapter, getTemplatesMetadata),
7115
7239
  readinessCheck: unwrapSnapshotData(readinessCheckAdapterFactory),
7116
7240
  setTags: unwrapSnapshotData(setTagsAdapterFactory),
7241
+ updateApp: unwrapSnapshotData(updateAppAdapterFactory),
7117
7242
  updateTemplate: unwrapSnapshotData(updateTemplateAdapterFactory),
7118
7243
  // Imperative GET Adapters
7119
7244
  getApp_imperative: createImperativeAdapter(luvio, getApp_ldsAdapter, getAppMetadata),
@@ -7154,6 +7279,7 @@ withDefaultLuvio((luvio) => {
7154
7279
  getTemplates,
7155
7280
  readinessCheck,
7156
7281
  setTags,
7282
+ updateApp,
7157
7283
  updateTemplate,
7158
7284
  getApp_imperative,
7159
7285
  getAppActivities_imperative,
@@ -7168,5 +7294,5 @@ withDefaultLuvio((luvio) => {
7168
7294
  } = bindExportsTo(luvio));
7169
7295
  });
7170
7296
 
7171
- export { createApp, createTemplate, deleteApp, deleteTemplate, getApp, getAppActivities, getAppActivitiesNotifyChange, getAppActivities_imperative, getAppActivity, getAppActivityNotifyChange, getAppActivity_imperative, getAppAssets, getAppAssetsNotifyChange, getAppAssets_imperative, getAppNotifyChange, getApp_imperative, getApps, getApps_imperative, getInstalledAssets, getInstalledAssets_imperative, getTags, getTagsNotifyChange, getTags_imperative, getTemplate, getTemplateConfig, getTemplateConfigNotifyChange, getTemplateConfig_imperative, getTemplateNotifyChange, getTemplate_imperative, getTemplates, getTemplates_imperative, readinessCheck, setTags, updateTemplate };
7172
- // version: 1.332.0-dev2-db38b645f2
7297
+ export { createApp, createTemplate, deleteApp, deleteTemplate, getApp, getAppActivities, getAppActivitiesNotifyChange, getAppActivities_imperative, getAppActivity, getAppActivityNotifyChange, getAppActivity_imperative, getAppAssets, getAppAssetsNotifyChange, getAppAssets_imperative, getAppNotifyChange, getApp_imperative, getApps, getApps_imperative, getInstalledAssets, getInstalledAssets_imperative, getTags, getTagsNotifyChange, getTags_imperative, getTemplate, getTemplateConfig, getTemplateConfigNotifyChange, getTemplateConfig_imperative, getTemplateNotifyChange, getTemplate_imperative, getTemplates, getTemplates_imperative, readinessCheck, setTags, updateApp, updateTemplate };
7298
+ // version: 1.332.0-dev21-cc02503f9d