@lblod/ember-rdfa-editor-lblod-plugins 33.1.0 → 33.2.0-dev.30fd14f2427b10213d5acbd8ef1a0f98dc9f26e5
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/.changeset/brave-ligers-march.md +5 -0
- package/CHANGELOG.md +8 -0
- package/addon/components/besluit-type-plugin/toolbar-dropdown.gts +18 -4
- package/addon/plugins/besluit-type-plugin/utils/besluit-type-instances.ts +18 -1
- package/addon/plugins/besluit-type-plugin/utils/set-besluit-type.ts +30 -3
- package/addon/plugins/roadsign-regulation-plugin/actions/insert-measure.ts +69 -18
- package/addon/plugins/roadsign-regulation-plugin/schemas/mobility-measure-design.ts +20 -0
- package/addon/plugins/roadsign-regulation-plugin/schemas/traffic-signal.ts +18 -0
- package/addon/plugins/roadsign-regulation-plugin/schemas/variable-instance.ts +54 -0
- package/addon/plugins/roadsign-regulation-plugin/schemas/variable.ts +6 -6
- package/app/styles/structure-plugin.scss +1 -1
- package/declarations/addon/components/besluit-type-plugin/toolbar-dropdown.d.ts +2 -1
- package/declarations/addon/plugins/besluit-type-plugin/utils/besluit-type-instances.d.ts +1 -0
- package/declarations/addon/plugins/besluit-type-plugin/utils/set-besluit-type.d.ts +1 -1
- package/declarations/addon/plugins/roadsign-regulation-plugin/actions/insert-measure.d.ts +10 -5
- package/declarations/addon/plugins/roadsign-regulation-plugin/schemas/mobility-measure-design.d.ts +279 -0
- package/declarations/addon/plugins/roadsign-regulation-plugin/schemas/traffic-signal.d.ts +90 -0
- package/declarations/addon/plugins/roadsign-regulation-plugin/schemas/variable-instance.d.ts +230 -0
- package/declarations/addon/plugins/roadsign-regulation-plugin/schemas/variable.d.ts +120 -0
- package/package.json +1 -1
package/CHANGELOG.md
CHANGED
|
@@ -1,5 +1,13 @@
|
|
|
1
1
|
# @lblod/ember-rdfa-editor-lblod-plugins
|
|
2
2
|
|
|
3
|
+
## 33.2.0
|
|
4
|
+
|
|
5
|
+
### Minor Changes
|
|
6
|
+
|
|
7
|
+
- [#609](https://github.com/lblod/ember-rdfa-editor-lblod-plugins/pull/609) [`600774b`](https://github.com/lblod/ember-rdfa-editor-lblod-plugins/commit/600774bf0e678850daa2ad1c848241403eb48b6f) Thanks [@elpoelma](https://github.com/elpoelma)! - roadsign-regulation-plugin: add support for inserting mobility-measures based on VKS measure-designs
|
|
8
|
+
|
|
9
|
+
- [#612](https://github.com/lblod/ember-rdfa-editor-lblod-plugins/pull/612) [`7aa62a0`](https://github.com/lblod/ember-rdfa-editor-lblod-plugins/commit/7aa62a00aa3706fcdd37944fad5613bd8a94bc57) Thanks [@piemonkey](https://github.com/piemonkey)! - Only display structure borders when within the editor
|
|
10
|
+
|
|
3
11
|
## 33.1.0
|
|
4
12
|
|
|
5
13
|
### Minor Changes
|
|
@@ -20,14 +20,17 @@ import { getCurrentBesluitRange } from '@lblod/ember-rdfa-editor-lblod-plugins/u
|
|
|
20
20
|
import {
|
|
21
21
|
BesluitTypeInstance,
|
|
22
22
|
checkBesluitTypeInstance,
|
|
23
|
+
checkForDraftBesluitType,
|
|
23
24
|
mostSpecificBesluitType,
|
|
24
25
|
} from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/besluit-type-plugin/utils/besluit-type-instances';
|
|
25
26
|
import BesluitTypeForm from '@lblod/ember-rdfa-editor-lblod-plugins/components/besluit-type-plugin/besluit-type-form';
|
|
26
27
|
import { setBesluitType } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/besluit-type-plugin/utils/set-besluit-type';
|
|
28
|
+
import AuButton from '@appuniversum/ember-appuniversum/components/au-button';
|
|
27
29
|
|
|
28
30
|
type Args = {
|
|
29
31
|
controller: SayController;
|
|
30
32
|
options: BesluitTypePluginOptions;
|
|
33
|
+
allowForDraftTypes?: boolean;
|
|
31
34
|
};
|
|
32
35
|
|
|
33
36
|
export default class EditorPluginsToolbarDropdownComponent extends Component<Args> {
|
|
@@ -67,7 +70,9 @@ export default class EditorPluginsToolbarDropdownComponent extends Component<Arg
|
|
|
67
70
|
|
|
68
71
|
setType = (type: BesluitTypeInstance) => {
|
|
69
72
|
this.selectedTypeInstance = type;
|
|
70
|
-
this.
|
|
73
|
+
if (!this.args.allowForDraftTypes) {
|
|
74
|
+
this.insertIfValid();
|
|
75
|
+
}
|
|
71
76
|
};
|
|
72
77
|
|
|
73
78
|
updateBesluitTypes = () => {
|
|
@@ -84,13 +89,16 @@ export default class EditorPluginsToolbarDropdownComponent extends Component<Arg
|
|
|
84
89
|
);
|
|
85
90
|
if (typeInstance) {
|
|
86
91
|
this.selectedTypeInstance = typeInstance;
|
|
87
|
-
|
|
92
|
+
const isDraftType = checkForDraftBesluitType(
|
|
93
|
+
this.controller.mainEditorState,
|
|
94
|
+
);
|
|
95
|
+
this.cardExpanded = !this.args.allowForDraftTypes && isDraftType;
|
|
88
96
|
} else {
|
|
89
97
|
this.cardExpanded = true;
|
|
90
98
|
}
|
|
91
99
|
};
|
|
92
100
|
|
|
93
|
-
insertIfValid() {
|
|
101
|
+
insertIfValid = () => {
|
|
94
102
|
this.controller.doCommand((state, dispatch) => {
|
|
95
103
|
if (!this.selectedTypeInstance || !dispatch) {
|
|
96
104
|
return false;
|
|
@@ -98,6 +106,7 @@ export default class EditorPluginsToolbarDropdownComponent extends Component<Arg
|
|
|
98
106
|
const { result, transaction } = setBesluitType(
|
|
99
107
|
state,
|
|
100
108
|
this.selectedTypeInstance,
|
|
109
|
+
this.args.allowForDraftTypes,
|
|
101
110
|
);
|
|
102
111
|
if (result.every((ok) => ok)) {
|
|
103
112
|
dispatch(transaction);
|
|
@@ -105,7 +114,7 @@ export default class EditorPluginsToolbarDropdownComponent extends Component<Arg
|
|
|
105
114
|
}
|
|
106
115
|
return false;
|
|
107
116
|
});
|
|
108
|
-
}
|
|
117
|
+
};
|
|
109
118
|
|
|
110
119
|
<template>
|
|
111
120
|
<div
|
|
@@ -182,6 +191,11 @@ export default class EditorPluginsToolbarDropdownComponent extends Component<Arg
|
|
|
182
191
|
@selectedType={{this.selectedTypeInstance}}
|
|
183
192
|
@setType={{this.setType}}
|
|
184
193
|
/>
|
|
194
|
+
{{#if @allowForDraftTypes}}
|
|
195
|
+
<AuButton {{on 'click' this.insertIfValid}}>
|
|
196
|
+
{{t 'common.insert'}}
|
|
197
|
+
</AuButton>
|
|
198
|
+
{{/if}}
|
|
185
199
|
{{/if}}
|
|
186
200
|
</Modal.Body>
|
|
187
201
|
</AuModal>
|
|
@@ -1,7 +1,10 @@
|
|
|
1
1
|
import { type EditorState } from '@lblod/ember-rdfa-editor';
|
|
2
2
|
import { getOutgoingTripleList } from '@lblod/ember-rdfa-editor-lblod-plugins/utils/namespace';
|
|
3
3
|
import { getCurrentBesluitRange } from '@lblod/ember-rdfa-editor-lblod-plugins/utils/decision-utils';
|
|
4
|
-
import {
|
|
4
|
+
import {
|
|
5
|
+
EXT,
|
|
6
|
+
RDF,
|
|
7
|
+
} from '@lblod/ember-rdfa-editor-lblod-plugins/utils/constants';
|
|
5
8
|
import { type BesluitType } from './fetchBesluitTypes';
|
|
6
9
|
import { type NamedNodeTriple } from '@lblod/ember-rdfa-editor/core/rdfa-processor';
|
|
7
10
|
|
|
@@ -27,6 +30,20 @@ export function extractBesluitTypeUris(editorState: EditorState): string[] {
|
|
|
27
30
|
.map((type: NamedNodeTriple) => type?.object.value);
|
|
28
31
|
}
|
|
29
32
|
|
|
33
|
+
export function checkForDraftBesluitType(editorState: EditorState): boolean {
|
|
34
|
+
const besluitRange = getCurrentBesluitRange(editorState);
|
|
35
|
+
if (!besluitRange) {
|
|
36
|
+
return false;
|
|
37
|
+
}
|
|
38
|
+
return getOutgoingTripleList(
|
|
39
|
+
besluitRange.node.attrs,
|
|
40
|
+
EXT('isDraftDecisionType'),
|
|
41
|
+
).some(
|
|
42
|
+
(draftTypeTriple: NamedNodeTriple) =>
|
|
43
|
+
draftTypeTriple?.object.value === 'true',
|
|
44
|
+
);
|
|
45
|
+
}
|
|
46
|
+
|
|
30
47
|
/**
|
|
31
48
|
* Finds a decision type in the document and checks that it represents a valid decision type
|
|
32
49
|
* according to the list of types passed in.
|
|
@@ -10,21 +10,26 @@ import {
|
|
|
10
10
|
import { sayDataFactory } from '@lblod/ember-rdfa-editor/core/say-data-factory';
|
|
11
11
|
import { getCurrentBesluitURI } from '@lblod/ember-rdfa-editor-lblod-plugins/utils/decision-utils';
|
|
12
12
|
import {
|
|
13
|
+
checkForDraftBesluitType,
|
|
13
14
|
extractBesluitTypeUris,
|
|
14
15
|
isValidTypeChoice,
|
|
15
16
|
mostSpecificBesluitType,
|
|
16
17
|
type BesluitTypeInstance,
|
|
17
18
|
} from './besluit-type-instances';
|
|
18
|
-
import {
|
|
19
|
+
import {
|
|
20
|
+
EXT,
|
|
21
|
+
RDF,
|
|
22
|
+
} from '@lblod/ember-rdfa-editor-lblod-plugins/utils/constants';
|
|
19
23
|
|
|
20
24
|
export function setBesluitType(
|
|
21
25
|
initialState: EditorState,
|
|
22
26
|
typeInstance: BesluitTypeInstance,
|
|
27
|
+
isDraftDecisionType?: boolean,
|
|
23
28
|
): TransactionCombinatorResult<boolean> {
|
|
24
29
|
const transaction = initialState.tr;
|
|
25
|
-
|
|
26
30
|
const resource = getCurrentBesluitURI(initialState);
|
|
27
|
-
|
|
31
|
+
const isValidType = isValidTypeChoice(typeInstance);
|
|
32
|
+
if (!resource || (!isValidType && !isDraftDecisionType)) {
|
|
28
33
|
return {
|
|
29
34
|
result: [false],
|
|
30
35
|
initialState,
|
|
@@ -42,6 +47,17 @@ export function setBesluitType(
|
|
|
42
47
|
},
|
|
43
48
|
});
|
|
44
49
|
});
|
|
50
|
+
if (checkForDraftBesluitType(initialState)) {
|
|
51
|
+
monads.push(
|
|
52
|
+
removePropertyFromNode({
|
|
53
|
+
resource,
|
|
54
|
+
property: {
|
|
55
|
+
predicate: EXT('isDraftDecisionType').full,
|
|
56
|
+
object: sayDataFactory.literal('true'),
|
|
57
|
+
},
|
|
58
|
+
}),
|
|
59
|
+
);
|
|
60
|
+
}
|
|
45
61
|
monads.push(
|
|
46
62
|
addPropertyToNode({
|
|
47
63
|
resource,
|
|
@@ -53,5 +69,16 @@ export function setBesluitType(
|
|
|
53
69
|
},
|
|
54
70
|
}),
|
|
55
71
|
);
|
|
72
|
+
if (!isValidType && isDraftDecisionType) {
|
|
73
|
+
monads.push(
|
|
74
|
+
addPropertyToNode({
|
|
75
|
+
resource,
|
|
76
|
+
property: {
|
|
77
|
+
predicate: EXT('isDraftDecisionType').full,
|
|
78
|
+
object: sayDataFactory.literal('true'),
|
|
79
|
+
},
|
|
80
|
+
}),
|
|
81
|
+
);
|
|
82
|
+
}
|
|
56
83
|
return transactionCombinator<boolean>(initialState)(monads);
|
|
57
84
|
}
|
|
@@ -38,30 +38,50 @@ import { createNumberVariable } from '../../variable-plugin/actions/create-numbe
|
|
|
38
38
|
import { createDateVariable } from '../../variable-plugin/actions/create-date-variable';
|
|
39
39
|
import { createCodelistVariable } from '../../variable-plugin/actions/create-codelist-variable';
|
|
40
40
|
import { createClassicLocationVariable } from '../../variable-plugin/actions/create-classic-location-variable';
|
|
41
|
+
import { isTrafficSignal, TrafficSignal } from '../schemas/traffic-signal';
|
|
42
|
+
import { MobilityMeasureDesign } from '../schemas/mobility-measure-design';
|
|
43
|
+
import {
|
|
44
|
+
isVariableInstance,
|
|
45
|
+
VariableInstance,
|
|
46
|
+
} from '../schemas/variable-instance';
|
|
41
47
|
|
|
42
|
-
|
|
43
|
-
measureConcept: MobilityMeasureConcept;
|
|
48
|
+
type InsertMeasureArgs = {
|
|
44
49
|
zonality: ZonalOrNot;
|
|
45
50
|
temporal: boolean;
|
|
46
|
-
variables: Record<
|
|
51
|
+
variables: Record<
|
|
52
|
+
string,
|
|
53
|
+
Exclude<Variable, { type: 'instruction' }> | VariableInstance
|
|
54
|
+
>;
|
|
47
55
|
templateString: string;
|
|
48
56
|
decisionUri: string;
|
|
49
57
|
articleUriGenerator?: () => string;
|
|
50
|
-
}
|
|
58
|
+
} & (
|
|
59
|
+
| {
|
|
60
|
+
measureConcept: MobilityMeasureConcept;
|
|
61
|
+
}
|
|
62
|
+
| {
|
|
63
|
+
measureDesign: MobilityMeasureDesign;
|
|
64
|
+
}
|
|
65
|
+
);
|
|
51
66
|
|
|
52
67
|
export default function insertMeasure({
|
|
53
|
-
measureConcept,
|
|
54
68
|
zonality,
|
|
55
69
|
temporal,
|
|
56
70
|
variables,
|
|
57
71
|
templateString,
|
|
58
72
|
articleUriGenerator,
|
|
59
73
|
decisionUri,
|
|
74
|
+
...args
|
|
60
75
|
}: InsertMeasureArgs): TransactionMonad<boolean> {
|
|
61
76
|
return function (state: EditorState) {
|
|
77
|
+
const measureConcept =
|
|
78
|
+
'measureConcept' in args
|
|
79
|
+
? args.measureConcept
|
|
80
|
+
: args.measureDesign.measureConcept;
|
|
81
|
+
const measureDesign = 'measureDesign' in args && args.measureDesign;
|
|
62
82
|
const { schema } = state;
|
|
63
83
|
const signNodes = measureConcept.trafficSignalConcepts.map((signConcept) =>
|
|
64
|
-
|
|
84
|
+
constructSignalNode(signConcept, schema, zonality),
|
|
65
85
|
);
|
|
66
86
|
let signSection: PNode[] = [];
|
|
67
87
|
if (signNodes.length) {
|
|
@@ -117,6 +137,14 @@ export default function insertMeasure({
|
|
|
117
137
|
predicate: DCT('description').full,
|
|
118
138
|
object: sayDataFactory.contentLiteral('nl-BE'),
|
|
119
139
|
},
|
|
140
|
+
...(measureDesign
|
|
141
|
+
? [
|
|
142
|
+
{
|
|
143
|
+
predicate: MOBILITEIT('isGebaseerdOpMaatregelOntwerp'),
|
|
144
|
+
object: sayDataFactory.namedNode(measureDesign.uri),
|
|
145
|
+
},
|
|
146
|
+
]
|
|
147
|
+
: []),
|
|
120
148
|
// TODO there are some properties that are missing from the measure that we should define if we can:
|
|
121
149
|
// locn:address, mobiliteit:contactorganisatie, mobiliteit:doelgroep, adms:identifier,
|
|
122
150
|
// mobiliteit:periode, mobiliteit:plaatsbepaling, schema:eventSchedule, mobiliteit:type,
|
|
@@ -172,7 +200,10 @@ export default function insertMeasure({
|
|
|
172
200
|
|
|
173
201
|
function constructMeasureBody(
|
|
174
202
|
templateString: string,
|
|
175
|
-
variables: Record<
|
|
203
|
+
variables: Record<
|
|
204
|
+
string,
|
|
205
|
+
Exclude<Variable, { type: 'instruction' }> | VariableInstance
|
|
206
|
+
>,
|
|
176
207
|
schema: Schema,
|
|
177
208
|
) {
|
|
178
209
|
const parts = templateString.split(/(\$\{[^{}$]+\})/);
|
|
@@ -216,13 +247,18 @@ function determineSignLabel(signConcept: TrafficSignalConcept) {
|
|
|
216
247
|
}
|
|
217
248
|
}
|
|
218
249
|
|
|
219
|
-
function
|
|
220
|
-
|
|
250
|
+
function constructSignalNode(
|
|
251
|
+
signalOrSignalConcept: TrafficSignal | TrafficSignalConcept,
|
|
221
252
|
schema: Schema,
|
|
222
253
|
zonality?: ZonalOrNot,
|
|
223
254
|
) {
|
|
224
|
-
const
|
|
225
|
-
|
|
255
|
+
const signalConcept = isTrafficSignal(signalOrSignalConcept)
|
|
256
|
+
? signalOrSignalConcept.trafficSignalConcept
|
|
257
|
+
: signalOrSignalConcept;
|
|
258
|
+
const signalUri = isTrafficSignal(signalOrSignalConcept)
|
|
259
|
+
? signalOrSignalConcept.uri
|
|
260
|
+
: `http://data.lblod.info/verkeerstekens/${uuid()}`;
|
|
261
|
+
const prefix = determineSignLabel(signalConcept);
|
|
226
262
|
const zonalityText =
|
|
227
263
|
!zonality || zonality !== ZONALITY_OPTIONS.ZONAL
|
|
228
264
|
? ''
|
|
@@ -232,7 +268,7 @@ function constructSignNode(
|
|
|
232
268
|
const node = schema.nodes.inline_rdfa.create(
|
|
233
269
|
{
|
|
234
270
|
rdfaNodeType: 'resource',
|
|
235
|
-
subject:
|
|
271
|
+
subject: signalUri,
|
|
236
272
|
__rdfaId: uuid(),
|
|
237
273
|
properties: [
|
|
238
274
|
{
|
|
@@ -242,33 +278,48 @@ function constructSignNode(
|
|
|
242
278
|
{
|
|
243
279
|
predicate: RDF('type').full,
|
|
244
280
|
object: sayDataFactory.namedNode(
|
|
245
|
-
TRAFFIC_SIGNAL_TYPE_MAPPING[
|
|
281
|
+
TRAFFIC_SIGNAL_TYPE_MAPPING[signalConcept.type],
|
|
246
282
|
),
|
|
247
283
|
},
|
|
248
284
|
{
|
|
249
285
|
predicate: PROV('wasDerivedFrom').full,
|
|
250
|
-
object: sayDataFactory.namedNode(
|
|
286
|
+
object: sayDataFactory.namedNode(signalOrSignalConcept.uri),
|
|
251
287
|
},
|
|
252
288
|
// TODO should include extra Verkeersteken properties? mobiliteit:heeftOnderbord,
|
|
253
289
|
// mobiliteit:isBeginZone, mobiliteit:isEindeZone?
|
|
254
290
|
],
|
|
255
291
|
},
|
|
256
292
|
schema.text(
|
|
257
|
-
`${prefix} ${
|
|
293
|
+
`${prefix} ${signalConcept.regulatoryNotation || signalConcept.code}${zonalityText}`,
|
|
258
294
|
),
|
|
259
295
|
);
|
|
260
296
|
return node;
|
|
261
297
|
}
|
|
262
298
|
|
|
263
299
|
function constructVariableNode(
|
|
264
|
-
|
|
300
|
+
variableOrVariableInstance:
|
|
301
|
+
| Exclude<Variable, { type: 'instruction' }>
|
|
302
|
+
| VariableInstance,
|
|
265
303
|
schema: Schema,
|
|
266
304
|
) {
|
|
267
|
-
const
|
|
305
|
+
const variable = isVariableInstance(variableOrVariableInstance)
|
|
306
|
+
? variableOrVariableInstance.variable
|
|
307
|
+
: variableOrVariableInstance;
|
|
308
|
+
const variableInstance = isVariableInstance(variableOrVariableInstance)
|
|
309
|
+
? variableOrVariableInstance
|
|
310
|
+
: {
|
|
311
|
+
uri: generateVariableInstanceUri(),
|
|
312
|
+
value: undefined,
|
|
313
|
+
};
|
|
314
|
+
const valueStr =
|
|
315
|
+
variableInstance.value instanceof Date
|
|
316
|
+
? variableInstance.value.toISOString()
|
|
317
|
+
: variableInstance.value?.toString();
|
|
268
318
|
const args = {
|
|
269
319
|
schema,
|
|
270
320
|
variable: variable.uri,
|
|
271
|
-
variableInstance,
|
|
321
|
+
variableInstance: variableInstance.uri,
|
|
322
|
+
value: valueStr,
|
|
272
323
|
label: variable.label,
|
|
273
324
|
};
|
|
274
325
|
switch (variable.type) {
|
|
@@ -0,0 +1,20 @@
|
|
|
1
|
+
import { z } from 'zod';
|
|
2
|
+
import { TrafficSignalSchema } from './traffic-signal';
|
|
3
|
+
import {
|
|
4
|
+
type MobilityMeasureConcept,
|
|
5
|
+
MobilityMeasureConceptSchema,
|
|
6
|
+
} from './mobility-measure-concept';
|
|
7
|
+
|
|
8
|
+
export const MobilityMeasureDesignSchema = z.object({
|
|
9
|
+
uri: z.string(),
|
|
10
|
+
trafficSignals: z.array(TrafficSignalSchema),
|
|
11
|
+
measureConcept: MobilityMeasureConceptSchema,
|
|
12
|
+
});
|
|
13
|
+
|
|
14
|
+
export type MobilityMeasureDesign = z.infer<typeof MobilityMeasureDesignSchema>;
|
|
15
|
+
|
|
16
|
+
export function isMobilityMeasureDesign(
|
|
17
|
+
conceptOrDesign: MobilityMeasureConcept | MobilityMeasureDesign,
|
|
18
|
+
): conceptOrDesign is MobilityMeasureDesign {
|
|
19
|
+
return 'measureConcept' in conceptOrDesign;
|
|
20
|
+
}
|
|
@@ -0,0 +1,18 @@
|
|
|
1
|
+
import { z } from 'zod';
|
|
2
|
+
import {
|
|
3
|
+
TrafficSignalConcept,
|
|
4
|
+
TrafficSignalConceptSchema,
|
|
5
|
+
} from './traffic-signal-concept';
|
|
6
|
+
|
|
7
|
+
export const TrafficSignalSchema = z.object({
|
|
8
|
+
uri: z.string(),
|
|
9
|
+
trafficSignalConcept: TrafficSignalConceptSchema,
|
|
10
|
+
});
|
|
11
|
+
|
|
12
|
+
export type TrafficSignal = z.infer<typeof TrafficSignalSchema>;
|
|
13
|
+
|
|
14
|
+
export function isTrafficSignal(
|
|
15
|
+
signalOrSignalConcept: TrafficSignal | TrafficSignalConcept,
|
|
16
|
+
): signalOrSignalConcept is TrafficSignal {
|
|
17
|
+
return 'trafficSignalConcept' in signalOrSignalConcept;
|
|
18
|
+
}
|
|
@@ -0,0 +1,54 @@
|
|
|
1
|
+
import { z } from 'zod';
|
|
2
|
+
import {
|
|
3
|
+
CodelistVariableSchema,
|
|
4
|
+
DateVariableSchema,
|
|
5
|
+
LocationVariableSchema,
|
|
6
|
+
NumberVariableSchema,
|
|
7
|
+
TextVariableSchema,
|
|
8
|
+
Variable,
|
|
9
|
+
} from './variable';
|
|
10
|
+
|
|
11
|
+
const BaseVariableInstanceSchema = z.object({
|
|
12
|
+
uri: z.string(),
|
|
13
|
+
});
|
|
14
|
+
|
|
15
|
+
const TextVariableInstanceSchema = BaseVariableInstanceSchema.extend({
|
|
16
|
+
value: z.string().optional(),
|
|
17
|
+
variable: TextVariableSchema,
|
|
18
|
+
});
|
|
19
|
+
|
|
20
|
+
const NumberVariableInstanceSchema = BaseVariableInstanceSchema.extend({
|
|
21
|
+
value: z.number({ coerce: true }).optional(),
|
|
22
|
+
variable: NumberVariableSchema,
|
|
23
|
+
});
|
|
24
|
+
|
|
25
|
+
const DateVariableInstanceSchema = BaseVariableInstanceSchema.extend({
|
|
26
|
+
value: z.date({ coerce: true }).optional(),
|
|
27
|
+
variable: DateVariableSchema,
|
|
28
|
+
});
|
|
29
|
+
|
|
30
|
+
const LocationVariableInstanceSchema = BaseVariableInstanceSchema.extend({
|
|
31
|
+
value: z.string().optional(),
|
|
32
|
+
variable: LocationVariableSchema,
|
|
33
|
+
});
|
|
34
|
+
|
|
35
|
+
const CodelistVariableInstanceSchema = BaseVariableInstanceSchema.extend({
|
|
36
|
+
value: z.string().optional(),
|
|
37
|
+
variable: CodelistVariableSchema,
|
|
38
|
+
});
|
|
39
|
+
|
|
40
|
+
export const VariableInstanceSchema = z.union([
|
|
41
|
+
TextVariableInstanceSchema,
|
|
42
|
+
NumberVariableInstanceSchema,
|
|
43
|
+
DateVariableInstanceSchema,
|
|
44
|
+
LocationVariableInstanceSchema,
|
|
45
|
+
CodelistVariableInstanceSchema,
|
|
46
|
+
]);
|
|
47
|
+
|
|
48
|
+
export type VariableInstance = z.infer<typeof VariableInstanceSchema>;
|
|
49
|
+
|
|
50
|
+
export function isVariableInstance(
|
|
51
|
+
variableOrVariableInstance: Variable | VariableInstance,
|
|
52
|
+
): variableOrVariableInstance is VariableInstance {
|
|
53
|
+
return 'variable' in variableOrVariableInstance;
|
|
54
|
+
}
|
|
@@ -5,33 +5,33 @@ const BaseVariableSchema = z.object({
|
|
|
5
5
|
label: z.string(),
|
|
6
6
|
source: z.string().optional(),
|
|
7
7
|
});
|
|
8
|
-
const TextVariableSchema = BaseVariableSchema.extend({
|
|
8
|
+
export const TextVariableSchema = BaseVariableSchema.extend({
|
|
9
9
|
type: z.literal('text'),
|
|
10
10
|
defaultValue: z.string().optional(),
|
|
11
11
|
});
|
|
12
12
|
|
|
13
|
-
const NumberVariableSchema = BaseVariableSchema.extend({
|
|
13
|
+
export const NumberVariableSchema = BaseVariableSchema.extend({
|
|
14
14
|
type: z.literal('number'),
|
|
15
15
|
defaultValue: z.number({ coerce: true }).optional(),
|
|
16
16
|
});
|
|
17
17
|
|
|
18
|
-
const DateVariableSchema = BaseVariableSchema.extend({
|
|
18
|
+
export const DateVariableSchema = BaseVariableSchema.extend({
|
|
19
19
|
type: z.literal('date'),
|
|
20
20
|
defaultValue: z.date({ coerce: true }).optional(),
|
|
21
21
|
});
|
|
22
22
|
|
|
23
|
-
const CodelistVariableSchema = BaseVariableSchema.extend({
|
|
23
|
+
export const CodelistVariableSchema = BaseVariableSchema.extend({
|
|
24
24
|
type: z.literal('codelist'),
|
|
25
25
|
defaultValue: z.string().optional(),
|
|
26
26
|
codelistUri: z.string(),
|
|
27
27
|
});
|
|
28
28
|
|
|
29
|
-
const LocationVariableSchema = BaseVariableSchema.extend({
|
|
29
|
+
export const LocationVariableSchema = BaseVariableSchema.extend({
|
|
30
30
|
type: z.literal('location'),
|
|
31
31
|
defaultValue: z.string().optional(),
|
|
32
32
|
});
|
|
33
33
|
|
|
34
|
-
const InstructionVariableSchema = BaseVariableSchema.extend({
|
|
34
|
+
export const InstructionVariableSchema = BaseVariableSchema.extend({
|
|
35
35
|
type: z.literal('instruction'),
|
|
36
36
|
});
|
|
37
37
|
|
|
@@ -5,6 +5,7 @@ import { BesluitTypeInstance } from '@lblod/ember-rdfa-editor-lblod-plugins/plug
|
|
|
5
5
|
type Args = {
|
|
6
6
|
controller: SayController;
|
|
7
7
|
options: BesluitTypePluginOptions;
|
|
8
|
+
allowForDraftTypes?: boolean;
|
|
8
9
|
};
|
|
9
10
|
export default class EditorPluginsToolbarDropdownComponent extends Component<Args> {
|
|
10
11
|
selectedTypeInstance?: BesluitTypeInstance;
|
|
@@ -17,6 +18,6 @@ export default class EditorPluginsToolbarDropdownComponent extends Component<Arg
|
|
|
17
18
|
toggleCard: () => void;
|
|
18
19
|
setType: (type: BesluitTypeInstance) => void;
|
|
19
20
|
updateBesluitTypes: () => void;
|
|
20
|
-
insertIfValid()
|
|
21
|
+
insertIfValid: () => void;
|
|
21
22
|
}
|
|
22
23
|
export {};
|
|
@@ -6,6 +6,7 @@ export interface BesluitTypeInstance {
|
|
|
6
6
|
subSubType?: BesluitType;
|
|
7
7
|
}
|
|
8
8
|
export declare function extractBesluitTypeUris(editorState: EditorState): string[];
|
|
9
|
+
export declare function checkForDraftBesluitType(editorState: EditorState): boolean;
|
|
9
10
|
/**
|
|
10
11
|
* Finds a decision type in the document and checks that it represents a valid decision type
|
|
11
12
|
* according to the list of types passed in.
|
|
@@ -1,4 +1,4 @@
|
|
|
1
1
|
import { type EditorState } from '@lblod/ember-rdfa-editor';
|
|
2
2
|
import { type TransactionCombinatorResult } from '@lblod/ember-rdfa-editor/utils/transaction-utils';
|
|
3
3
|
import { type BesluitTypeInstance } from './besluit-type-instances';
|
|
4
|
-
export declare function setBesluitType(initialState: EditorState, typeInstance: BesluitTypeInstance): TransactionCombinatorResult<boolean>;
|
|
4
|
+
export declare function setBesluitType(initialState: EditorState, typeInstance: BesluitTypeInstance, isDraftDecisionType?: boolean): TransactionCombinatorResult<boolean>;
|
|
@@ -2,16 +2,21 @@ import { TransactionMonad } from '@lblod/ember-rdfa-editor/utils/transaction-uti
|
|
|
2
2
|
import { MobilityMeasureConcept } from '../schemas/mobility-measure-concept';
|
|
3
3
|
import { Variable } from '../schemas/variable';
|
|
4
4
|
import { ZonalOrNot } from '../constants';
|
|
5
|
-
|
|
6
|
-
|
|
5
|
+
import { MobilityMeasureDesign } from '../schemas/mobility-measure-design';
|
|
6
|
+
import { VariableInstance } from '../schemas/variable-instance';
|
|
7
|
+
type InsertMeasureArgs = {
|
|
7
8
|
zonality: ZonalOrNot;
|
|
8
9
|
temporal: boolean;
|
|
9
10
|
variables: Record<string, Exclude<Variable, {
|
|
10
11
|
type: 'instruction';
|
|
11
|
-
}
|
|
12
|
+
}> | VariableInstance>;
|
|
12
13
|
templateString: string;
|
|
13
14
|
decisionUri: string;
|
|
14
15
|
articleUriGenerator?: () => string;
|
|
15
|
-
}
|
|
16
|
-
|
|
16
|
+
} & ({
|
|
17
|
+
measureConcept: MobilityMeasureConcept;
|
|
18
|
+
} | {
|
|
19
|
+
measureDesign: MobilityMeasureDesign;
|
|
20
|
+
});
|
|
21
|
+
export default function insertMeasure({ zonality, temporal, variables, templateString, articleUriGenerator, decisionUri, ...args }: InsertMeasureArgs): TransactionMonad<boolean>;
|
|
17
22
|
export {};
|
package/declarations/addon/plugins/roadsign-regulation-plugin/schemas/mobility-measure-design.d.ts
ADDED
|
@@ -0,0 +1,279 @@
|
|
|
1
|
+
import { z } from 'zod';
|
|
2
|
+
import { type MobilityMeasureConcept } from './mobility-measure-concept';
|
|
3
|
+
export declare const MobilityMeasureDesignSchema: z.ZodObject<{
|
|
4
|
+
uri: z.ZodString;
|
|
5
|
+
trafficSignals: z.ZodArray<z.ZodObject<{
|
|
6
|
+
uri: z.ZodString;
|
|
7
|
+
trafficSignalConcept: z.ZodIntersection<z.ZodObject<{
|
|
8
|
+
uri: z.ZodString;
|
|
9
|
+
code: z.ZodString;
|
|
10
|
+
regulatoryNotation: z.ZodOptional<z.ZodString>;
|
|
11
|
+
image: z.ZodString;
|
|
12
|
+
position: z.ZodDefault<z.ZodNumber>;
|
|
13
|
+
}, "strip", z.ZodTypeAny, {
|
|
14
|
+
code: string;
|
|
15
|
+
image: string;
|
|
16
|
+
uri: string;
|
|
17
|
+
position: number;
|
|
18
|
+
regulatoryNotation?: string | undefined;
|
|
19
|
+
}, {
|
|
20
|
+
code: string;
|
|
21
|
+
image: string;
|
|
22
|
+
uri: string;
|
|
23
|
+
position?: number | undefined;
|
|
24
|
+
regulatoryNotation?: string | undefined;
|
|
25
|
+
}>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
26
|
+
type: z.ZodLiteral<"https://data.vlaanderen.be/ns/mobiliteit#Verkeersbordconcept">;
|
|
27
|
+
categories: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
28
|
+
uri: z.ZodString;
|
|
29
|
+
label: z.ZodString;
|
|
30
|
+
}, "strip", z.ZodTypeAny, {
|
|
31
|
+
label: string;
|
|
32
|
+
uri: string;
|
|
33
|
+
}, {
|
|
34
|
+
label: string;
|
|
35
|
+
uri: string;
|
|
36
|
+
}>, "many">>;
|
|
37
|
+
}, "strip", z.ZodTypeAny, {
|
|
38
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeersbordconcept";
|
|
39
|
+
categories: {
|
|
40
|
+
label: string;
|
|
41
|
+
uri: string;
|
|
42
|
+
}[];
|
|
43
|
+
}, {
|
|
44
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeersbordconcept";
|
|
45
|
+
categories?: {
|
|
46
|
+
label: string;
|
|
47
|
+
uri: string;
|
|
48
|
+
}[] | undefined;
|
|
49
|
+
}>, z.ZodObject<{
|
|
50
|
+
type: z.ZodEnum<["https://data.vlaanderen.be/ns/mobiliteit#Wegmarkeringconcept", "https://data.vlaanderen.be/ns/mobiliteit#Verkeerslichtconcept"]>;
|
|
51
|
+
}, "strip", z.ZodTypeAny, {
|
|
52
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeerslichtconcept" | "https://data.vlaanderen.be/ns/mobiliteit#Wegmarkeringconcept";
|
|
53
|
+
}, {
|
|
54
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeerslichtconcept" | "https://data.vlaanderen.be/ns/mobiliteit#Wegmarkeringconcept";
|
|
55
|
+
}>]>>;
|
|
56
|
+
}, "strip", z.ZodTypeAny, {
|
|
57
|
+
uri: string;
|
|
58
|
+
trafficSignalConcept: {
|
|
59
|
+
code: string;
|
|
60
|
+
image: string;
|
|
61
|
+
uri: string;
|
|
62
|
+
position: number;
|
|
63
|
+
regulatoryNotation?: string | undefined;
|
|
64
|
+
} & ({
|
|
65
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeersbordconcept";
|
|
66
|
+
categories: {
|
|
67
|
+
label: string;
|
|
68
|
+
uri: string;
|
|
69
|
+
}[];
|
|
70
|
+
} | {
|
|
71
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeerslichtconcept" | "https://data.vlaanderen.be/ns/mobiliteit#Wegmarkeringconcept";
|
|
72
|
+
});
|
|
73
|
+
}, {
|
|
74
|
+
uri: string;
|
|
75
|
+
trafficSignalConcept: {
|
|
76
|
+
code: string;
|
|
77
|
+
image: string;
|
|
78
|
+
uri: string;
|
|
79
|
+
position?: number | undefined;
|
|
80
|
+
regulatoryNotation?: string | undefined;
|
|
81
|
+
} & ({
|
|
82
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeersbordconcept";
|
|
83
|
+
categories?: {
|
|
84
|
+
label: string;
|
|
85
|
+
uri: string;
|
|
86
|
+
}[] | undefined;
|
|
87
|
+
} | {
|
|
88
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeerslichtconcept" | "https://data.vlaanderen.be/ns/mobiliteit#Wegmarkeringconcept";
|
|
89
|
+
});
|
|
90
|
+
}>, "many">;
|
|
91
|
+
measureConcept: z.ZodObject<{
|
|
92
|
+
uri: z.ZodString;
|
|
93
|
+
label: z.ZodString;
|
|
94
|
+
preview: z.ZodString;
|
|
95
|
+
zonality: z.ZodNativeEnum<{
|
|
96
|
+
readonly POTENTIALLY_ZONAL: "http://register.mobiliteit.vlaanderen.be/concepts/8f9367b2-c717-4be7-8833-4c75bbb4ae1f";
|
|
97
|
+
readonly ZONAL: "http://register.mobiliteit.vlaanderen.be/concepts/c81c6b96-736a-48cf-b003-6f5cc3dbc55d";
|
|
98
|
+
readonly NON_ZONAL: "http://register.mobiliteit.vlaanderen.be/concepts/b651931b-923c-477c-8da9-fc7dd841fdcc";
|
|
99
|
+
}>;
|
|
100
|
+
variableSignage: z.ZodDefault<z.ZodBoolean>;
|
|
101
|
+
trafficSignalConcepts: z.ZodDefault<z.ZodArray<z.ZodIntersection<z.ZodObject<{
|
|
102
|
+
uri: z.ZodString;
|
|
103
|
+
code: z.ZodString;
|
|
104
|
+
regulatoryNotation: z.ZodOptional<z.ZodString>;
|
|
105
|
+
image: z.ZodString;
|
|
106
|
+
position: z.ZodDefault<z.ZodNumber>;
|
|
107
|
+
}, "strip", z.ZodTypeAny, {
|
|
108
|
+
code: string;
|
|
109
|
+
image: string;
|
|
110
|
+
uri: string;
|
|
111
|
+
position: number;
|
|
112
|
+
regulatoryNotation?: string | undefined;
|
|
113
|
+
}, {
|
|
114
|
+
code: string;
|
|
115
|
+
image: string;
|
|
116
|
+
uri: string;
|
|
117
|
+
position?: number | undefined;
|
|
118
|
+
regulatoryNotation?: string | undefined;
|
|
119
|
+
}>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
120
|
+
type: z.ZodLiteral<"https://data.vlaanderen.be/ns/mobiliteit#Verkeersbordconcept">;
|
|
121
|
+
categories: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
122
|
+
uri: z.ZodString;
|
|
123
|
+
label: z.ZodString;
|
|
124
|
+
}, "strip", z.ZodTypeAny, {
|
|
125
|
+
label: string;
|
|
126
|
+
uri: string;
|
|
127
|
+
}, {
|
|
128
|
+
label: string;
|
|
129
|
+
uri: string;
|
|
130
|
+
}>, "many">>;
|
|
131
|
+
}, "strip", z.ZodTypeAny, {
|
|
132
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeersbordconcept";
|
|
133
|
+
categories: {
|
|
134
|
+
label: string;
|
|
135
|
+
uri: string;
|
|
136
|
+
}[];
|
|
137
|
+
}, {
|
|
138
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeersbordconcept";
|
|
139
|
+
categories?: {
|
|
140
|
+
label: string;
|
|
141
|
+
uri: string;
|
|
142
|
+
}[] | undefined;
|
|
143
|
+
}>, z.ZodObject<{
|
|
144
|
+
type: z.ZodEnum<["https://data.vlaanderen.be/ns/mobiliteit#Wegmarkeringconcept", "https://data.vlaanderen.be/ns/mobiliteit#Verkeerslichtconcept"]>;
|
|
145
|
+
}, "strip", z.ZodTypeAny, {
|
|
146
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeerslichtconcept" | "https://data.vlaanderen.be/ns/mobiliteit#Wegmarkeringconcept";
|
|
147
|
+
}, {
|
|
148
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeerslichtconcept" | "https://data.vlaanderen.be/ns/mobiliteit#Wegmarkeringconcept";
|
|
149
|
+
}>]>>, "many">>;
|
|
150
|
+
}, "strip", z.ZodTypeAny, {
|
|
151
|
+
label: string;
|
|
152
|
+
uri: string;
|
|
153
|
+
preview: string;
|
|
154
|
+
zonality: "http://register.mobiliteit.vlaanderen.be/concepts/8f9367b2-c717-4be7-8833-4c75bbb4ae1f" | "http://register.mobiliteit.vlaanderen.be/concepts/c81c6b96-736a-48cf-b003-6f5cc3dbc55d" | "http://register.mobiliteit.vlaanderen.be/concepts/b651931b-923c-477c-8da9-fc7dd841fdcc";
|
|
155
|
+
variableSignage: boolean;
|
|
156
|
+
trafficSignalConcepts: ({
|
|
157
|
+
code: string;
|
|
158
|
+
image: string;
|
|
159
|
+
uri: string;
|
|
160
|
+
position: number;
|
|
161
|
+
regulatoryNotation?: string | undefined;
|
|
162
|
+
} & ({
|
|
163
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeersbordconcept";
|
|
164
|
+
categories: {
|
|
165
|
+
label: string;
|
|
166
|
+
uri: string;
|
|
167
|
+
}[];
|
|
168
|
+
} | {
|
|
169
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeerslichtconcept" | "https://data.vlaanderen.be/ns/mobiliteit#Wegmarkeringconcept";
|
|
170
|
+
}))[];
|
|
171
|
+
}, {
|
|
172
|
+
label: string;
|
|
173
|
+
uri: string;
|
|
174
|
+
preview: string;
|
|
175
|
+
zonality: "http://register.mobiliteit.vlaanderen.be/concepts/8f9367b2-c717-4be7-8833-4c75bbb4ae1f" | "http://register.mobiliteit.vlaanderen.be/concepts/c81c6b96-736a-48cf-b003-6f5cc3dbc55d" | "http://register.mobiliteit.vlaanderen.be/concepts/b651931b-923c-477c-8da9-fc7dd841fdcc";
|
|
176
|
+
variableSignage?: boolean | undefined;
|
|
177
|
+
trafficSignalConcepts?: ({
|
|
178
|
+
code: string;
|
|
179
|
+
image: string;
|
|
180
|
+
uri: string;
|
|
181
|
+
position?: number | undefined;
|
|
182
|
+
regulatoryNotation?: string | undefined;
|
|
183
|
+
} & ({
|
|
184
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeersbordconcept";
|
|
185
|
+
categories?: {
|
|
186
|
+
label: string;
|
|
187
|
+
uri: string;
|
|
188
|
+
}[] | undefined;
|
|
189
|
+
} | {
|
|
190
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeerslichtconcept" | "https://data.vlaanderen.be/ns/mobiliteit#Wegmarkeringconcept";
|
|
191
|
+
}))[] | undefined;
|
|
192
|
+
}>;
|
|
193
|
+
}, "strip", z.ZodTypeAny, {
|
|
194
|
+
uri: string;
|
|
195
|
+
measureConcept: {
|
|
196
|
+
label: string;
|
|
197
|
+
uri: string;
|
|
198
|
+
preview: string;
|
|
199
|
+
zonality: "http://register.mobiliteit.vlaanderen.be/concepts/8f9367b2-c717-4be7-8833-4c75bbb4ae1f" | "http://register.mobiliteit.vlaanderen.be/concepts/c81c6b96-736a-48cf-b003-6f5cc3dbc55d" | "http://register.mobiliteit.vlaanderen.be/concepts/b651931b-923c-477c-8da9-fc7dd841fdcc";
|
|
200
|
+
variableSignage: boolean;
|
|
201
|
+
trafficSignalConcepts: ({
|
|
202
|
+
code: string;
|
|
203
|
+
image: string;
|
|
204
|
+
uri: string;
|
|
205
|
+
position: number;
|
|
206
|
+
regulatoryNotation?: string | undefined;
|
|
207
|
+
} & ({
|
|
208
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeersbordconcept";
|
|
209
|
+
categories: {
|
|
210
|
+
label: string;
|
|
211
|
+
uri: string;
|
|
212
|
+
}[];
|
|
213
|
+
} | {
|
|
214
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeerslichtconcept" | "https://data.vlaanderen.be/ns/mobiliteit#Wegmarkeringconcept";
|
|
215
|
+
}))[];
|
|
216
|
+
};
|
|
217
|
+
trafficSignals: {
|
|
218
|
+
uri: string;
|
|
219
|
+
trafficSignalConcept: {
|
|
220
|
+
code: string;
|
|
221
|
+
image: string;
|
|
222
|
+
uri: string;
|
|
223
|
+
position: number;
|
|
224
|
+
regulatoryNotation?: string | undefined;
|
|
225
|
+
} & ({
|
|
226
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeersbordconcept";
|
|
227
|
+
categories: {
|
|
228
|
+
label: string;
|
|
229
|
+
uri: string;
|
|
230
|
+
}[];
|
|
231
|
+
} | {
|
|
232
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeerslichtconcept" | "https://data.vlaanderen.be/ns/mobiliteit#Wegmarkeringconcept";
|
|
233
|
+
});
|
|
234
|
+
}[];
|
|
235
|
+
}, {
|
|
236
|
+
uri: string;
|
|
237
|
+
measureConcept: {
|
|
238
|
+
label: string;
|
|
239
|
+
uri: string;
|
|
240
|
+
preview: string;
|
|
241
|
+
zonality: "http://register.mobiliteit.vlaanderen.be/concepts/8f9367b2-c717-4be7-8833-4c75bbb4ae1f" | "http://register.mobiliteit.vlaanderen.be/concepts/c81c6b96-736a-48cf-b003-6f5cc3dbc55d" | "http://register.mobiliteit.vlaanderen.be/concepts/b651931b-923c-477c-8da9-fc7dd841fdcc";
|
|
242
|
+
variableSignage?: boolean | undefined;
|
|
243
|
+
trafficSignalConcepts?: ({
|
|
244
|
+
code: string;
|
|
245
|
+
image: string;
|
|
246
|
+
uri: string;
|
|
247
|
+
position?: number | undefined;
|
|
248
|
+
regulatoryNotation?: string | undefined;
|
|
249
|
+
} & ({
|
|
250
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeersbordconcept";
|
|
251
|
+
categories?: {
|
|
252
|
+
label: string;
|
|
253
|
+
uri: string;
|
|
254
|
+
}[] | undefined;
|
|
255
|
+
} | {
|
|
256
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeerslichtconcept" | "https://data.vlaanderen.be/ns/mobiliteit#Wegmarkeringconcept";
|
|
257
|
+
}))[] | undefined;
|
|
258
|
+
};
|
|
259
|
+
trafficSignals: {
|
|
260
|
+
uri: string;
|
|
261
|
+
trafficSignalConcept: {
|
|
262
|
+
code: string;
|
|
263
|
+
image: string;
|
|
264
|
+
uri: string;
|
|
265
|
+
position?: number | undefined;
|
|
266
|
+
regulatoryNotation?: string | undefined;
|
|
267
|
+
} & ({
|
|
268
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeersbordconcept";
|
|
269
|
+
categories?: {
|
|
270
|
+
label: string;
|
|
271
|
+
uri: string;
|
|
272
|
+
}[] | undefined;
|
|
273
|
+
} | {
|
|
274
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeerslichtconcept" | "https://data.vlaanderen.be/ns/mobiliteit#Wegmarkeringconcept";
|
|
275
|
+
});
|
|
276
|
+
}[];
|
|
277
|
+
}>;
|
|
278
|
+
export type MobilityMeasureDesign = z.infer<typeof MobilityMeasureDesignSchema>;
|
|
279
|
+
export declare function isMobilityMeasureDesign(conceptOrDesign: MobilityMeasureConcept | MobilityMeasureDesign): conceptOrDesign is MobilityMeasureDesign;
|
|
@@ -0,0 +1,90 @@
|
|
|
1
|
+
import { z } from 'zod';
|
|
2
|
+
import { TrafficSignalConcept } from './traffic-signal-concept';
|
|
3
|
+
export declare const TrafficSignalSchema: z.ZodObject<{
|
|
4
|
+
uri: z.ZodString;
|
|
5
|
+
trafficSignalConcept: z.ZodIntersection<z.ZodObject<{
|
|
6
|
+
uri: z.ZodString;
|
|
7
|
+
code: z.ZodString;
|
|
8
|
+
regulatoryNotation: z.ZodOptional<z.ZodString>;
|
|
9
|
+
image: z.ZodString;
|
|
10
|
+
position: z.ZodDefault<z.ZodNumber>;
|
|
11
|
+
}, "strip", z.ZodTypeAny, {
|
|
12
|
+
code: string;
|
|
13
|
+
image: string;
|
|
14
|
+
uri: string;
|
|
15
|
+
position: number;
|
|
16
|
+
regulatoryNotation?: string | undefined;
|
|
17
|
+
}, {
|
|
18
|
+
code: string;
|
|
19
|
+
image: string;
|
|
20
|
+
uri: string;
|
|
21
|
+
position?: number | undefined;
|
|
22
|
+
regulatoryNotation?: string | undefined;
|
|
23
|
+
}>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
24
|
+
type: z.ZodLiteral<"https://data.vlaanderen.be/ns/mobiliteit#Verkeersbordconcept">;
|
|
25
|
+
categories: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
26
|
+
uri: z.ZodString;
|
|
27
|
+
label: z.ZodString;
|
|
28
|
+
}, "strip", z.ZodTypeAny, {
|
|
29
|
+
label: string;
|
|
30
|
+
uri: string;
|
|
31
|
+
}, {
|
|
32
|
+
label: string;
|
|
33
|
+
uri: string;
|
|
34
|
+
}>, "many">>;
|
|
35
|
+
}, "strip", z.ZodTypeAny, {
|
|
36
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeersbordconcept";
|
|
37
|
+
categories: {
|
|
38
|
+
label: string;
|
|
39
|
+
uri: string;
|
|
40
|
+
}[];
|
|
41
|
+
}, {
|
|
42
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeersbordconcept";
|
|
43
|
+
categories?: {
|
|
44
|
+
label: string;
|
|
45
|
+
uri: string;
|
|
46
|
+
}[] | undefined;
|
|
47
|
+
}>, z.ZodObject<{
|
|
48
|
+
type: z.ZodEnum<["https://data.vlaanderen.be/ns/mobiliteit#Wegmarkeringconcept", "https://data.vlaanderen.be/ns/mobiliteit#Verkeerslichtconcept"]>;
|
|
49
|
+
}, "strip", z.ZodTypeAny, {
|
|
50
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeerslichtconcept" | "https://data.vlaanderen.be/ns/mobiliteit#Wegmarkeringconcept";
|
|
51
|
+
}, {
|
|
52
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeerslichtconcept" | "https://data.vlaanderen.be/ns/mobiliteit#Wegmarkeringconcept";
|
|
53
|
+
}>]>>;
|
|
54
|
+
}, "strip", z.ZodTypeAny, {
|
|
55
|
+
uri: string;
|
|
56
|
+
trafficSignalConcept: {
|
|
57
|
+
code: string;
|
|
58
|
+
image: string;
|
|
59
|
+
uri: string;
|
|
60
|
+
position: number;
|
|
61
|
+
regulatoryNotation?: string | undefined;
|
|
62
|
+
} & ({
|
|
63
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeersbordconcept";
|
|
64
|
+
categories: {
|
|
65
|
+
label: string;
|
|
66
|
+
uri: string;
|
|
67
|
+
}[];
|
|
68
|
+
} | {
|
|
69
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeerslichtconcept" | "https://data.vlaanderen.be/ns/mobiliteit#Wegmarkeringconcept";
|
|
70
|
+
});
|
|
71
|
+
}, {
|
|
72
|
+
uri: string;
|
|
73
|
+
trafficSignalConcept: {
|
|
74
|
+
code: string;
|
|
75
|
+
image: string;
|
|
76
|
+
uri: string;
|
|
77
|
+
position?: number | undefined;
|
|
78
|
+
regulatoryNotation?: string | undefined;
|
|
79
|
+
} & ({
|
|
80
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeersbordconcept";
|
|
81
|
+
categories?: {
|
|
82
|
+
label: string;
|
|
83
|
+
uri: string;
|
|
84
|
+
}[] | undefined;
|
|
85
|
+
} | {
|
|
86
|
+
type: "https://data.vlaanderen.be/ns/mobiliteit#Verkeerslichtconcept" | "https://data.vlaanderen.be/ns/mobiliteit#Wegmarkeringconcept";
|
|
87
|
+
});
|
|
88
|
+
}>;
|
|
89
|
+
export type TrafficSignal = z.infer<typeof TrafficSignalSchema>;
|
|
90
|
+
export declare function isTrafficSignal(signalOrSignalConcept: TrafficSignal | TrafficSignalConcept): signalOrSignalConcept is TrafficSignal;
|
|
@@ -0,0 +1,230 @@
|
|
|
1
|
+
import { z } from 'zod';
|
|
2
|
+
import { Variable } from './variable';
|
|
3
|
+
export declare const VariableInstanceSchema: z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
|
|
4
|
+
uri: z.ZodString;
|
|
5
|
+
}, {
|
|
6
|
+
value: z.ZodOptional<z.ZodString>;
|
|
7
|
+
variable: z.ZodObject<z.objectUtil.extendShape<{
|
|
8
|
+
uri: z.ZodString;
|
|
9
|
+
label: z.ZodString;
|
|
10
|
+
source: z.ZodOptional<z.ZodString>;
|
|
11
|
+
}, {
|
|
12
|
+
type: z.ZodLiteral<"text">;
|
|
13
|
+
defaultValue: z.ZodOptional<z.ZodString>;
|
|
14
|
+
}>, "strip", z.ZodTypeAny, {
|
|
15
|
+
type: "text";
|
|
16
|
+
label: string;
|
|
17
|
+
uri: string;
|
|
18
|
+
source?: string | undefined;
|
|
19
|
+
defaultValue?: string | undefined;
|
|
20
|
+
}, {
|
|
21
|
+
type: "text";
|
|
22
|
+
label: string;
|
|
23
|
+
uri: string;
|
|
24
|
+
source?: string | undefined;
|
|
25
|
+
defaultValue?: string | undefined;
|
|
26
|
+
}>;
|
|
27
|
+
}>, "strip", z.ZodTypeAny, {
|
|
28
|
+
uri: string;
|
|
29
|
+
variable: {
|
|
30
|
+
type: "text";
|
|
31
|
+
label: string;
|
|
32
|
+
uri: string;
|
|
33
|
+
source?: string | undefined;
|
|
34
|
+
defaultValue?: string | undefined;
|
|
35
|
+
};
|
|
36
|
+
value?: string | undefined;
|
|
37
|
+
}, {
|
|
38
|
+
uri: string;
|
|
39
|
+
variable: {
|
|
40
|
+
type: "text";
|
|
41
|
+
label: string;
|
|
42
|
+
uri: string;
|
|
43
|
+
source?: string | undefined;
|
|
44
|
+
defaultValue?: string | undefined;
|
|
45
|
+
};
|
|
46
|
+
value?: string | undefined;
|
|
47
|
+
}>, z.ZodObject<z.objectUtil.extendShape<{
|
|
48
|
+
uri: z.ZodString;
|
|
49
|
+
}, {
|
|
50
|
+
value: z.ZodOptional<z.ZodNumber>;
|
|
51
|
+
variable: z.ZodObject<z.objectUtil.extendShape<{
|
|
52
|
+
uri: z.ZodString;
|
|
53
|
+
label: z.ZodString;
|
|
54
|
+
source: z.ZodOptional<z.ZodString>;
|
|
55
|
+
}, {
|
|
56
|
+
type: z.ZodLiteral<"number">;
|
|
57
|
+
defaultValue: z.ZodOptional<z.ZodNumber>;
|
|
58
|
+
}>, "strip", z.ZodTypeAny, {
|
|
59
|
+
type: "number";
|
|
60
|
+
label: string;
|
|
61
|
+
uri: string;
|
|
62
|
+
source?: string | undefined;
|
|
63
|
+
defaultValue?: number | undefined;
|
|
64
|
+
}, {
|
|
65
|
+
type: "number";
|
|
66
|
+
label: string;
|
|
67
|
+
uri: string;
|
|
68
|
+
source?: string | undefined;
|
|
69
|
+
defaultValue?: number | undefined;
|
|
70
|
+
}>;
|
|
71
|
+
}>, "strip", z.ZodTypeAny, {
|
|
72
|
+
uri: string;
|
|
73
|
+
variable: {
|
|
74
|
+
type: "number";
|
|
75
|
+
label: string;
|
|
76
|
+
uri: string;
|
|
77
|
+
source?: string | undefined;
|
|
78
|
+
defaultValue?: number | undefined;
|
|
79
|
+
};
|
|
80
|
+
value?: number | undefined;
|
|
81
|
+
}, {
|
|
82
|
+
uri: string;
|
|
83
|
+
variable: {
|
|
84
|
+
type: "number";
|
|
85
|
+
label: string;
|
|
86
|
+
uri: string;
|
|
87
|
+
source?: string | undefined;
|
|
88
|
+
defaultValue?: number | undefined;
|
|
89
|
+
};
|
|
90
|
+
value?: number | undefined;
|
|
91
|
+
}>, z.ZodObject<z.objectUtil.extendShape<{
|
|
92
|
+
uri: z.ZodString;
|
|
93
|
+
}, {
|
|
94
|
+
value: z.ZodOptional<z.ZodDate>;
|
|
95
|
+
variable: z.ZodObject<z.objectUtil.extendShape<{
|
|
96
|
+
uri: z.ZodString;
|
|
97
|
+
label: z.ZodString;
|
|
98
|
+
source: z.ZodOptional<z.ZodString>;
|
|
99
|
+
}, {
|
|
100
|
+
type: z.ZodLiteral<"date">;
|
|
101
|
+
defaultValue: z.ZodOptional<z.ZodDate>;
|
|
102
|
+
}>, "strip", z.ZodTypeAny, {
|
|
103
|
+
type: "date";
|
|
104
|
+
label: string;
|
|
105
|
+
uri: string;
|
|
106
|
+
source?: string | undefined;
|
|
107
|
+
defaultValue?: Date | undefined;
|
|
108
|
+
}, {
|
|
109
|
+
type: "date";
|
|
110
|
+
label: string;
|
|
111
|
+
uri: string;
|
|
112
|
+
source?: string | undefined;
|
|
113
|
+
defaultValue?: Date | undefined;
|
|
114
|
+
}>;
|
|
115
|
+
}>, "strip", z.ZodTypeAny, {
|
|
116
|
+
uri: string;
|
|
117
|
+
variable: {
|
|
118
|
+
type: "date";
|
|
119
|
+
label: string;
|
|
120
|
+
uri: string;
|
|
121
|
+
source?: string | undefined;
|
|
122
|
+
defaultValue?: Date | undefined;
|
|
123
|
+
};
|
|
124
|
+
value?: Date | undefined;
|
|
125
|
+
}, {
|
|
126
|
+
uri: string;
|
|
127
|
+
variable: {
|
|
128
|
+
type: "date";
|
|
129
|
+
label: string;
|
|
130
|
+
uri: string;
|
|
131
|
+
source?: string | undefined;
|
|
132
|
+
defaultValue?: Date | undefined;
|
|
133
|
+
};
|
|
134
|
+
value?: Date | undefined;
|
|
135
|
+
}>, z.ZodObject<z.objectUtil.extendShape<{
|
|
136
|
+
uri: z.ZodString;
|
|
137
|
+
}, {
|
|
138
|
+
value: z.ZodOptional<z.ZodString>;
|
|
139
|
+
variable: z.ZodObject<z.objectUtil.extendShape<{
|
|
140
|
+
uri: z.ZodString;
|
|
141
|
+
label: z.ZodString;
|
|
142
|
+
source: z.ZodOptional<z.ZodString>;
|
|
143
|
+
}, {
|
|
144
|
+
type: z.ZodLiteral<"location">;
|
|
145
|
+
defaultValue: z.ZodOptional<z.ZodString>;
|
|
146
|
+
}>, "strip", z.ZodTypeAny, {
|
|
147
|
+
type: "location";
|
|
148
|
+
label: string;
|
|
149
|
+
uri: string;
|
|
150
|
+
source?: string | undefined;
|
|
151
|
+
defaultValue?: string | undefined;
|
|
152
|
+
}, {
|
|
153
|
+
type: "location";
|
|
154
|
+
label: string;
|
|
155
|
+
uri: string;
|
|
156
|
+
source?: string | undefined;
|
|
157
|
+
defaultValue?: string | undefined;
|
|
158
|
+
}>;
|
|
159
|
+
}>, "strip", z.ZodTypeAny, {
|
|
160
|
+
uri: string;
|
|
161
|
+
variable: {
|
|
162
|
+
type: "location";
|
|
163
|
+
label: string;
|
|
164
|
+
uri: string;
|
|
165
|
+
source?: string | undefined;
|
|
166
|
+
defaultValue?: string | undefined;
|
|
167
|
+
};
|
|
168
|
+
value?: string | undefined;
|
|
169
|
+
}, {
|
|
170
|
+
uri: string;
|
|
171
|
+
variable: {
|
|
172
|
+
type: "location";
|
|
173
|
+
label: string;
|
|
174
|
+
uri: string;
|
|
175
|
+
source?: string | undefined;
|
|
176
|
+
defaultValue?: string | undefined;
|
|
177
|
+
};
|
|
178
|
+
value?: string | undefined;
|
|
179
|
+
}>, z.ZodObject<z.objectUtil.extendShape<{
|
|
180
|
+
uri: z.ZodString;
|
|
181
|
+
}, {
|
|
182
|
+
value: z.ZodOptional<z.ZodString>;
|
|
183
|
+
variable: z.ZodObject<z.objectUtil.extendShape<{
|
|
184
|
+
uri: z.ZodString;
|
|
185
|
+
label: z.ZodString;
|
|
186
|
+
source: z.ZodOptional<z.ZodString>;
|
|
187
|
+
}, {
|
|
188
|
+
type: z.ZodLiteral<"codelist">;
|
|
189
|
+
defaultValue: z.ZodOptional<z.ZodString>;
|
|
190
|
+
codelistUri: z.ZodString;
|
|
191
|
+
}>, "strip", z.ZodTypeAny, {
|
|
192
|
+
type: "codelist";
|
|
193
|
+
label: string;
|
|
194
|
+
uri: string;
|
|
195
|
+
codelistUri: string;
|
|
196
|
+
source?: string | undefined;
|
|
197
|
+
defaultValue?: string | undefined;
|
|
198
|
+
}, {
|
|
199
|
+
type: "codelist";
|
|
200
|
+
label: string;
|
|
201
|
+
uri: string;
|
|
202
|
+
codelistUri: string;
|
|
203
|
+
source?: string | undefined;
|
|
204
|
+
defaultValue?: string | undefined;
|
|
205
|
+
}>;
|
|
206
|
+
}>, "strip", z.ZodTypeAny, {
|
|
207
|
+
uri: string;
|
|
208
|
+
variable: {
|
|
209
|
+
type: "codelist";
|
|
210
|
+
label: string;
|
|
211
|
+
uri: string;
|
|
212
|
+
codelistUri: string;
|
|
213
|
+
source?: string | undefined;
|
|
214
|
+
defaultValue?: string | undefined;
|
|
215
|
+
};
|
|
216
|
+
value?: string | undefined;
|
|
217
|
+
}, {
|
|
218
|
+
uri: string;
|
|
219
|
+
variable: {
|
|
220
|
+
type: "codelist";
|
|
221
|
+
label: string;
|
|
222
|
+
uri: string;
|
|
223
|
+
codelistUri: string;
|
|
224
|
+
source?: string | undefined;
|
|
225
|
+
defaultValue?: string | undefined;
|
|
226
|
+
};
|
|
227
|
+
value?: string | undefined;
|
|
228
|
+
}>]>;
|
|
229
|
+
export type VariableInstance = z.infer<typeof VariableInstanceSchema>;
|
|
230
|
+
export declare function isVariableInstance(variableOrVariableInstance: Variable | VariableInstance): variableOrVariableInstance is VariableInstance;
|
|
@@ -1,4 +1,124 @@
|
|
|
1
1
|
import { z } from 'zod';
|
|
2
|
+
export declare const TextVariableSchema: z.ZodObject<z.objectUtil.extendShape<{
|
|
3
|
+
uri: z.ZodString;
|
|
4
|
+
label: z.ZodString;
|
|
5
|
+
source: z.ZodOptional<z.ZodString>;
|
|
6
|
+
}, {
|
|
7
|
+
type: z.ZodLiteral<"text">;
|
|
8
|
+
defaultValue: z.ZodOptional<z.ZodString>;
|
|
9
|
+
}>, "strip", z.ZodTypeAny, {
|
|
10
|
+
type: "text";
|
|
11
|
+
label: string;
|
|
12
|
+
uri: string;
|
|
13
|
+
source?: string | undefined;
|
|
14
|
+
defaultValue?: string | undefined;
|
|
15
|
+
}, {
|
|
16
|
+
type: "text";
|
|
17
|
+
label: string;
|
|
18
|
+
uri: string;
|
|
19
|
+
source?: string | undefined;
|
|
20
|
+
defaultValue?: string | undefined;
|
|
21
|
+
}>;
|
|
22
|
+
export declare const NumberVariableSchema: z.ZodObject<z.objectUtil.extendShape<{
|
|
23
|
+
uri: z.ZodString;
|
|
24
|
+
label: z.ZodString;
|
|
25
|
+
source: z.ZodOptional<z.ZodString>;
|
|
26
|
+
}, {
|
|
27
|
+
type: z.ZodLiteral<"number">;
|
|
28
|
+
defaultValue: z.ZodOptional<z.ZodNumber>;
|
|
29
|
+
}>, "strip", z.ZodTypeAny, {
|
|
30
|
+
type: "number";
|
|
31
|
+
label: string;
|
|
32
|
+
uri: string;
|
|
33
|
+
source?: string | undefined;
|
|
34
|
+
defaultValue?: number | undefined;
|
|
35
|
+
}, {
|
|
36
|
+
type: "number";
|
|
37
|
+
label: string;
|
|
38
|
+
uri: string;
|
|
39
|
+
source?: string | undefined;
|
|
40
|
+
defaultValue?: number | undefined;
|
|
41
|
+
}>;
|
|
42
|
+
export declare const DateVariableSchema: z.ZodObject<z.objectUtil.extendShape<{
|
|
43
|
+
uri: z.ZodString;
|
|
44
|
+
label: z.ZodString;
|
|
45
|
+
source: z.ZodOptional<z.ZodString>;
|
|
46
|
+
}, {
|
|
47
|
+
type: z.ZodLiteral<"date">;
|
|
48
|
+
defaultValue: z.ZodOptional<z.ZodDate>;
|
|
49
|
+
}>, "strip", z.ZodTypeAny, {
|
|
50
|
+
type: "date";
|
|
51
|
+
label: string;
|
|
52
|
+
uri: string;
|
|
53
|
+
source?: string | undefined;
|
|
54
|
+
defaultValue?: Date | undefined;
|
|
55
|
+
}, {
|
|
56
|
+
type: "date";
|
|
57
|
+
label: string;
|
|
58
|
+
uri: string;
|
|
59
|
+
source?: string | undefined;
|
|
60
|
+
defaultValue?: Date | undefined;
|
|
61
|
+
}>;
|
|
62
|
+
export declare const CodelistVariableSchema: z.ZodObject<z.objectUtil.extendShape<{
|
|
63
|
+
uri: z.ZodString;
|
|
64
|
+
label: z.ZodString;
|
|
65
|
+
source: z.ZodOptional<z.ZodString>;
|
|
66
|
+
}, {
|
|
67
|
+
type: z.ZodLiteral<"codelist">;
|
|
68
|
+
defaultValue: z.ZodOptional<z.ZodString>;
|
|
69
|
+
codelistUri: z.ZodString;
|
|
70
|
+
}>, "strip", z.ZodTypeAny, {
|
|
71
|
+
type: "codelist";
|
|
72
|
+
label: string;
|
|
73
|
+
uri: string;
|
|
74
|
+
codelistUri: string;
|
|
75
|
+
source?: string | undefined;
|
|
76
|
+
defaultValue?: string | undefined;
|
|
77
|
+
}, {
|
|
78
|
+
type: "codelist";
|
|
79
|
+
label: string;
|
|
80
|
+
uri: string;
|
|
81
|
+
codelistUri: string;
|
|
82
|
+
source?: string | undefined;
|
|
83
|
+
defaultValue?: string | undefined;
|
|
84
|
+
}>;
|
|
85
|
+
export declare const LocationVariableSchema: z.ZodObject<z.objectUtil.extendShape<{
|
|
86
|
+
uri: z.ZodString;
|
|
87
|
+
label: z.ZodString;
|
|
88
|
+
source: z.ZodOptional<z.ZodString>;
|
|
89
|
+
}, {
|
|
90
|
+
type: z.ZodLiteral<"location">;
|
|
91
|
+
defaultValue: z.ZodOptional<z.ZodString>;
|
|
92
|
+
}>, "strip", z.ZodTypeAny, {
|
|
93
|
+
type: "location";
|
|
94
|
+
label: string;
|
|
95
|
+
uri: string;
|
|
96
|
+
source?: string | undefined;
|
|
97
|
+
defaultValue?: string | undefined;
|
|
98
|
+
}, {
|
|
99
|
+
type: "location";
|
|
100
|
+
label: string;
|
|
101
|
+
uri: string;
|
|
102
|
+
source?: string | undefined;
|
|
103
|
+
defaultValue?: string | undefined;
|
|
104
|
+
}>;
|
|
105
|
+
export declare const InstructionVariableSchema: z.ZodObject<z.objectUtil.extendShape<{
|
|
106
|
+
uri: z.ZodString;
|
|
107
|
+
label: z.ZodString;
|
|
108
|
+
source: z.ZodOptional<z.ZodString>;
|
|
109
|
+
}, {
|
|
110
|
+
type: z.ZodLiteral<"instruction">;
|
|
111
|
+
}>, "strip", z.ZodTypeAny, {
|
|
112
|
+
type: "instruction";
|
|
113
|
+
label: string;
|
|
114
|
+
uri: string;
|
|
115
|
+
source?: string | undefined;
|
|
116
|
+
}, {
|
|
117
|
+
type: "instruction";
|
|
118
|
+
label: string;
|
|
119
|
+
uri: string;
|
|
120
|
+
source?: string | undefined;
|
|
121
|
+
}>;
|
|
2
122
|
export declare const VariableSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<z.objectUtil.extendShape<{
|
|
3
123
|
uri: z.ZodString;
|
|
4
124
|
label: z.ZodString;
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@lblod/ember-rdfa-editor-lblod-plugins",
|
|
3
|
-
"version": "33.
|
|
3
|
+
"version": "33.2.0-dev.30fd14f2427b10213d5acbd8ef1a0f98dc9f26e5",
|
|
4
4
|
"description": "Ember addon providing lblod specific plugins for the ember-rdfa-editor",
|
|
5
5
|
"keywords": [
|
|
6
6
|
"ember-addon",
|