@player-ui/types 0.4.0-next.4 → 0.4.0-next.6
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.
- package/dist/index.d.ts +16 -3
- package/dist/xlr/Asset.json +40 -0
- package/dist/xlr/AssetBinding.json +23 -0
- package/dist/xlr/AssetSwitch.json +213 -0
- package/dist/xlr/AssetWrapper.json +34 -0
- package/dist/xlr/AssetWrapperOrSwitch.json +304 -0
- package/dist/xlr/Binding.json +7 -0
- package/dist/xlr/BindingRef.json +7 -0
- package/dist/xlr/DataModel.json +13 -0
- package/dist/xlr/DynamicSwitch.json +96 -0
- package/dist/xlr/Expression.json +21 -0
- package/dist/xlr/ExpressionObject.json +19 -0
- package/dist/xlr/ExpressionRef.json +7 -0
- package/dist/xlr/Flow.json +2145 -0
- package/dist/xlr/FlowResult.json +131 -0
- package/dist/xlr/Navigation.json +783 -0
- package/dist/xlr/NavigationBaseState.json +133 -0
- package/dist/xlr/NavigationFlow.json +746 -0
- package/dist/xlr/NavigationFlowActionState.json +120 -0
- package/dist/xlr/NavigationFlowEndState.json +110 -0
- package/dist/xlr/NavigationFlowExternalState.json +126 -0
- package/dist/xlr/NavigationFlowFlowState.json +125 -0
- package/dist/xlr/NavigationFlowState.json +627 -0
- package/dist/xlr/NavigationFlowTransition.json +12 -0
- package/dist/xlr/NavigationFlowTransitionableState.json +149 -0
- package/dist/xlr/NavigationFlowViewState.json +138 -0
- package/dist/xlr/StaticSwitch.json +96 -0
- package/dist/xlr/Switch.json +71 -0
- package/dist/xlr/SwitchCase.json +51 -0
- package/dist/xlr/Templatable.json +83 -0
- package/dist/xlr/Template.json +65 -0
- package/dist/xlr/View.json +166 -0
- package/dist/xlr/manifest.js +38 -0
- package/dist/xlr/manifest.json +38 -0
- package/package.json +1 -1
- package/src/index.ts +20 -4
|
@@ -0,0 +1,2145 @@
|
|
|
1
|
+
{
|
|
2
|
+
"source": "core/types/src/index.ts",
|
|
3
|
+
"name": "Flow",
|
|
4
|
+
"type": "object",
|
|
5
|
+
"properties": {
|
|
6
|
+
"id": {
|
|
7
|
+
"required": true,
|
|
8
|
+
"node": {
|
|
9
|
+
"type": "string",
|
|
10
|
+
"title": "Flow.id",
|
|
11
|
+
"description": "A unique identifier for the flow"
|
|
12
|
+
}
|
|
13
|
+
},
|
|
14
|
+
"views": {
|
|
15
|
+
"required": false,
|
|
16
|
+
"node": {
|
|
17
|
+
"type": "array",
|
|
18
|
+
"elementType": {
|
|
19
|
+
"source": "core/types/src/index.ts",
|
|
20
|
+
"name": "View",
|
|
21
|
+
"type": "conditional",
|
|
22
|
+
"check": {
|
|
23
|
+
"left": {
|
|
24
|
+
"type": "unknown"
|
|
25
|
+
},
|
|
26
|
+
"right": {
|
|
27
|
+
"type": "ref",
|
|
28
|
+
"ref": "Asset",
|
|
29
|
+
"property": "validation"
|
|
30
|
+
}
|
|
31
|
+
},
|
|
32
|
+
"value": {
|
|
33
|
+
"true": {
|
|
34
|
+
"type": "and",
|
|
35
|
+
"and": [
|
|
36
|
+
{
|
|
37
|
+
"type": "ref",
|
|
38
|
+
"ref": "T"
|
|
39
|
+
},
|
|
40
|
+
{
|
|
41
|
+
"type": "object",
|
|
42
|
+
"properties": {
|
|
43
|
+
"validation": {
|
|
44
|
+
"required": false,
|
|
45
|
+
"node": {
|
|
46
|
+
"type": "array",
|
|
47
|
+
"elementType": {
|
|
48
|
+
"name": "CrossfieldReference",
|
|
49
|
+
"type": "object",
|
|
50
|
+
"properties": {
|
|
51
|
+
"type": {
|
|
52
|
+
"required": true,
|
|
53
|
+
"node": {
|
|
54
|
+
"type": "string",
|
|
55
|
+
"title": "Reference.type",
|
|
56
|
+
"description": "The name of the referenced validation type\nThis will be used to lookup the proper handler"
|
|
57
|
+
}
|
|
58
|
+
},
|
|
59
|
+
"message": {
|
|
60
|
+
"required": false,
|
|
61
|
+
"node": {
|
|
62
|
+
"type": "string",
|
|
63
|
+
"title": "Reference.message",
|
|
64
|
+
"description": "An optional means of overriding the default message if the validation is triggered"
|
|
65
|
+
}
|
|
66
|
+
},
|
|
67
|
+
"severity": {
|
|
68
|
+
"required": false,
|
|
69
|
+
"node": {
|
|
70
|
+
"name": "Severity",
|
|
71
|
+
"type": "or",
|
|
72
|
+
"or": [
|
|
73
|
+
{
|
|
74
|
+
"type": "string",
|
|
75
|
+
"const": "error"
|
|
76
|
+
},
|
|
77
|
+
{
|
|
78
|
+
"type": "string",
|
|
79
|
+
"const": "warning"
|
|
80
|
+
}
|
|
81
|
+
],
|
|
82
|
+
"title": "Reference.severity",
|
|
83
|
+
"description": "An optional means of overriding the default severity of the validation if triggered"
|
|
84
|
+
}
|
|
85
|
+
},
|
|
86
|
+
"trigger": {
|
|
87
|
+
"required": false,
|
|
88
|
+
"node": {
|
|
89
|
+
"name": "Trigger",
|
|
90
|
+
"type": "or",
|
|
91
|
+
"or": [
|
|
92
|
+
{
|
|
93
|
+
"type": "string",
|
|
94
|
+
"const": "navigation"
|
|
95
|
+
},
|
|
96
|
+
{
|
|
97
|
+
"type": "string",
|
|
98
|
+
"const": "change"
|
|
99
|
+
},
|
|
100
|
+
{
|
|
101
|
+
"type": "string",
|
|
102
|
+
"const": "load"
|
|
103
|
+
}
|
|
104
|
+
],
|
|
105
|
+
"title": "Reference.trigger",
|
|
106
|
+
"description": "When to run this particular validation"
|
|
107
|
+
}
|
|
108
|
+
},
|
|
109
|
+
"dataTarget": {
|
|
110
|
+
"required": false,
|
|
111
|
+
"node": {
|
|
112
|
+
"type": "never",
|
|
113
|
+
"title": "CrossfieldReference.dataTarget",
|
|
114
|
+
"description": "Cross-field references and validation must run against the default (deformatted) value"
|
|
115
|
+
}
|
|
116
|
+
},
|
|
117
|
+
"displayTarget": {
|
|
118
|
+
"required": false,
|
|
119
|
+
"node": {
|
|
120
|
+
"name": "DisplayTarget",
|
|
121
|
+
"type": "or",
|
|
122
|
+
"or": [
|
|
123
|
+
{
|
|
124
|
+
"type": "string",
|
|
125
|
+
"const": "page"
|
|
126
|
+
},
|
|
127
|
+
{
|
|
128
|
+
"type": "string",
|
|
129
|
+
"const": "section"
|
|
130
|
+
},
|
|
131
|
+
{
|
|
132
|
+
"type": "string",
|
|
133
|
+
"const": "field"
|
|
134
|
+
}
|
|
135
|
+
],
|
|
136
|
+
"title": "Reference.displayTarget",
|
|
137
|
+
"description": "Where the error should be displayed"
|
|
138
|
+
}
|
|
139
|
+
},
|
|
140
|
+
"ref": {
|
|
141
|
+
"required": false,
|
|
142
|
+
"node": {
|
|
143
|
+
"type": "ref",
|
|
144
|
+
"ref": "Binding",
|
|
145
|
+
"title": "CrossfieldReference.ref",
|
|
146
|
+
"description": "The binding to associate this validation with"
|
|
147
|
+
}
|
|
148
|
+
}
|
|
149
|
+
},
|
|
150
|
+
"additionalProperties": {
|
|
151
|
+
"type": "unknown"
|
|
152
|
+
},
|
|
153
|
+
"title": "CrossfieldReference"
|
|
154
|
+
},
|
|
155
|
+
"title": "validation",
|
|
156
|
+
"description": "Each view can optionally supply a list of validations to run against a particular view"
|
|
157
|
+
}
|
|
158
|
+
}
|
|
159
|
+
},
|
|
160
|
+
"additionalProperties": false
|
|
161
|
+
}
|
|
162
|
+
]
|
|
163
|
+
},
|
|
164
|
+
"false": {
|
|
165
|
+
"type": "ref",
|
|
166
|
+
"ref": "T"
|
|
167
|
+
}
|
|
168
|
+
},
|
|
169
|
+
"title": "View",
|
|
170
|
+
"genericTokens": [
|
|
171
|
+
{
|
|
172
|
+
"symbol": "T",
|
|
173
|
+
"constraints": {
|
|
174
|
+
"type": "ref",
|
|
175
|
+
"ref": "Asset"
|
|
176
|
+
},
|
|
177
|
+
"default": {
|
|
178
|
+
"type": "ref",
|
|
179
|
+
"ref": "Asset"
|
|
180
|
+
}
|
|
181
|
+
}
|
|
182
|
+
]
|
|
183
|
+
},
|
|
184
|
+
"title": "Flow.views",
|
|
185
|
+
"description": "A list of views (each with an ID) that can be shown to a user"
|
|
186
|
+
}
|
|
187
|
+
},
|
|
188
|
+
"schema": {
|
|
189
|
+
"required": false,
|
|
190
|
+
"node": {
|
|
191
|
+
"name": "Schema",
|
|
192
|
+
"type": "object",
|
|
193
|
+
"properties": {
|
|
194
|
+
"ROOT": {
|
|
195
|
+
"required": true,
|
|
196
|
+
"node": {
|
|
197
|
+
"name": "Node",
|
|
198
|
+
"type": "object",
|
|
199
|
+
"properties": {},
|
|
200
|
+
"additionalProperties": {
|
|
201
|
+
"name": "DataTypes",
|
|
202
|
+
"type": "or",
|
|
203
|
+
"or": [
|
|
204
|
+
{
|
|
205
|
+
"name": "DataType",
|
|
206
|
+
"type": "object",
|
|
207
|
+
"properties": {
|
|
208
|
+
"type": {
|
|
209
|
+
"required": true,
|
|
210
|
+
"node": {
|
|
211
|
+
"type": "string",
|
|
212
|
+
"title": "DataType.type",
|
|
213
|
+
"description": "The reference of the base type to use"
|
|
214
|
+
}
|
|
215
|
+
},
|
|
216
|
+
"validation": {
|
|
217
|
+
"required": false,
|
|
218
|
+
"node": {
|
|
219
|
+
"type": "array",
|
|
220
|
+
"elementType": {
|
|
221
|
+
"name": "Reference",
|
|
222
|
+
"type": "object",
|
|
223
|
+
"properties": {
|
|
224
|
+
"type": {
|
|
225
|
+
"required": true,
|
|
226
|
+
"node": {
|
|
227
|
+
"type": "string",
|
|
228
|
+
"title": "Reference.type",
|
|
229
|
+
"description": "The name of the referenced validation type\nThis will be used to lookup the proper handler"
|
|
230
|
+
}
|
|
231
|
+
},
|
|
232
|
+
"message": {
|
|
233
|
+
"required": false,
|
|
234
|
+
"node": {
|
|
235
|
+
"type": "string",
|
|
236
|
+
"title": "Reference.message",
|
|
237
|
+
"description": "An optional means of overriding the default message if the validation is triggered"
|
|
238
|
+
}
|
|
239
|
+
},
|
|
240
|
+
"severity": {
|
|
241
|
+
"required": false,
|
|
242
|
+
"node": {
|
|
243
|
+
"name": "Severity",
|
|
244
|
+
"type": "or",
|
|
245
|
+
"or": [
|
|
246
|
+
{
|
|
247
|
+
"type": "string",
|
|
248
|
+
"const": "error"
|
|
249
|
+
},
|
|
250
|
+
{
|
|
251
|
+
"type": "string",
|
|
252
|
+
"const": "warning"
|
|
253
|
+
}
|
|
254
|
+
],
|
|
255
|
+
"title": "Reference.severity",
|
|
256
|
+
"description": "An optional means of overriding the default severity of the validation if triggered"
|
|
257
|
+
}
|
|
258
|
+
},
|
|
259
|
+
"trigger": {
|
|
260
|
+
"required": false,
|
|
261
|
+
"node": {
|
|
262
|
+
"name": "Trigger",
|
|
263
|
+
"type": "or",
|
|
264
|
+
"or": [
|
|
265
|
+
{
|
|
266
|
+
"type": "string",
|
|
267
|
+
"const": "navigation"
|
|
268
|
+
},
|
|
269
|
+
{
|
|
270
|
+
"type": "string",
|
|
271
|
+
"const": "change"
|
|
272
|
+
},
|
|
273
|
+
{
|
|
274
|
+
"type": "string",
|
|
275
|
+
"const": "load"
|
|
276
|
+
}
|
|
277
|
+
],
|
|
278
|
+
"title": "Reference.trigger",
|
|
279
|
+
"description": "When to run this particular validation"
|
|
280
|
+
}
|
|
281
|
+
},
|
|
282
|
+
"dataTarget": {
|
|
283
|
+
"required": false,
|
|
284
|
+
"node": {
|
|
285
|
+
"type": "or",
|
|
286
|
+
"or": [
|
|
287
|
+
{
|
|
288
|
+
"type": "string",
|
|
289
|
+
"const": "formatted"
|
|
290
|
+
},
|
|
291
|
+
{
|
|
292
|
+
"type": "string",
|
|
293
|
+
"const": "deformatted"
|
|
294
|
+
}
|
|
295
|
+
],
|
|
296
|
+
"title": "Reference.dataTarget",
|
|
297
|
+
"description": "Each validation is passed the value of the data to run it's validation against.\nBy default, this is the value stored in the data-model (deformatted).\nIn the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option"
|
|
298
|
+
}
|
|
299
|
+
},
|
|
300
|
+
"displayTarget": {
|
|
301
|
+
"required": false,
|
|
302
|
+
"node": {
|
|
303
|
+
"name": "DisplayTarget",
|
|
304
|
+
"type": "or",
|
|
305
|
+
"or": [
|
|
306
|
+
{
|
|
307
|
+
"type": "string",
|
|
308
|
+
"const": "page"
|
|
309
|
+
},
|
|
310
|
+
{
|
|
311
|
+
"type": "string",
|
|
312
|
+
"const": "section"
|
|
313
|
+
},
|
|
314
|
+
{
|
|
315
|
+
"type": "string",
|
|
316
|
+
"const": "field"
|
|
317
|
+
}
|
|
318
|
+
],
|
|
319
|
+
"title": "Reference.displayTarget",
|
|
320
|
+
"description": "Where the error should be displayed"
|
|
321
|
+
}
|
|
322
|
+
}
|
|
323
|
+
},
|
|
324
|
+
"additionalProperties": {
|
|
325
|
+
"type": "unknown"
|
|
326
|
+
},
|
|
327
|
+
"title": "Reference",
|
|
328
|
+
"description": "A reference to a validation object"
|
|
329
|
+
},
|
|
330
|
+
"title": "DataType.validation",
|
|
331
|
+
"description": "Any additional validations that are associated with this property\nThese will add to any base validations associated with the \"type\""
|
|
332
|
+
}
|
|
333
|
+
},
|
|
334
|
+
"format": {
|
|
335
|
+
"required": false,
|
|
336
|
+
"node": {
|
|
337
|
+
"name": "Reference",
|
|
338
|
+
"type": "object",
|
|
339
|
+
"properties": {
|
|
340
|
+
"type": {
|
|
341
|
+
"required": true,
|
|
342
|
+
"node": {
|
|
343
|
+
"type": "string",
|
|
344
|
+
"title": "Reference.type",
|
|
345
|
+
"description": "The name of the formatter (and de-formatter) to use"
|
|
346
|
+
}
|
|
347
|
+
}
|
|
348
|
+
},
|
|
349
|
+
"additionalProperties": {
|
|
350
|
+
"type": "unknown"
|
|
351
|
+
},
|
|
352
|
+
"title": "DataType.format",
|
|
353
|
+
"description": "A reference to a specific data format to use.\nIf none is specified, will fallback to that of the base type"
|
|
354
|
+
}
|
|
355
|
+
},
|
|
356
|
+
"default": {
|
|
357
|
+
"required": false,
|
|
358
|
+
"node": {
|
|
359
|
+
"type": "ref",
|
|
360
|
+
"ref": "T",
|
|
361
|
+
"title": "DataType.default",
|
|
362
|
+
"description": "A default value for this property.\nAny reads for this property will result in this default value being written to the model."
|
|
363
|
+
}
|
|
364
|
+
}
|
|
365
|
+
},
|
|
366
|
+
"additionalProperties": {
|
|
367
|
+
"type": "unknown"
|
|
368
|
+
},
|
|
369
|
+
"title": "DataType",
|
|
370
|
+
"description": "Each prop in the object can have a specific DataType",
|
|
371
|
+
"genericTokens": [
|
|
372
|
+
{
|
|
373
|
+
"symbol": "T",
|
|
374
|
+
"constraints": {
|
|
375
|
+
"type": "any"
|
|
376
|
+
},
|
|
377
|
+
"default": {
|
|
378
|
+
"type": "unknown"
|
|
379
|
+
}
|
|
380
|
+
}
|
|
381
|
+
]
|
|
382
|
+
},
|
|
383
|
+
{
|
|
384
|
+
"name": "RecordType",
|
|
385
|
+
"type": "object",
|
|
386
|
+
"properties": {
|
|
387
|
+
"type": {
|
|
388
|
+
"required": true,
|
|
389
|
+
"node": {
|
|
390
|
+
"type": "string",
|
|
391
|
+
"title": "DataType.type",
|
|
392
|
+
"description": "The reference of the base type to use"
|
|
393
|
+
}
|
|
394
|
+
},
|
|
395
|
+
"validation": {
|
|
396
|
+
"required": false,
|
|
397
|
+
"node": {
|
|
398
|
+
"type": "array",
|
|
399
|
+
"elementType": {
|
|
400
|
+
"name": "Reference",
|
|
401
|
+
"type": "object",
|
|
402
|
+
"properties": {
|
|
403
|
+
"type": {
|
|
404
|
+
"required": true,
|
|
405
|
+
"node": {
|
|
406
|
+
"type": "string",
|
|
407
|
+
"title": "Reference.type",
|
|
408
|
+
"description": "The name of the referenced validation type\nThis will be used to lookup the proper handler"
|
|
409
|
+
}
|
|
410
|
+
},
|
|
411
|
+
"message": {
|
|
412
|
+
"required": false,
|
|
413
|
+
"node": {
|
|
414
|
+
"type": "string",
|
|
415
|
+
"title": "Reference.message",
|
|
416
|
+
"description": "An optional means of overriding the default message if the validation is triggered"
|
|
417
|
+
}
|
|
418
|
+
},
|
|
419
|
+
"severity": {
|
|
420
|
+
"required": false,
|
|
421
|
+
"node": {
|
|
422
|
+
"name": "Severity",
|
|
423
|
+
"type": "or",
|
|
424
|
+
"or": [
|
|
425
|
+
{
|
|
426
|
+
"type": "string",
|
|
427
|
+
"const": "error"
|
|
428
|
+
},
|
|
429
|
+
{
|
|
430
|
+
"type": "string",
|
|
431
|
+
"const": "warning"
|
|
432
|
+
}
|
|
433
|
+
],
|
|
434
|
+
"title": "Reference.severity",
|
|
435
|
+
"description": "An optional means of overriding the default severity of the validation if triggered"
|
|
436
|
+
}
|
|
437
|
+
},
|
|
438
|
+
"trigger": {
|
|
439
|
+
"required": false,
|
|
440
|
+
"node": {
|
|
441
|
+
"name": "Trigger",
|
|
442
|
+
"type": "or",
|
|
443
|
+
"or": [
|
|
444
|
+
{
|
|
445
|
+
"type": "string",
|
|
446
|
+
"const": "navigation"
|
|
447
|
+
},
|
|
448
|
+
{
|
|
449
|
+
"type": "string",
|
|
450
|
+
"const": "change"
|
|
451
|
+
},
|
|
452
|
+
{
|
|
453
|
+
"type": "string",
|
|
454
|
+
"const": "load"
|
|
455
|
+
}
|
|
456
|
+
],
|
|
457
|
+
"title": "Reference.trigger",
|
|
458
|
+
"description": "When to run this particular validation"
|
|
459
|
+
}
|
|
460
|
+
},
|
|
461
|
+
"dataTarget": {
|
|
462
|
+
"required": false,
|
|
463
|
+
"node": {
|
|
464
|
+
"type": "or",
|
|
465
|
+
"or": [
|
|
466
|
+
{
|
|
467
|
+
"type": "string",
|
|
468
|
+
"const": "formatted"
|
|
469
|
+
},
|
|
470
|
+
{
|
|
471
|
+
"type": "string",
|
|
472
|
+
"const": "deformatted"
|
|
473
|
+
}
|
|
474
|
+
],
|
|
475
|
+
"title": "Reference.dataTarget",
|
|
476
|
+
"description": "Each validation is passed the value of the data to run it's validation against.\nBy default, this is the value stored in the data-model (deformatted).\nIn the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option"
|
|
477
|
+
}
|
|
478
|
+
},
|
|
479
|
+
"displayTarget": {
|
|
480
|
+
"required": false,
|
|
481
|
+
"node": {
|
|
482
|
+
"name": "DisplayTarget",
|
|
483
|
+
"type": "or",
|
|
484
|
+
"or": [
|
|
485
|
+
{
|
|
486
|
+
"type": "string",
|
|
487
|
+
"const": "page"
|
|
488
|
+
},
|
|
489
|
+
{
|
|
490
|
+
"type": "string",
|
|
491
|
+
"const": "section"
|
|
492
|
+
},
|
|
493
|
+
{
|
|
494
|
+
"type": "string",
|
|
495
|
+
"const": "field"
|
|
496
|
+
}
|
|
497
|
+
],
|
|
498
|
+
"title": "Reference.displayTarget",
|
|
499
|
+
"description": "Where the error should be displayed"
|
|
500
|
+
}
|
|
501
|
+
}
|
|
502
|
+
},
|
|
503
|
+
"additionalProperties": {
|
|
504
|
+
"type": "unknown"
|
|
505
|
+
},
|
|
506
|
+
"title": "Reference",
|
|
507
|
+
"description": "A reference to a validation object"
|
|
508
|
+
},
|
|
509
|
+
"title": "DataType.validation",
|
|
510
|
+
"description": "Any additional validations that are associated with this property\nThese will add to any base validations associated with the \"type\""
|
|
511
|
+
}
|
|
512
|
+
},
|
|
513
|
+
"format": {
|
|
514
|
+
"required": false,
|
|
515
|
+
"node": {
|
|
516
|
+
"name": "Reference",
|
|
517
|
+
"type": "object",
|
|
518
|
+
"properties": {
|
|
519
|
+
"type": {
|
|
520
|
+
"required": true,
|
|
521
|
+
"node": {
|
|
522
|
+
"type": "string",
|
|
523
|
+
"title": "Reference.type",
|
|
524
|
+
"description": "The name of the formatter (and de-formatter) to use"
|
|
525
|
+
}
|
|
526
|
+
}
|
|
527
|
+
},
|
|
528
|
+
"additionalProperties": {
|
|
529
|
+
"type": "unknown"
|
|
530
|
+
},
|
|
531
|
+
"title": "DataType.format",
|
|
532
|
+
"description": "A reference to a specific data format to use.\nIf none is specified, will fallback to that of the base type"
|
|
533
|
+
}
|
|
534
|
+
},
|
|
535
|
+
"default": {
|
|
536
|
+
"required": false,
|
|
537
|
+
"node": {
|
|
538
|
+
"type": "ref",
|
|
539
|
+
"ref": "T",
|
|
540
|
+
"title": "DataType.default",
|
|
541
|
+
"description": "A default value for this property.\nAny reads for this property will result in this default value being written to the model."
|
|
542
|
+
}
|
|
543
|
+
},
|
|
544
|
+
"isRecord": {
|
|
545
|
+
"required": true,
|
|
546
|
+
"node": {
|
|
547
|
+
"type": "boolean",
|
|
548
|
+
"title": "RecordType.isRecord",
|
|
549
|
+
"description": "boolean to define if its a record"
|
|
550
|
+
}
|
|
551
|
+
},
|
|
552
|
+
"isArray": {
|
|
553
|
+
"required": false,
|
|
554
|
+
"node": {
|
|
555
|
+
"type": "never",
|
|
556
|
+
"title": "RecordType.isArray",
|
|
557
|
+
"description": "This property is mutually exclusive with RecordType and can not be used with ArrayType"
|
|
558
|
+
}
|
|
559
|
+
}
|
|
560
|
+
},
|
|
561
|
+
"additionalProperties": {
|
|
562
|
+
"type": "unknown"
|
|
563
|
+
},
|
|
564
|
+
"title": "RecordType",
|
|
565
|
+
"description": "Determines if the Datatype is a record object"
|
|
566
|
+
},
|
|
567
|
+
{
|
|
568
|
+
"name": "ArrayType",
|
|
569
|
+
"type": "object",
|
|
570
|
+
"properties": {
|
|
571
|
+
"type": {
|
|
572
|
+
"required": true,
|
|
573
|
+
"node": {
|
|
574
|
+
"type": "string",
|
|
575
|
+
"title": "DataType.type",
|
|
576
|
+
"description": "The reference of the base type to use"
|
|
577
|
+
}
|
|
578
|
+
},
|
|
579
|
+
"validation": {
|
|
580
|
+
"required": false,
|
|
581
|
+
"node": {
|
|
582
|
+
"type": "array",
|
|
583
|
+
"elementType": {
|
|
584
|
+
"name": "Reference",
|
|
585
|
+
"type": "object",
|
|
586
|
+
"properties": {
|
|
587
|
+
"type": {
|
|
588
|
+
"required": true,
|
|
589
|
+
"node": {
|
|
590
|
+
"type": "string",
|
|
591
|
+
"title": "Reference.type",
|
|
592
|
+
"description": "The name of the referenced validation type\nThis will be used to lookup the proper handler"
|
|
593
|
+
}
|
|
594
|
+
},
|
|
595
|
+
"message": {
|
|
596
|
+
"required": false,
|
|
597
|
+
"node": {
|
|
598
|
+
"type": "string",
|
|
599
|
+
"title": "Reference.message",
|
|
600
|
+
"description": "An optional means of overriding the default message if the validation is triggered"
|
|
601
|
+
}
|
|
602
|
+
},
|
|
603
|
+
"severity": {
|
|
604
|
+
"required": false,
|
|
605
|
+
"node": {
|
|
606
|
+
"name": "Severity",
|
|
607
|
+
"type": "or",
|
|
608
|
+
"or": [
|
|
609
|
+
{
|
|
610
|
+
"type": "string",
|
|
611
|
+
"const": "error"
|
|
612
|
+
},
|
|
613
|
+
{
|
|
614
|
+
"type": "string",
|
|
615
|
+
"const": "warning"
|
|
616
|
+
}
|
|
617
|
+
],
|
|
618
|
+
"title": "Reference.severity",
|
|
619
|
+
"description": "An optional means of overriding the default severity of the validation if triggered"
|
|
620
|
+
}
|
|
621
|
+
},
|
|
622
|
+
"trigger": {
|
|
623
|
+
"required": false,
|
|
624
|
+
"node": {
|
|
625
|
+
"name": "Trigger",
|
|
626
|
+
"type": "or",
|
|
627
|
+
"or": [
|
|
628
|
+
{
|
|
629
|
+
"type": "string",
|
|
630
|
+
"const": "navigation"
|
|
631
|
+
},
|
|
632
|
+
{
|
|
633
|
+
"type": "string",
|
|
634
|
+
"const": "change"
|
|
635
|
+
},
|
|
636
|
+
{
|
|
637
|
+
"type": "string",
|
|
638
|
+
"const": "load"
|
|
639
|
+
}
|
|
640
|
+
],
|
|
641
|
+
"title": "Reference.trigger",
|
|
642
|
+
"description": "When to run this particular validation"
|
|
643
|
+
}
|
|
644
|
+
},
|
|
645
|
+
"dataTarget": {
|
|
646
|
+
"required": false,
|
|
647
|
+
"node": {
|
|
648
|
+
"type": "or",
|
|
649
|
+
"or": [
|
|
650
|
+
{
|
|
651
|
+
"type": "string",
|
|
652
|
+
"const": "formatted"
|
|
653
|
+
},
|
|
654
|
+
{
|
|
655
|
+
"type": "string",
|
|
656
|
+
"const": "deformatted"
|
|
657
|
+
}
|
|
658
|
+
],
|
|
659
|
+
"title": "Reference.dataTarget",
|
|
660
|
+
"description": "Each validation is passed the value of the data to run it's validation against.\nBy default, this is the value stored in the data-model (deformatted).\nIn the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option"
|
|
661
|
+
}
|
|
662
|
+
},
|
|
663
|
+
"displayTarget": {
|
|
664
|
+
"required": false,
|
|
665
|
+
"node": {
|
|
666
|
+
"name": "DisplayTarget",
|
|
667
|
+
"type": "or",
|
|
668
|
+
"or": [
|
|
669
|
+
{
|
|
670
|
+
"type": "string",
|
|
671
|
+
"const": "page"
|
|
672
|
+
},
|
|
673
|
+
{
|
|
674
|
+
"type": "string",
|
|
675
|
+
"const": "section"
|
|
676
|
+
},
|
|
677
|
+
{
|
|
678
|
+
"type": "string",
|
|
679
|
+
"const": "field"
|
|
680
|
+
}
|
|
681
|
+
],
|
|
682
|
+
"title": "Reference.displayTarget",
|
|
683
|
+
"description": "Where the error should be displayed"
|
|
684
|
+
}
|
|
685
|
+
}
|
|
686
|
+
},
|
|
687
|
+
"additionalProperties": {
|
|
688
|
+
"type": "unknown"
|
|
689
|
+
},
|
|
690
|
+
"title": "Reference",
|
|
691
|
+
"description": "A reference to a validation object"
|
|
692
|
+
},
|
|
693
|
+
"title": "DataType.validation",
|
|
694
|
+
"description": "Any additional validations that are associated with this property\nThese will add to any base validations associated with the \"type\""
|
|
695
|
+
}
|
|
696
|
+
},
|
|
697
|
+
"format": {
|
|
698
|
+
"required": false,
|
|
699
|
+
"node": {
|
|
700
|
+
"name": "Reference",
|
|
701
|
+
"type": "object",
|
|
702
|
+
"properties": {
|
|
703
|
+
"type": {
|
|
704
|
+
"required": true,
|
|
705
|
+
"node": {
|
|
706
|
+
"type": "string",
|
|
707
|
+
"title": "Reference.type",
|
|
708
|
+
"description": "The name of the formatter (and de-formatter) to use"
|
|
709
|
+
}
|
|
710
|
+
}
|
|
711
|
+
},
|
|
712
|
+
"additionalProperties": {
|
|
713
|
+
"type": "unknown"
|
|
714
|
+
},
|
|
715
|
+
"title": "DataType.format",
|
|
716
|
+
"description": "A reference to a specific data format to use.\nIf none is specified, will fallback to that of the base type"
|
|
717
|
+
}
|
|
718
|
+
},
|
|
719
|
+
"default": {
|
|
720
|
+
"required": false,
|
|
721
|
+
"node": {
|
|
722
|
+
"type": "ref",
|
|
723
|
+
"ref": "T",
|
|
724
|
+
"title": "DataType.default",
|
|
725
|
+
"description": "A default value for this property.\nAny reads for this property will result in this default value being written to the model."
|
|
726
|
+
}
|
|
727
|
+
},
|
|
728
|
+
"isArray": {
|
|
729
|
+
"required": true,
|
|
730
|
+
"node": {
|
|
731
|
+
"type": "boolean",
|
|
732
|
+
"title": "ArrayType.isArray",
|
|
733
|
+
"description": "boolean to define if its an array"
|
|
734
|
+
}
|
|
735
|
+
},
|
|
736
|
+
"isRecord": {
|
|
737
|
+
"required": false,
|
|
738
|
+
"node": {
|
|
739
|
+
"type": "never",
|
|
740
|
+
"title": "ArrayType.isRecord",
|
|
741
|
+
"description": "This property is mutually exclusive with ArrayType and can not be used with RecordType"
|
|
742
|
+
}
|
|
743
|
+
}
|
|
744
|
+
},
|
|
745
|
+
"additionalProperties": {
|
|
746
|
+
"type": "unknown"
|
|
747
|
+
},
|
|
748
|
+
"title": "ArrayType",
|
|
749
|
+
"description": "Determines if the DataType is an Array Object"
|
|
750
|
+
}
|
|
751
|
+
],
|
|
752
|
+
"title": "DataTypes"
|
|
753
|
+
},
|
|
754
|
+
"title": "Schema.ROOT",
|
|
755
|
+
"description": "The ROOT object is the top level object to use"
|
|
756
|
+
}
|
|
757
|
+
}
|
|
758
|
+
},
|
|
759
|
+
"additionalProperties": {
|
|
760
|
+
"name": "Node",
|
|
761
|
+
"type": "object",
|
|
762
|
+
"properties": {},
|
|
763
|
+
"additionalProperties": {
|
|
764
|
+
"name": "DataTypes",
|
|
765
|
+
"type": "or",
|
|
766
|
+
"or": [
|
|
767
|
+
{
|
|
768
|
+
"name": "DataType",
|
|
769
|
+
"type": "object",
|
|
770
|
+
"properties": {
|
|
771
|
+
"type": {
|
|
772
|
+
"required": true,
|
|
773
|
+
"node": {
|
|
774
|
+
"type": "string",
|
|
775
|
+
"title": "DataType.type",
|
|
776
|
+
"description": "The reference of the base type to use"
|
|
777
|
+
}
|
|
778
|
+
},
|
|
779
|
+
"validation": {
|
|
780
|
+
"required": false,
|
|
781
|
+
"node": {
|
|
782
|
+
"type": "array",
|
|
783
|
+
"elementType": {
|
|
784
|
+
"name": "Reference",
|
|
785
|
+
"type": "object",
|
|
786
|
+
"properties": {
|
|
787
|
+
"type": {
|
|
788
|
+
"required": true,
|
|
789
|
+
"node": {
|
|
790
|
+
"type": "string",
|
|
791
|
+
"title": "Reference.type",
|
|
792
|
+
"description": "The name of the referenced validation type\nThis will be used to lookup the proper handler"
|
|
793
|
+
}
|
|
794
|
+
},
|
|
795
|
+
"message": {
|
|
796
|
+
"required": false,
|
|
797
|
+
"node": {
|
|
798
|
+
"type": "string",
|
|
799
|
+
"title": "Reference.message",
|
|
800
|
+
"description": "An optional means of overriding the default message if the validation is triggered"
|
|
801
|
+
}
|
|
802
|
+
},
|
|
803
|
+
"severity": {
|
|
804
|
+
"required": false,
|
|
805
|
+
"node": {
|
|
806
|
+
"name": "Severity",
|
|
807
|
+
"type": "or",
|
|
808
|
+
"or": [
|
|
809
|
+
{
|
|
810
|
+
"type": "string",
|
|
811
|
+
"const": "error"
|
|
812
|
+
},
|
|
813
|
+
{
|
|
814
|
+
"type": "string",
|
|
815
|
+
"const": "warning"
|
|
816
|
+
}
|
|
817
|
+
],
|
|
818
|
+
"title": "Reference.severity",
|
|
819
|
+
"description": "An optional means of overriding the default severity of the validation if triggered"
|
|
820
|
+
}
|
|
821
|
+
},
|
|
822
|
+
"trigger": {
|
|
823
|
+
"required": false,
|
|
824
|
+
"node": {
|
|
825
|
+
"name": "Trigger",
|
|
826
|
+
"type": "or",
|
|
827
|
+
"or": [
|
|
828
|
+
{
|
|
829
|
+
"type": "string",
|
|
830
|
+
"const": "navigation"
|
|
831
|
+
},
|
|
832
|
+
{
|
|
833
|
+
"type": "string",
|
|
834
|
+
"const": "change"
|
|
835
|
+
},
|
|
836
|
+
{
|
|
837
|
+
"type": "string",
|
|
838
|
+
"const": "load"
|
|
839
|
+
}
|
|
840
|
+
],
|
|
841
|
+
"title": "Reference.trigger",
|
|
842
|
+
"description": "When to run this particular validation"
|
|
843
|
+
}
|
|
844
|
+
},
|
|
845
|
+
"dataTarget": {
|
|
846
|
+
"required": false,
|
|
847
|
+
"node": {
|
|
848
|
+
"type": "or",
|
|
849
|
+
"or": [
|
|
850
|
+
{
|
|
851
|
+
"type": "string",
|
|
852
|
+
"const": "formatted"
|
|
853
|
+
},
|
|
854
|
+
{
|
|
855
|
+
"type": "string",
|
|
856
|
+
"const": "deformatted"
|
|
857
|
+
}
|
|
858
|
+
],
|
|
859
|
+
"title": "Reference.dataTarget",
|
|
860
|
+
"description": "Each validation is passed the value of the data to run it's validation against.\nBy default, this is the value stored in the data-model (deformatted).\nIn the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option"
|
|
861
|
+
}
|
|
862
|
+
},
|
|
863
|
+
"displayTarget": {
|
|
864
|
+
"required": false,
|
|
865
|
+
"node": {
|
|
866
|
+
"name": "DisplayTarget",
|
|
867
|
+
"type": "or",
|
|
868
|
+
"or": [
|
|
869
|
+
{
|
|
870
|
+
"type": "string",
|
|
871
|
+
"const": "page"
|
|
872
|
+
},
|
|
873
|
+
{
|
|
874
|
+
"type": "string",
|
|
875
|
+
"const": "section"
|
|
876
|
+
},
|
|
877
|
+
{
|
|
878
|
+
"type": "string",
|
|
879
|
+
"const": "field"
|
|
880
|
+
}
|
|
881
|
+
],
|
|
882
|
+
"title": "Reference.displayTarget",
|
|
883
|
+
"description": "Where the error should be displayed"
|
|
884
|
+
}
|
|
885
|
+
}
|
|
886
|
+
},
|
|
887
|
+
"additionalProperties": {
|
|
888
|
+
"type": "unknown"
|
|
889
|
+
},
|
|
890
|
+
"title": "Reference",
|
|
891
|
+
"description": "A reference to a validation object"
|
|
892
|
+
},
|
|
893
|
+
"title": "DataType.validation",
|
|
894
|
+
"description": "Any additional validations that are associated with this property\nThese will add to any base validations associated with the \"type\""
|
|
895
|
+
}
|
|
896
|
+
},
|
|
897
|
+
"format": {
|
|
898
|
+
"required": false,
|
|
899
|
+
"node": {
|
|
900
|
+
"name": "Reference",
|
|
901
|
+
"type": "object",
|
|
902
|
+
"properties": {
|
|
903
|
+
"type": {
|
|
904
|
+
"required": true,
|
|
905
|
+
"node": {
|
|
906
|
+
"type": "string",
|
|
907
|
+
"title": "Reference.type",
|
|
908
|
+
"description": "The name of the formatter (and de-formatter) to use"
|
|
909
|
+
}
|
|
910
|
+
}
|
|
911
|
+
},
|
|
912
|
+
"additionalProperties": {
|
|
913
|
+
"type": "unknown"
|
|
914
|
+
},
|
|
915
|
+
"title": "DataType.format",
|
|
916
|
+
"description": "A reference to a specific data format to use.\nIf none is specified, will fallback to that of the base type"
|
|
917
|
+
}
|
|
918
|
+
},
|
|
919
|
+
"default": {
|
|
920
|
+
"required": false,
|
|
921
|
+
"node": {
|
|
922
|
+
"type": "ref",
|
|
923
|
+
"ref": "T",
|
|
924
|
+
"title": "DataType.default",
|
|
925
|
+
"description": "A default value for this property.\nAny reads for this property will result in this default value being written to the model."
|
|
926
|
+
}
|
|
927
|
+
}
|
|
928
|
+
},
|
|
929
|
+
"additionalProperties": {
|
|
930
|
+
"type": "unknown"
|
|
931
|
+
},
|
|
932
|
+
"title": "DataType",
|
|
933
|
+
"description": "Each prop in the object can have a specific DataType",
|
|
934
|
+
"genericTokens": [
|
|
935
|
+
{
|
|
936
|
+
"symbol": "T",
|
|
937
|
+
"constraints": {
|
|
938
|
+
"type": "any"
|
|
939
|
+
},
|
|
940
|
+
"default": {
|
|
941
|
+
"type": "unknown"
|
|
942
|
+
}
|
|
943
|
+
}
|
|
944
|
+
]
|
|
945
|
+
},
|
|
946
|
+
{
|
|
947
|
+
"name": "RecordType",
|
|
948
|
+
"type": "object",
|
|
949
|
+
"properties": {
|
|
950
|
+
"type": {
|
|
951
|
+
"required": true,
|
|
952
|
+
"node": {
|
|
953
|
+
"type": "string",
|
|
954
|
+
"title": "DataType.type",
|
|
955
|
+
"description": "The reference of the base type to use"
|
|
956
|
+
}
|
|
957
|
+
},
|
|
958
|
+
"validation": {
|
|
959
|
+
"required": false,
|
|
960
|
+
"node": {
|
|
961
|
+
"type": "array",
|
|
962
|
+
"elementType": {
|
|
963
|
+
"name": "Reference",
|
|
964
|
+
"type": "object",
|
|
965
|
+
"properties": {
|
|
966
|
+
"type": {
|
|
967
|
+
"required": true,
|
|
968
|
+
"node": {
|
|
969
|
+
"type": "string",
|
|
970
|
+
"title": "Reference.type",
|
|
971
|
+
"description": "The name of the referenced validation type\nThis will be used to lookup the proper handler"
|
|
972
|
+
}
|
|
973
|
+
},
|
|
974
|
+
"message": {
|
|
975
|
+
"required": false,
|
|
976
|
+
"node": {
|
|
977
|
+
"type": "string",
|
|
978
|
+
"title": "Reference.message",
|
|
979
|
+
"description": "An optional means of overriding the default message if the validation is triggered"
|
|
980
|
+
}
|
|
981
|
+
},
|
|
982
|
+
"severity": {
|
|
983
|
+
"required": false,
|
|
984
|
+
"node": {
|
|
985
|
+
"name": "Severity",
|
|
986
|
+
"type": "or",
|
|
987
|
+
"or": [
|
|
988
|
+
{
|
|
989
|
+
"type": "string",
|
|
990
|
+
"const": "error"
|
|
991
|
+
},
|
|
992
|
+
{
|
|
993
|
+
"type": "string",
|
|
994
|
+
"const": "warning"
|
|
995
|
+
}
|
|
996
|
+
],
|
|
997
|
+
"title": "Reference.severity",
|
|
998
|
+
"description": "An optional means of overriding the default severity of the validation if triggered"
|
|
999
|
+
}
|
|
1000
|
+
},
|
|
1001
|
+
"trigger": {
|
|
1002
|
+
"required": false,
|
|
1003
|
+
"node": {
|
|
1004
|
+
"name": "Trigger",
|
|
1005
|
+
"type": "or",
|
|
1006
|
+
"or": [
|
|
1007
|
+
{
|
|
1008
|
+
"type": "string",
|
|
1009
|
+
"const": "navigation"
|
|
1010
|
+
},
|
|
1011
|
+
{
|
|
1012
|
+
"type": "string",
|
|
1013
|
+
"const": "change"
|
|
1014
|
+
},
|
|
1015
|
+
{
|
|
1016
|
+
"type": "string",
|
|
1017
|
+
"const": "load"
|
|
1018
|
+
}
|
|
1019
|
+
],
|
|
1020
|
+
"title": "Reference.trigger",
|
|
1021
|
+
"description": "When to run this particular validation"
|
|
1022
|
+
}
|
|
1023
|
+
},
|
|
1024
|
+
"dataTarget": {
|
|
1025
|
+
"required": false,
|
|
1026
|
+
"node": {
|
|
1027
|
+
"type": "or",
|
|
1028
|
+
"or": [
|
|
1029
|
+
{
|
|
1030
|
+
"type": "string",
|
|
1031
|
+
"const": "formatted"
|
|
1032
|
+
},
|
|
1033
|
+
{
|
|
1034
|
+
"type": "string",
|
|
1035
|
+
"const": "deformatted"
|
|
1036
|
+
}
|
|
1037
|
+
],
|
|
1038
|
+
"title": "Reference.dataTarget",
|
|
1039
|
+
"description": "Each validation is passed the value of the data to run it's validation against.\nBy default, this is the value stored in the data-model (deformatted).\nIn the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option"
|
|
1040
|
+
}
|
|
1041
|
+
},
|
|
1042
|
+
"displayTarget": {
|
|
1043
|
+
"required": false,
|
|
1044
|
+
"node": {
|
|
1045
|
+
"name": "DisplayTarget",
|
|
1046
|
+
"type": "or",
|
|
1047
|
+
"or": [
|
|
1048
|
+
{
|
|
1049
|
+
"type": "string",
|
|
1050
|
+
"const": "page"
|
|
1051
|
+
},
|
|
1052
|
+
{
|
|
1053
|
+
"type": "string",
|
|
1054
|
+
"const": "section"
|
|
1055
|
+
},
|
|
1056
|
+
{
|
|
1057
|
+
"type": "string",
|
|
1058
|
+
"const": "field"
|
|
1059
|
+
}
|
|
1060
|
+
],
|
|
1061
|
+
"title": "Reference.displayTarget",
|
|
1062
|
+
"description": "Where the error should be displayed"
|
|
1063
|
+
}
|
|
1064
|
+
}
|
|
1065
|
+
},
|
|
1066
|
+
"additionalProperties": {
|
|
1067
|
+
"type": "unknown"
|
|
1068
|
+
},
|
|
1069
|
+
"title": "Reference",
|
|
1070
|
+
"description": "A reference to a validation object"
|
|
1071
|
+
},
|
|
1072
|
+
"title": "DataType.validation",
|
|
1073
|
+
"description": "Any additional validations that are associated with this property\nThese will add to any base validations associated with the \"type\""
|
|
1074
|
+
}
|
|
1075
|
+
},
|
|
1076
|
+
"format": {
|
|
1077
|
+
"required": false,
|
|
1078
|
+
"node": {
|
|
1079
|
+
"name": "Reference",
|
|
1080
|
+
"type": "object",
|
|
1081
|
+
"properties": {
|
|
1082
|
+
"type": {
|
|
1083
|
+
"required": true,
|
|
1084
|
+
"node": {
|
|
1085
|
+
"type": "string",
|
|
1086
|
+
"title": "Reference.type",
|
|
1087
|
+
"description": "The name of the formatter (and de-formatter) to use"
|
|
1088
|
+
}
|
|
1089
|
+
}
|
|
1090
|
+
},
|
|
1091
|
+
"additionalProperties": {
|
|
1092
|
+
"type": "unknown"
|
|
1093
|
+
},
|
|
1094
|
+
"title": "DataType.format",
|
|
1095
|
+
"description": "A reference to a specific data format to use.\nIf none is specified, will fallback to that of the base type"
|
|
1096
|
+
}
|
|
1097
|
+
},
|
|
1098
|
+
"default": {
|
|
1099
|
+
"required": false,
|
|
1100
|
+
"node": {
|
|
1101
|
+
"type": "ref",
|
|
1102
|
+
"ref": "T",
|
|
1103
|
+
"title": "DataType.default",
|
|
1104
|
+
"description": "A default value for this property.\nAny reads for this property will result in this default value being written to the model."
|
|
1105
|
+
}
|
|
1106
|
+
},
|
|
1107
|
+
"isRecord": {
|
|
1108
|
+
"required": true,
|
|
1109
|
+
"node": {
|
|
1110
|
+
"type": "boolean",
|
|
1111
|
+
"title": "RecordType.isRecord",
|
|
1112
|
+
"description": "boolean to define if its a record"
|
|
1113
|
+
}
|
|
1114
|
+
},
|
|
1115
|
+
"isArray": {
|
|
1116
|
+
"required": false,
|
|
1117
|
+
"node": {
|
|
1118
|
+
"type": "never",
|
|
1119
|
+
"title": "RecordType.isArray",
|
|
1120
|
+
"description": "This property is mutually exclusive with RecordType and can not be used with ArrayType"
|
|
1121
|
+
}
|
|
1122
|
+
}
|
|
1123
|
+
},
|
|
1124
|
+
"additionalProperties": {
|
|
1125
|
+
"type": "unknown"
|
|
1126
|
+
},
|
|
1127
|
+
"title": "RecordType",
|
|
1128
|
+
"description": "Determines if the Datatype is a record object"
|
|
1129
|
+
},
|
|
1130
|
+
{
|
|
1131
|
+
"name": "ArrayType",
|
|
1132
|
+
"type": "object",
|
|
1133
|
+
"properties": {
|
|
1134
|
+
"type": {
|
|
1135
|
+
"required": true,
|
|
1136
|
+
"node": {
|
|
1137
|
+
"type": "string",
|
|
1138
|
+
"title": "DataType.type",
|
|
1139
|
+
"description": "The reference of the base type to use"
|
|
1140
|
+
}
|
|
1141
|
+
},
|
|
1142
|
+
"validation": {
|
|
1143
|
+
"required": false,
|
|
1144
|
+
"node": {
|
|
1145
|
+
"type": "array",
|
|
1146
|
+
"elementType": {
|
|
1147
|
+
"name": "Reference",
|
|
1148
|
+
"type": "object",
|
|
1149
|
+
"properties": {
|
|
1150
|
+
"type": {
|
|
1151
|
+
"required": true,
|
|
1152
|
+
"node": {
|
|
1153
|
+
"type": "string",
|
|
1154
|
+
"title": "Reference.type",
|
|
1155
|
+
"description": "The name of the referenced validation type\nThis will be used to lookup the proper handler"
|
|
1156
|
+
}
|
|
1157
|
+
},
|
|
1158
|
+
"message": {
|
|
1159
|
+
"required": false,
|
|
1160
|
+
"node": {
|
|
1161
|
+
"type": "string",
|
|
1162
|
+
"title": "Reference.message",
|
|
1163
|
+
"description": "An optional means of overriding the default message if the validation is triggered"
|
|
1164
|
+
}
|
|
1165
|
+
},
|
|
1166
|
+
"severity": {
|
|
1167
|
+
"required": false,
|
|
1168
|
+
"node": {
|
|
1169
|
+
"name": "Severity",
|
|
1170
|
+
"type": "or",
|
|
1171
|
+
"or": [
|
|
1172
|
+
{
|
|
1173
|
+
"type": "string",
|
|
1174
|
+
"const": "error"
|
|
1175
|
+
},
|
|
1176
|
+
{
|
|
1177
|
+
"type": "string",
|
|
1178
|
+
"const": "warning"
|
|
1179
|
+
}
|
|
1180
|
+
],
|
|
1181
|
+
"title": "Reference.severity",
|
|
1182
|
+
"description": "An optional means of overriding the default severity of the validation if triggered"
|
|
1183
|
+
}
|
|
1184
|
+
},
|
|
1185
|
+
"trigger": {
|
|
1186
|
+
"required": false,
|
|
1187
|
+
"node": {
|
|
1188
|
+
"name": "Trigger",
|
|
1189
|
+
"type": "or",
|
|
1190
|
+
"or": [
|
|
1191
|
+
{
|
|
1192
|
+
"type": "string",
|
|
1193
|
+
"const": "navigation"
|
|
1194
|
+
},
|
|
1195
|
+
{
|
|
1196
|
+
"type": "string",
|
|
1197
|
+
"const": "change"
|
|
1198
|
+
},
|
|
1199
|
+
{
|
|
1200
|
+
"type": "string",
|
|
1201
|
+
"const": "load"
|
|
1202
|
+
}
|
|
1203
|
+
],
|
|
1204
|
+
"title": "Reference.trigger",
|
|
1205
|
+
"description": "When to run this particular validation"
|
|
1206
|
+
}
|
|
1207
|
+
},
|
|
1208
|
+
"dataTarget": {
|
|
1209
|
+
"required": false,
|
|
1210
|
+
"node": {
|
|
1211
|
+
"type": "or",
|
|
1212
|
+
"or": [
|
|
1213
|
+
{
|
|
1214
|
+
"type": "string",
|
|
1215
|
+
"const": "formatted"
|
|
1216
|
+
},
|
|
1217
|
+
{
|
|
1218
|
+
"type": "string",
|
|
1219
|
+
"const": "deformatted"
|
|
1220
|
+
}
|
|
1221
|
+
],
|
|
1222
|
+
"title": "Reference.dataTarget",
|
|
1223
|
+
"description": "Each validation is passed the value of the data to run it's validation against.\nBy default, this is the value stored in the data-model (deformatted).\nIn the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option"
|
|
1224
|
+
}
|
|
1225
|
+
},
|
|
1226
|
+
"displayTarget": {
|
|
1227
|
+
"required": false,
|
|
1228
|
+
"node": {
|
|
1229
|
+
"name": "DisplayTarget",
|
|
1230
|
+
"type": "or",
|
|
1231
|
+
"or": [
|
|
1232
|
+
{
|
|
1233
|
+
"type": "string",
|
|
1234
|
+
"const": "page"
|
|
1235
|
+
},
|
|
1236
|
+
{
|
|
1237
|
+
"type": "string",
|
|
1238
|
+
"const": "section"
|
|
1239
|
+
},
|
|
1240
|
+
{
|
|
1241
|
+
"type": "string",
|
|
1242
|
+
"const": "field"
|
|
1243
|
+
}
|
|
1244
|
+
],
|
|
1245
|
+
"title": "Reference.displayTarget",
|
|
1246
|
+
"description": "Where the error should be displayed"
|
|
1247
|
+
}
|
|
1248
|
+
}
|
|
1249
|
+
},
|
|
1250
|
+
"additionalProperties": {
|
|
1251
|
+
"type": "unknown"
|
|
1252
|
+
},
|
|
1253
|
+
"title": "Reference",
|
|
1254
|
+
"description": "A reference to a validation object"
|
|
1255
|
+
},
|
|
1256
|
+
"title": "DataType.validation",
|
|
1257
|
+
"description": "Any additional validations that are associated with this property\nThese will add to any base validations associated with the \"type\""
|
|
1258
|
+
}
|
|
1259
|
+
},
|
|
1260
|
+
"format": {
|
|
1261
|
+
"required": false,
|
|
1262
|
+
"node": {
|
|
1263
|
+
"name": "Reference",
|
|
1264
|
+
"type": "object",
|
|
1265
|
+
"properties": {
|
|
1266
|
+
"type": {
|
|
1267
|
+
"required": true,
|
|
1268
|
+
"node": {
|
|
1269
|
+
"type": "string",
|
|
1270
|
+
"title": "Reference.type",
|
|
1271
|
+
"description": "The name of the formatter (and de-formatter) to use"
|
|
1272
|
+
}
|
|
1273
|
+
}
|
|
1274
|
+
},
|
|
1275
|
+
"additionalProperties": {
|
|
1276
|
+
"type": "unknown"
|
|
1277
|
+
},
|
|
1278
|
+
"title": "DataType.format",
|
|
1279
|
+
"description": "A reference to a specific data format to use.\nIf none is specified, will fallback to that of the base type"
|
|
1280
|
+
}
|
|
1281
|
+
},
|
|
1282
|
+
"default": {
|
|
1283
|
+
"required": false,
|
|
1284
|
+
"node": {
|
|
1285
|
+
"type": "ref",
|
|
1286
|
+
"ref": "T",
|
|
1287
|
+
"title": "DataType.default",
|
|
1288
|
+
"description": "A default value for this property.\nAny reads for this property will result in this default value being written to the model."
|
|
1289
|
+
}
|
|
1290
|
+
},
|
|
1291
|
+
"isArray": {
|
|
1292
|
+
"required": true,
|
|
1293
|
+
"node": {
|
|
1294
|
+
"type": "boolean",
|
|
1295
|
+
"title": "ArrayType.isArray",
|
|
1296
|
+
"description": "boolean to define if its an array"
|
|
1297
|
+
}
|
|
1298
|
+
},
|
|
1299
|
+
"isRecord": {
|
|
1300
|
+
"required": false,
|
|
1301
|
+
"node": {
|
|
1302
|
+
"type": "never",
|
|
1303
|
+
"title": "ArrayType.isRecord",
|
|
1304
|
+
"description": "This property is mutually exclusive with ArrayType and can not be used with RecordType"
|
|
1305
|
+
}
|
|
1306
|
+
}
|
|
1307
|
+
},
|
|
1308
|
+
"additionalProperties": {
|
|
1309
|
+
"type": "unknown"
|
|
1310
|
+
},
|
|
1311
|
+
"title": "ArrayType",
|
|
1312
|
+
"description": "Determines if the DataType is an Array Object"
|
|
1313
|
+
}
|
|
1314
|
+
],
|
|
1315
|
+
"title": "DataTypes"
|
|
1316
|
+
},
|
|
1317
|
+
"title": "Node",
|
|
1318
|
+
"description": "A Node describes a specific object in the tree"
|
|
1319
|
+
},
|
|
1320
|
+
"title": "Flow.schema",
|
|
1321
|
+
"description": "The schema for the supplied (or referenced data).\nThis is used for validation, formatting, etc"
|
|
1322
|
+
}
|
|
1323
|
+
},
|
|
1324
|
+
"data": {
|
|
1325
|
+
"required": false,
|
|
1326
|
+
"node": {
|
|
1327
|
+
"source": "core/types/src/index.ts",
|
|
1328
|
+
"name": "DataModel",
|
|
1329
|
+
"type": "record",
|
|
1330
|
+
"keyType": {
|
|
1331
|
+
"type": "any"
|
|
1332
|
+
},
|
|
1333
|
+
"valueType": {
|
|
1334
|
+
"type": "unknown"
|
|
1335
|
+
},
|
|
1336
|
+
"title": "Flow.data",
|
|
1337
|
+
"description": "Any initial data that the flow can use"
|
|
1338
|
+
}
|
|
1339
|
+
},
|
|
1340
|
+
"navigation": {
|
|
1341
|
+
"required": true,
|
|
1342
|
+
"node": {
|
|
1343
|
+
"source": "core/types/src/index.ts",
|
|
1344
|
+
"name": "Navigation",
|
|
1345
|
+
"type": "and",
|
|
1346
|
+
"and": [
|
|
1347
|
+
{
|
|
1348
|
+
"type": "object",
|
|
1349
|
+
"properties": {
|
|
1350
|
+
"BEGIN": {
|
|
1351
|
+
"required": true,
|
|
1352
|
+
"node": {
|
|
1353
|
+
"type": "string",
|
|
1354
|
+
"title": "BEGIN",
|
|
1355
|
+
"description": "The name of the Flow to begin on"
|
|
1356
|
+
}
|
|
1357
|
+
}
|
|
1358
|
+
},
|
|
1359
|
+
"additionalProperties": false
|
|
1360
|
+
},
|
|
1361
|
+
{
|
|
1362
|
+
"type": "record",
|
|
1363
|
+
"keyType": {
|
|
1364
|
+
"type": "string"
|
|
1365
|
+
},
|
|
1366
|
+
"valueType": {
|
|
1367
|
+
"type": "or",
|
|
1368
|
+
"or": [
|
|
1369
|
+
{
|
|
1370
|
+
"type": "string"
|
|
1371
|
+
},
|
|
1372
|
+
{
|
|
1373
|
+
"source": "core/types/src/index.ts",
|
|
1374
|
+
"name": "NavigationFlow",
|
|
1375
|
+
"type": "object",
|
|
1376
|
+
"properties": {
|
|
1377
|
+
"startState": {
|
|
1378
|
+
"required": true,
|
|
1379
|
+
"node": {
|
|
1380
|
+
"type": "string",
|
|
1381
|
+
"title": "NavigationFlow.startState",
|
|
1382
|
+
"description": "The first state to kick off the state machine"
|
|
1383
|
+
}
|
|
1384
|
+
},
|
|
1385
|
+
"onStart": {
|
|
1386
|
+
"required": false,
|
|
1387
|
+
"node": {
|
|
1388
|
+
"type": "or",
|
|
1389
|
+
"or": [
|
|
1390
|
+
{
|
|
1391
|
+
"type": "ref",
|
|
1392
|
+
"ref": "Expression",
|
|
1393
|
+
"title": "NavigationFlow.onStart"
|
|
1394
|
+
},
|
|
1395
|
+
{
|
|
1396
|
+
"source": "core/types/src/index.ts",
|
|
1397
|
+
"name": "ExpressionObject",
|
|
1398
|
+
"type": "object",
|
|
1399
|
+
"properties": {
|
|
1400
|
+
"exp": {
|
|
1401
|
+
"required": false,
|
|
1402
|
+
"node": {
|
|
1403
|
+
"type": "ref",
|
|
1404
|
+
"ref": "Expression",
|
|
1405
|
+
"title": "ExpressionObject.exp",
|
|
1406
|
+
"description": "The expression to run"
|
|
1407
|
+
}
|
|
1408
|
+
}
|
|
1409
|
+
},
|
|
1410
|
+
"additionalProperties": false,
|
|
1411
|
+
"title": "ExpressionObject",
|
|
1412
|
+
"description": "An object with an expression in it"
|
|
1413
|
+
}
|
|
1414
|
+
],
|
|
1415
|
+
"title": "NavigationFlow.onStart",
|
|
1416
|
+
"description": "An optional expression to run when this Flow starts"
|
|
1417
|
+
}
|
|
1418
|
+
},
|
|
1419
|
+
"onEnd": {
|
|
1420
|
+
"required": false,
|
|
1421
|
+
"node": {
|
|
1422
|
+
"type": "or",
|
|
1423
|
+
"or": [
|
|
1424
|
+
{
|
|
1425
|
+
"type": "ref",
|
|
1426
|
+
"ref": "Expression",
|
|
1427
|
+
"title": "NavigationFlow.onEnd"
|
|
1428
|
+
},
|
|
1429
|
+
{
|
|
1430
|
+
"source": "core/types/src/index.ts",
|
|
1431
|
+
"name": "ExpressionObject",
|
|
1432
|
+
"type": "object",
|
|
1433
|
+
"properties": {
|
|
1434
|
+
"exp": {
|
|
1435
|
+
"required": false,
|
|
1436
|
+
"node": {
|
|
1437
|
+
"type": "ref",
|
|
1438
|
+
"ref": "Expression",
|
|
1439
|
+
"title": "ExpressionObject.exp",
|
|
1440
|
+
"description": "The expression to run"
|
|
1441
|
+
}
|
|
1442
|
+
}
|
|
1443
|
+
},
|
|
1444
|
+
"additionalProperties": false,
|
|
1445
|
+
"title": "ExpressionObject",
|
|
1446
|
+
"description": "An object with an expression in it"
|
|
1447
|
+
}
|
|
1448
|
+
],
|
|
1449
|
+
"title": "NavigationFlow.onEnd",
|
|
1450
|
+
"description": "An optional expression to run when this Flow ends"
|
|
1451
|
+
}
|
|
1452
|
+
}
|
|
1453
|
+
},
|
|
1454
|
+
"additionalProperties": {
|
|
1455
|
+
"type": "or",
|
|
1456
|
+
"or": [
|
|
1457
|
+
{
|
|
1458
|
+
"type": "undefined"
|
|
1459
|
+
},
|
|
1460
|
+
{
|
|
1461
|
+
"type": "string"
|
|
1462
|
+
},
|
|
1463
|
+
{
|
|
1464
|
+
"type": "ref",
|
|
1465
|
+
"ref": "Expression"
|
|
1466
|
+
},
|
|
1467
|
+
{
|
|
1468
|
+
"source": "core/types/src/index.ts",
|
|
1469
|
+
"name": "ExpressionObject",
|
|
1470
|
+
"type": "object",
|
|
1471
|
+
"properties": {
|
|
1472
|
+
"exp": {
|
|
1473
|
+
"required": false,
|
|
1474
|
+
"node": {
|
|
1475
|
+
"type": "ref",
|
|
1476
|
+
"ref": "Expression",
|
|
1477
|
+
"title": "ExpressionObject.exp",
|
|
1478
|
+
"description": "The expression to run"
|
|
1479
|
+
}
|
|
1480
|
+
}
|
|
1481
|
+
},
|
|
1482
|
+
"additionalProperties": false,
|
|
1483
|
+
"title": "ExpressionObject",
|
|
1484
|
+
"description": "An object with an expression in it"
|
|
1485
|
+
},
|
|
1486
|
+
{
|
|
1487
|
+
"source": "core/types/src/index.ts",
|
|
1488
|
+
"name": "NavigationFlowState",
|
|
1489
|
+
"type": "or",
|
|
1490
|
+
"or": [
|
|
1491
|
+
{
|
|
1492
|
+
"source": "core/types/src/index.ts",
|
|
1493
|
+
"name": "NavigationFlowViewState",
|
|
1494
|
+
"type": "object",
|
|
1495
|
+
"properties": {
|
|
1496
|
+
"_comment": {
|
|
1497
|
+
"required": false,
|
|
1498
|
+
"node": {
|
|
1499
|
+
"type": "string",
|
|
1500
|
+
"title": "CommentBase._comment",
|
|
1501
|
+
"description": "Add comments that will not be processing, but are useful for code explanation"
|
|
1502
|
+
}
|
|
1503
|
+
},
|
|
1504
|
+
"state_type": {
|
|
1505
|
+
"required": true,
|
|
1506
|
+
"node": {
|
|
1507
|
+
"type": "string",
|
|
1508
|
+
"const": "VIEW",
|
|
1509
|
+
"title": "NavigationBaseState.state_type",
|
|
1510
|
+
"description": "A property to determine the type of state this is"
|
|
1511
|
+
}
|
|
1512
|
+
},
|
|
1513
|
+
"onStart": {
|
|
1514
|
+
"required": false,
|
|
1515
|
+
"node": {
|
|
1516
|
+
"type": "or",
|
|
1517
|
+
"or": [
|
|
1518
|
+
{
|
|
1519
|
+
"type": "ref",
|
|
1520
|
+
"ref": "Expression",
|
|
1521
|
+
"title": "NavigationBaseState.onStart"
|
|
1522
|
+
},
|
|
1523
|
+
{
|
|
1524
|
+
"source": "core/types/src/index.ts",
|
|
1525
|
+
"name": "ExpressionObject",
|
|
1526
|
+
"type": "object",
|
|
1527
|
+
"properties": {
|
|
1528
|
+
"exp": {
|
|
1529
|
+
"required": false,
|
|
1530
|
+
"node": {
|
|
1531
|
+
"type": "ref",
|
|
1532
|
+
"ref": "Expression",
|
|
1533
|
+
"title": "ExpressionObject.exp",
|
|
1534
|
+
"description": "The expression to run"
|
|
1535
|
+
}
|
|
1536
|
+
}
|
|
1537
|
+
},
|
|
1538
|
+
"additionalProperties": false,
|
|
1539
|
+
"title": "ExpressionObject",
|
|
1540
|
+
"description": "An object with an expression in it"
|
|
1541
|
+
}
|
|
1542
|
+
],
|
|
1543
|
+
"title": "NavigationBaseState.onStart",
|
|
1544
|
+
"description": "An optional expression to run when this view renders"
|
|
1545
|
+
}
|
|
1546
|
+
},
|
|
1547
|
+
"onEnd": {
|
|
1548
|
+
"required": false,
|
|
1549
|
+
"node": {
|
|
1550
|
+
"type": "or",
|
|
1551
|
+
"or": [
|
|
1552
|
+
{
|
|
1553
|
+
"type": "ref",
|
|
1554
|
+
"ref": "Expression",
|
|
1555
|
+
"title": "NavigationBaseState.onEnd"
|
|
1556
|
+
},
|
|
1557
|
+
{
|
|
1558
|
+
"source": "core/types/src/index.ts",
|
|
1559
|
+
"name": "ExpressionObject",
|
|
1560
|
+
"type": "object",
|
|
1561
|
+
"properties": {
|
|
1562
|
+
"exp": {
|
|
1563
|
+
"required": false,
|
|
1564
|
+
"node": {
|
|
1565
|
+
"type": "ref",
|
|
1566
|
+
"ref": "Expression",
|
|
1567
|
+
"title": "ExpressionObject.exp",
|
|
1568
|
+
"description": "The expression to run"
|
|
1569
|
+
}
|
|
1570
|
+
}
|
|
1571
|
+
},
|
|
1572
|
+
"additionalProperties": false,
|
|
1573
|
+
"title": "ExpressionObject",
|
|
1574
|
+
"description": "An object with an expression in it"
|
|
1575
|
+
}
|
|
1576
|
+
],
|
|
1577
|
+
"title": "NavigationBaseState.onEnd",
|
|
1578
|
+
"description": "An optional expression to run before view transition"
|
|
1579
|
+
}
|
|
1580
|
+
},
|
|
1581
|
+
"exp": {
|
|
1582
|
+
"required": false,
|
|
1583
|
+
"node": {
|
|
1584
|
+
"title": "NavigationBaseState.exp",
|
|
1585
|
+
"type": "never"
|
|
1586
|
+
}
|
|
1587
|
+
},
|
|
1588
|
+
"transitions": {
|
|
1589
|
+
"required": true,
|
|
1590
|
+
"node": {
|
|
1591
|
+
"source": "core/types/src/index.ts",
|
|
1592
|
+
"name": "NavigationFlowTransition",
|
|
1593
|
+
"type": "record",
|
|
1594
|
+
"keyType": {
|
|
1595
|
+
"type": "string"
|
|
1596
|
+
},
|
|
1597
|
+
"valueType": {
|
|
1598
|
+
"type": "string"
|
|
1599
|
+
},
|
|
1600
|
+
"title": "NavigationFlowTransitionableState.transitions",
|
|
1601
|
+
"description": "A mapping of transition-name to FlowState name"
|
|
1602
|
+
}
|
|
1603
|
+
},
|
|
1604
|
+
"ref": {
|
|
1605
|
+
"required": true,
|
|
1606
|
+
"node": {
|
|
1607
|
+
"type": "string",
|
|
1608
|
+
"title": "NavigationFlowViewState.ref",
|
|
1609
|
+
"description": "An id corresponding to a view from the 'views' array"
|
|
1610
|
+
}
|
|
1611
|
+
},
|
|
1612
|
+
"attributes": {
|
|
1613
|
+
"required": false,
|
|
1614
|
+
"node": {
|
|
1615
|
+
"type": "object",
|
|
1616
|
+
"properties": {},
|
|
1617
|
+
"additionalProperties": {
|
|
1618
|
+
"type": "any"
|
|
1619
|
+
},
|
|
1620
|
+
"title": "NavigationFlowViewState.attributes",
|
|
1621
|
+
"description": "View meta-properties"
|
|
1622
|
+
}
|
|
1623
|
+
}
|
|
1624
|
+
},
|
|
1625
|
+
"additionalProperties": false,
|
|
1626
|
+
"title": "NavigationFlowViewState",
|
|
1627
|
+
"description": "A state representing a view"
|
|
1628
|
+
},
|
|
1629
|
+
{
|
|
1630
|
+
"source": "core/types/src/index.ts",
|
|
1631
|
+
"name": "NavigationFlowEndState",
|
|
1632
|
+
"type": "object",
|
|
1633
|
+
"properties": {
|
|
1634
|
+
"_comment": {
|
|
1635
|
+
"required": false,
|
|
1636
|
+
"node": {
|
|
1637
|
+
"type": "string",
|
|
1638
|
+
"title": "CommentBase._comment",
|
|
1639
|
+
"description": "Add comments that will not be processing, but are useful for code explanation"
|
|
1640
|
+
}
|
|
1641
|
+
},
|
|
1642
|
+
"state_type": {
|
|
1643
|
+
"required": true,
|
|
1644
|
+
"node": {
|
|
1645
|
+
"type": "string",
|
|
1646
|
+
"const": "END",
|
|
1647
|
+
"title": "NavigationBaseState.state_type",
|
|
1648
|
+
"description": "A property to determine the type of state this is"
|
|
1649
|
+
}
|
|
1650
|
+
},
|
|
1651
|
+
"onStart": {
|
|
1652
|
+
"required": false,
|
|
1653
|
+
"node": {
|
|
1654
|
+
"type": "or",
|
|
1655
|
+
"or": [
|
|
1656
|
+
{
|
|
1657
|
+
"type": "ref",
|
|
1658
|
+
"ref": "Expression",
|
|
1659
|
+
"title": "NavigationBaseState.onStart"
|
|
1660
|
+
},
|
|
1661
|
+
{
|
|
1662
|
+
"source": "core/types/src/index.ts",
|
|
1663
|
+
"name": "ExpressionObject",
|
|
1664
|
+
"type": "object",
|
|
1665
|
+
"properties": {
|
|
1666
|
+
"exp": {
|
|
1667
|
+
"required": false,
|
|
1668
|
+
"node": {
|
|
1669
|
+
"type": "ref",
|
|
1670
|
+
"ref": "Expression",
|
|
1671
|
+
"title": "ExpressionObject.exp",
|
|
1672
|
+
"description": "The expression to run"
|
|
1673
|
+
}
|
|
1674
|
+
}
|
|
1675
|
+
},
|
|
1676
|
+
"additionalProperties": false,
|
|
1677
|
+
"title": "ExpressionObject",
|
|
1678
|
+
"description": "An object with an expression in it"
|
|
1679
|
+
}
|
|
1680
|
+
],
|
|
1681
|
+
"title": "NavigationBaseState.onStart",
|
|
1682
|
+
"description": "An optional expression to run when this view renders"
|
|
1683
|
+
}
|
|
1684
|
+
},
|
|
1685
|
+
"onEnd": {
|
|
1686
|
+
"required": false,
|
|
1687
|
+
"node": {
|
|
1688
|
+
"type": "or",
|
|
1689
|
+
"or": [
|
|
1690
|
+
{
|
|
1691
|
+
"type": "ref",
|
|
1692
|
+
"ref": "Expression",
|
|
1693
|
+
"title": "NavigationBaseState.onEnd"
|
|
1694
|
+
},
|
|
1695
|
+
{
|
|
1696
|
+
"source": "core/types/src/index.ts",
|
|
1697
|
+
"name": "ExpressionObject",
|
|
1698
|
+
"type": "object",
|
|
1699
|
+
"properties": {
|
|
1700
|
+
"exp": {
|
|
1701
|
+
"required": false,
|
|
1702
|
+
"node": {
|
|
1703
|
+
"type": "ref",
|
|
1704
|
+
"ref": "Expression",
|
|
1705
|
+
"title": "ExpressionObject.exp",
|
|
1706
|
+
"description": "The expression to run"
|
|
1707
|
+
}
|
|
1708
|
+
}
|
|
1709
|
+
},
|
|
1710
|
+
"additionalProperties": false,
|
|
1711
|
+
"title": "ExpressionObject",
|
|
1712
|
+
"description": "An object with an expression in it"
|
|
1713
|
+
}
|
|
1714
|
+
],
|
|
1715
|
+
"title": "NavigationBaseState.onEnd",
|
|
1716
|
+
"description": "An optional expression to run before view transition"
|
|
1717
|
+
}
|
|
1718
|
+
},
|
|
1719
|
+
"exp": {
|
|
1720
|
+
"required": false,
|
|
1721
|
+
"node": {
|
|
1722
|
+
"title": "NavigationBaseState.exp",
|
|
1723
|
+
"type": "never"
|
|
1724
|
+
}
|
|
1725
|
+
},
|
|
1726
|
+
"outcome": {
|
|
1727
|
+
"required": true,
|
|
1728
|
+
"node": {
|
|
1729
|
+
"type": "string",
|
|
1730
|
+
"title": "NavigationFlowEndState.outcome",
|
|
1731
|
+
"description": "A description of _how_ the flow ended.\nIf this is a flow started from another flow, the outcome determines the flow transition"
|
|
1732
|
+
}
|
|
1733
|
+
}
|
|
1734
|
+
},
|
|
1735
|
+
"additionalProperties": false,
|
|
1736
|
+
"title": "NavigationFlowEndState",
|
|
1737
|
+
"description": "An END state of the flow."
|
|
1738
|
+
},
|
|
1739
|
+
{
|
|
1740
|
+
"source": "core/types/src/index.ts",
|
|
1741
|
+
"name": "NavigationFlowFlowState",
|
|
1742
|
+
"type": "object",
|
|
1743
|
+
"properties": {
|
|
1744
|
+
"_comment": {
|
|
1745
|
+
"required": false,
|
|
1746
|
+
"node": {
|
|
1747
|
+
"type": "string",
|
|
1748
|
+
"title": "CommentBase._comment",
|
|
1749
|
+
"description": "Add comments that will not be processing, but are useful for code explanation"
|
|
1750
|
+
}
|
|
1751
|
+
},
|
|
1752
|
+
"state_type": {
|
|
1753
|
+
"required": true,
|
|
1754
|
+
"node": {
|
|
1755
|
+
"type": "string",
|
|
1756
|
+
"const": "FLOW",
|
|
1757
|
+
"title": "NavigationBaseState.state_type",
|
|
1758
|
+
"description": "A property to determine the type of state this is"
|
|
1759
|
+
}
|
|
1760
|
+
},
|
|
1761
|
+
"onStart": {
|
|
1762
|
+
"required": false,
|
|
1763
|
+
"node": {
|
|
1764
|
+
"type": "or",
|
|
1765
|
+
"or": [
|
|
1766
|
+
{
|
|
1767
|
+
"type": "ref",
|
|
1768
|
+
"ref": "Expression",
|
|
1769
|
+
"title": "NavigationBaseState.onStart"
|
|
1770
|
+
},
|
|
1771
|
+
{
|
|
1772
|
+
"source": "core/types/src/index.ts",
|
|
1773
|
+
"name": "ExpressionObject",
|
|
1774
|
+
"type": "object",
|
|
1775
|
+
"properties": {
|
|
1776
|
+
"exp": {
|
|
1777
|
+
"required": false,
|
|
1778
|
+
"node": {
|
|
1779
|
+
"type": "ref",
|
|
1780
|
+
"ref": "Expression",
|
|
1781
|
+
"title": "ExpressionObject.exp",
|
|
1782
|
+
"description": "The expression to run"
|
|
1783
|
+
}
|
|
1784
|
+
}
|
|
1785
|
+
},
|
|
1786
|
+
"additionalProperties": false,
|
|
1787
|
+
"title": "ExpressionObject",
|
|
1788
|
+
"description": "An object with an expression in it"
|
|
1789
|
+
}
|
|
1790
|
+
],
|
|
1791
|
+
"title": "NavigationBaseState.onStart",
|
|
1792
|
+
"description": "An optional expression to run when this view renders"
|
|
1793
|
+
}
|
|
1794
|
+
},
|
|
1795
|
+
"onEnd": {
|
|
1796
|
+
"required": false,
|
|
1797
|
+
"node": {
|
|
1798
|
+
"type": "or",
|
|
1799
|
+
"or": [
|
|
1800
|
+
{
|
|
1801
|
+
"type": "ref",
|
|
1802
|
+
"ref": "Expression",
|
|
1803
|
+
"title": "NavigationBaseState.onEnd"
|
|
1804
|
+
},
|
|
1805
|
+
{
|
|
1806
|
+
"source": "core/types/src/index.ts",
|
|
1807
|
+
"name": "ExpressionObject",
|
|
1808
|
+
"type": "object",
|
|
1809
|
+
"properties": {
|
|
1810
|
+
"exp": {
|
|
1811
|
+
"required": false,
|
|
1812
|
+
"node": {
|
|
1813
|
+
"type": "ref",
|
|
1814
|
+
"ref": "Expression",
|
|
1815
|
+
"title": "ExpressionObject.exp",
|
|
1816
|
+
"description": "The expression to run"
|
|
1817
|
+
}
|
|
1818
|
+
}
|
|
1819
|
+
},
|
|
1820
|
+
"additionalProperties": false,
|
|
1821
|
+
"title": "ExpressionObject",
|
|
1822
|
+
"description": "An object with an expression in it"
|
|
1823
|
+
}
|
|
1824
|
+
],
|
|
1825
|
+
"title": "NavigationBaseState.onEnd",
|
|
1826
|
+
"description": "An optional expression to run before view transition"
|
|
1827
|
+
}
|
|
1828
|
+
},
|
|
1829
|
+
"exp": {
|
|
1830
|
+
"required": false,
|
|
1831
|
+
"node": {
|
|
1832
|
+
"title": "NavigationBaseState.exp",
|
|
1833
|
+
"type": "never"
|
|
1834
|
+
}
|
|
1835
|
+
},
|
|
1836
|
+
"transitions": {
|
|
1837
|
+
"required": true,
|
|
1838
|
+
"node": {
|
|
1839
|
+
"source": "core/types/src/index.ts",
|
|
1840
|
+
"name": "NavigationFlowTransition",
|
|
1841
|
+
"type": "record",
|
|
1842
|
+
"keyType": {
|
|
1843
|
+
"type": "string"
|
|
1844
|
+
},
|
|
1845
|
+
"valueType": {
|
|
1846
|
+
"type": "string"
|
|
1847
|
+
},
|
|
1848
|
+
"title": "NavigationFlowTransitionableState.transitions",
|
|
1849
|
+
"description": "A mapping of transition-name to FlowState name"
|
|
1850
|
+
}
|
|
1851
|
+
},
|
|
1852
|
+
"ref": {
|
|
1853
|
+
"required": true,
|
|
1854
|
+
"node": {
|
|
1855
|
+
"type": "string",
|
|
1856
|
+
"title": "NavigationFlowFlowState.ref",
|
|
1857
|
+
"description": "A reference to a FLOW id state to run"
|
|
1858
|
+
}
|
|
1859
|
+
}
|
|
1860
|
+
},
|
|
1861
|
+
"additionalProperties": false,
|
|
1862
|
+
"title": "NavigationFlowFlowState"
|
|
1863
|
+
},
|
|
1864
|
+
{
|
|
1865
|
+
"source": "core/types/src/index.ts",
|
|
1866
|
+
"name": "NavigationFlowActionState",
|
|
1867
|
+
"type": "object",
|
|
1868
|
+
"properties": {
|
|
1869
|
+
"_comment": {
|
|
1870
|
+
"required": false,
|
|
1871
|
+
"node": {
|
|
1872
|
+
"type": "string",
|
|
1873
|
+
"title": "CommentBase._comment",
|
|
1874
|
+
"description": "Add comments that will not be processing, but are useful for code explanation"
|
|
1875
|
+
}
|
|
1876
|
+
},
|
|
1877
|
+
"state_type": {
|
|
1878
|
+
"required": true,
|
|
1879
|
+
"node": {
|
|
1880
|
+
"type": "string",
|
|
1881
|
+
"const": "ACTION",
|
|
1882
|
+
"title": "NavigationBaseState.state_type",
|
|
1883
|
+
"description": "A property to determine the type of state this is"
|
|
1884
|
+
}
|
|
1885
|
+
},
|
|
1886
|
+
"onStart": {
|
|
1887
|
+
"required": false,
|
|
1888
|
+
"node": {
|
|
1889
|
+
"type": "or",
|
|
1890
|
+
"or": [
|
|
1891
|
+
{
|
|
1892
|
+
"type": "ref",
|
|
1893
|
+
"ref": "Expression",
|
|
1894
|
+
"title": "NavigationBaseState.onStart"
|
|
1895
|
+
},
|
|
1896
|
+
{
|
|
1897
|
+
"source": "core/types/src/index.ts",
|
|
1898
|
+
"name": "ExpressionObject",
|
|
1899
|
+
"type": "object",
|
|
1900
|
+
"properties": {
|
|
1901
|
+
"exp": {
|
|
1902
|
+
"required": false,
|
|
1903
|
+
"node": {
|
|
1904
|
+
"type": "ref",
|
|
1905
|
+
"ref": "Expression",
|
|
1906
|
+
"title": "ExpressionObject.exp",
|
|
1907
|
+
"description": "The expression to run"
|
|
1908
|
+
}
|
|
1909
|
+
}
|
|
1910
|
+
},
|
|
1911
|
+
"additionalProperties": false,
|
|
1912
|
+
"title": "ExpressionObject",
|
|
1913
|
+
"description": "An object with an expression in it"
|
|
1914
|
+
}
|
|
1915
|
+
],
|
|
1916
|
+
"title": "NavigationBaseState.onStart",
|
|
1917
|
+
"description": "An optional expression to run when this view renders"
|
|
1918
|
+
}
|
|
1919
|
+
},
|
|
1920
|
+
"onEnd": {
|
|
1921
|
+
"required": false,
|
|
1922
|
+
"node": {
|
|
1923
|
+
"type": "or",
|
|
1924
|
+
"or": [
|
|
1925
|
+
{
|
|
1926
|
+
"type": "ref",
|
|
1927
|
+
"ref": "Expression",
|
|
1928
|
+
"title": "NavigationBaseState.onEnd"
|
|
1929
|
+
},
|
|
1930
|
+
{
|
|
1931
|
+
"source": "core/types/src/index.ts",
|
|
1932
|
+
"name": "ExpressionObject",
|
|
1933
|
+
"type": "object",
|
|
1934
|
+
"properties": {
|
|
1935
|
+
"exp": {
|
|
1936
|
+
"required": false,
|
|
1937
|
+
"node": {
|
|
1938
|
+
"type": "ref",
|
|
1939
|
+
"ref": "Expression",
|
|
1940
|
+
"title": "ExpressionObject.exp",
|
|
1941
|
+
"description": "The expression to run"
|
|
1942
|
+
}
|
|
1943
|
+
}
|
|
1944
|
+
},
|
|
1945
|
+
"additionalProperties": false,
|
|
1946
|
+
"title": "ExpressionObject",
|
|
1947
|
+
"description": "An object with an expression in it"
|
|
1948
|
+
}
|
|
1949
|
+
],
|
|
1950
|
+
"title": "NavigationBaseState.onEnd",
|
|
1951
|
+
"description": "An optional expression to run before view transition"
|
|
1952
|
+
}
|
|
1953
|
+
},
|
|
1954
|
+
"exp": {
|
|
1955
|
+
"required": true,
|
|
1956
|
+
"node": {
|
|
1957
|
+
"type": "ref",
|
|
1958
|
+
"ref": "Expression",
|
|
1959
|
+
"title": "NavigationFlowActionState.exp",
|
|
1960
|
+
"description": "An expression to execute.\nThe return value determines the transition to take"
|
|
1961
|
+
}
|
|
1962
|
+
},
|
|
1963
|
+
"transitions": {
|
|
1964
|
+
"required": true,
|
|
1965
|
+
"node": {
|
|
1966
|
+
"source": "core/types/src/index.ts",
|
|
1967
|
+
"name": "NavigationFlowTransition",
|
|
1968
|
+
"type": "record",
|
|
1969
|
+
"keyType": {
|
|
1970
|
+
"type": "string"
|
|
1971
|
+
},
|
|
1972
|
+
"valueType": {
|
|
1973
|
+
"type": "string"
|
|
1974
|
+
},
|
|
1975
|
+
"title": "NavigationFlowTransitionableState.transitions",
|
|
1976
|
+
"description": "A mapping of transition-name to FlowState name"
|
|
1977
|
+
}
|
|
1978
|
+
}
|
|
1979
|
+
},
|
|
1980
|
+
"additionalProperties": false,
|
|
1981
|
+
"title": "NavigationFlowActionState",
|
|
1982
|
+
"description": "Action states execute an expression to determine the next state to transition to"
|
|
1983
|
+
},
|
|
1984
|
+
{
|
|
1985
|
+
"source": "core/types/src/index.ts",
|
|
1986
|
+
"name": "NavigationFlowExternalState",
|
|
1987
|
+
"type": "object",
|
|
1988
|
+
"properties": {
|
|
1989
|
+
"_comment": {
|
|
1990
|
+
"required": false,
|
|
1991
|
+
"node": {
|
|
1992
|
+
"type": "string",
|
|
1993
|
+
"title": "CommentBase._comment",
|
|
1994
|
+
"description": "Add comments that will not be processing, but are useful for code explanation"
|
|
1995
|
+
}
|
|
1996
|
+
},
|
|
1997
|
+
"state_type": {
|
|
1998
|
+
"required": true,
|
|
1999
|
+
"node": {
|
|
2000
|
+
"type": "string",
|
|
2001
|
+
"const": "EXTERNAL",
|
|
2002
|
+
"title": "NavigationBaseState.state_type",
|
|
2003
|
+
"description": "A property to determine the type of state this is"
|
|
2004
|
+
}
|
|
2005
|
+
},
|
|
2006
|
+
"onStart": {
|
|
2007
|
+
"required": false,
|
|
2008
|
+
"node": {
|
|
2009
|
+
"type": "or",
|
|
2010
|
+
"or": [
|
|
2011
|
+
{
|
|
2012
|
+
"type": "ref",
|
|
2013
|
+
"ref": "Expression",
|
|
2014
|
+
"title": "NavigationBaseState.onStart"
|
|
2015
|
+
},
|
|
2016
|
+
{
|
|
2017
|
+
"source": "core/types/src/index.ts",
|
|
2018
|
+
"name": "ExpressionObject",
|
|
2019
|
+
"type": "object",
|
|
2020
|
+
"properties": {
|
|
2021
|
+
"exp": {
|
|
2022
|
+
"required": false,
|
|
2023
|
+
"node": {
|
|
2024
|
+
"type": "ref",
|
|
2025
|
+
"ref": "Expression",
|
|
2026
|
+
"title": "ExpressionObject.exp",
|
|
2027
|
+
"description": "The expression to run"
|
|
2028
|
+
}
|
|
2029
|
+
}
|
|
2030
|
+
},
|
|
2031
|
+
"additionalProperties": false,
|
|
2032
|
+
"title": "ExpressionObject",
|
|
2033
|
+
"description": "An object with an expression in it"
|
|
2034
|
+
}
|
|
2035
|
+
],
|
|
2036
|
+
"title": "NavigationBaseState.onStart",
|
|
2037
|
+
"description": "An optional expression to run when this view renders"
|
|
2038
|
+
}
|
|
2039
|
+
},
|
|
2040
|
+
"onEnd": {
|
|
2041
|
+
"required": false,
|
|
2042
|
+
"node": {
|
|
2043
|
+
"type": "or",
|
|
2044
|
+
"or": [
|
|
2045
|
+
{
|
|
2046
|
+
"type": "ref",
|
|
2047
|
+
"ref": "Expression",
|
|
2048
|
+
"title": "NavigationBaseState.onEnd"
|
|
2049
|
+
},
|
|
2050
|
+
{
|
|
2051
|
+
"source": "core/types/src/index.ts",
|
|
2052
|
+
"name": "ExpressionObject",
|
|
2053
|
+
"type": "object",
|
|
2054
|
+
"properties": {
|
|
2055
|
+
"exp": {
|
|
2056
|
+
"required": false,
|
|
2057
|
+
"node": {
|
|
2058
|
+
"type": "ref",
|
|
2059
|
+
"ref": "Expression",
|
|
2060
|
+
"title": "ExpressionObject.exp",
|
|
2061
|
+
"description": "The expression to run"
|
|
2062
|
+
}
|
|
2063
|
+
}
|
|
2064
|
+
},
|
|
2065
|
+
"additionalProperties": false,
|
|
2066
|
+
"title": "ExpressionObject",
|
|
2067
|
+
"description": "An object with an expression in it"
|
|
2068
|
+
}
|
|
2069
|
+
],
|
|
2070
|
+
"title": "NavigationBaseState.onEnd",
|
|
2071
|
+
"description": "An optional expression to run before view transition"
|
|
2072
|
+
}
|
|
2073
|
+
},
|
|
2074
|
+
"exp": {
|
|
2075
|
+
"required": false,
|
|
2076
|
+
"node": {
|
|
2077
|
+
"title": "NavigationBaseState.exp",
|
|
2078
|
+
"type": "never"
|
|
2079
|
+
}
|
|
2080
|
+
},
|
|
2081
|
+
"transitions": {
|
|
2082
|
+
"required": true,
|
|
2083
|
+
"node": {
|
|
2084
|
+
"source": "core/types/src/index.ts",
|
|
2085
|
+
"name": "NavigationFlowTransition",
|
|
2086
|
+
"type": "record",
|
|
2087
|
+
"keyType": {
|
|
2088
|
+
"type": "string"
|
|
2089
|
+
},
|
|
2090
|
+
"valueType": {
|
|
2091
|
+
"type": "string"
|
|
2092
|
+
},
|
|
2093
|
+
"title": "NavigationFlowTransitionableState.transitions",
|
|
2094
|
+
"description": "A mapping of transition-name to FlowState name"
|
|
2095
|
+
}
|
|
2096
|
+
},
|
|
2097
|
+
"ref": {
|
|
2098
|
+
"required": true,
|
|
2099
|
+
"node": {
|
|
2100
|
+
"type": "string",
|
|
2101
|
+
"title": "NavigationFlowExternalState.ref",
|
|
2102
|
+
"description": "A reference for this external state"
|
|
2103
|
+
}
|
|
2104
|
+
}
|
|
2105
|
+
},
|
|
2106
|
+
"additionalProperties": false,
|
|
2107
|
+
"title": "NavigationFlowExternalState",
|
|
2108
|
+
"description": "External Flow states represent states in the FSM that can't be resolved internally in Player.\nThe flow will wait for the embedded application to manage moving to the next state via a transition"
|
|
2109
|
+
}
|
|
2110
|
+
],
|
|
2111
|
+
"title": "NavigationFlowState"
|
|
2112
|
+
}
|
|
2113
|
+
]
|
|
2114
|
+
},
|
|
2115
|
+
"title": "NavigationFlow",
|
|
2116
|
+
"description": "A state machine in the navigation"
|
|
2117
|
+
}
|
|
2118
|
+
]
|
|
2119
|
+
}
|
|
2120
|
+
}
|
|
2121
|
+
],
|
|
2122
|
+
"title": "Flow.navigation",
|
|
2123
|
+
"description": "A state machine to drive a user through the experience"
|
|
2124
|
+
}
|
|
2125
|
+
}
|
|
2126
|
+
},
|
|
2127
|
+
"additionalProperties": {
|
|
2128
|
+
"type": "unknown"
|
|
2129
|
+
},
|
|
2130
|
+
"title": "Flow",
|
|
2131
|
+
"description": "The JSON payload for running Player",
|
|
2132
|
+
"genericTokens": [
|
|
2133
|
+
{
|
|
2134
|
+
"symbol": "T",
|
|
2135
|
+
"constraints": {
|
|
2136
|
+
"type": "ref",
|
|
2137
|
+
"ref": "Asset"
|
|
2138
|
+
},
|
|
2139
|
+
"default": {
|
|
2140
|
+
"type": "ref",
|
|
2141
|
+
"ref": "Asset"
|
|
2142
|
+
}
|
|
2143
|
+
}
|
|
2144
|
+
]
|
|
2145
|
+
}
|