@uniformdev/uniform-nuxt 20.15.0 → 20.16.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (9) hide show
  1. package/dist/module.d.mts +2 -1
  2. package/dist/module.json +2 -2
  3. package/dist/runtime/composables/useUniformComposition.d.ts +1305 -4
  4. package/dist/runtime/plugin.d.ts +3142 -1
  5. package/dist/types.d.mts +4 -2
  6. package/package.json +25 -19
  7. package/dist/module.cjs +0 -5
  8. package/dist/module.d.ts +0 -45
  9. package/dist/types.d.ts +0 -7
package/dist/runtime/plugin.d.ts CHANGED
@@ -1,3 +1,6 @@
1
+ import { CanvasClient, CompositionGetParameters } from '@uniformdev/canvas';
2
+ import { Context } from '@uniformdev/context';
3
+ import { type Ref } from 'vue';
1
4
  export type PreviewState = {
2
5
  slug: string | undefined;
3
6
  compositionId: string | undefined;
@@ -5,5 +8,3143 @@ export type PreviewState = {
5
8
  locale: string | undefined;
6
9
  isContextualEditing: boolean;
7
10
  };
8
- declare const _default: any;
11
+ declare const _default: import("#app").Plugin<{
12
+ uniformIsSetup: boolean;
13
+ useUniformContext: () => import("@uniformdev/context-vue").UniformContextProps;
14
+ preview: PreviewState | undefined;
15
+ uniformCanvasClient: CanvasClient;
16
+ uniformContext: Context;
17
+ useComposition: (options: Pick<CompositionGetParameters, "compositionId" | "slug" | "state">) => Promise<{
18
+ data: Ref<({
19
+ wholeResponseCacheDiagnostics?: {
20
+ info: string;
21
+ cacheTtl: number;
22
+ cachedAt: string;
23
+ edgeLocation?: string;
24
+ requestId: string;
25
+ };
26
+ diagnostics?: {
27
+ edgeLocation?: string;
28
+ originFetch?: {
29
+ duration: number;
30
+ cacheHit: boolean;
31
+ isValid: boolean;
32
+ sourceCache?: "edge-cdn-cache" | "long-term-cache" | "api-cache";
33
+ cacheLocation?: string;
34
+ requestId?: string;
35
+ };
36
+ configRetrieval?: {
37
+ duration: number;
38
+ dataTypeCount: number;
39
+ };
40
+ } & {
41
+ data?: {
42
+ componentPath: string;
43
+ dataType: string;
44
+ dataName: string;
45
+ performance: {
46
+ cacheHit: boolean;
47
+ total: number;
48
+ retryCount: number;
49
+ retryDelay: number;
50
+ sourceCache?: string;
51
+ statusCodes: number[];
52
+ };
53
+ data: unknown;
54
+ }[];
55
+ };
56
+ errors?: {
57
+ componentId?: string;
58
+ componentPath?: string;
59
+ componentType?: string;
60
+ message: string;
61
+ type: string;
62
+ parameterName?: string;
63
+ expression?: {
64
+ pointer: string;
65
+ syntax: "jptr";
66
+ failureAction?: "t" | "p" | "c" | "a";
67
+ failureLogLevel?: "e" | "w" | "i";
68
+ failureDefault?: string;
69
+ };
70
+ dataName?: string;
71
+ dataType?: string;
72
+ inputName?: string;
73
+ code?: string;
74
+ locale?: string;
75
+ conditionIndex?: number;
76
+ clauseIndex?: number;
77
+ }[];
78
+ warnings?: {
79
+ componentId?: string;
80
+ componentPath?: string;
81
+ componentType?: string;
82
+ message: string;
83
+ type: string;
84
+ parameterName?: string;
85
+ expression?: {
86
+ pointer: string;
87
+ syntax: "jptr";
88
+ failureAction?: "t" | "p" | "c" | "a";
89
+ failureLogLevel?: "e" | "w" | "i";
90
+ failureDefault?: string;
91
+ };
92
+ dataName?: string;
93
+ dataType?: string;
94
+ inputName?: string;
95
+ code?: string;
96
+ locale?: string;
97
+ conditionIndex?: number;
98
+ clauseIndex?: number;
99
+ }[];
100
+ infos?: {
101
+ componentId?: string;
102
+ componentPath?: string;
103
+ componentType?: string;
104
+ message: string;
105
+ type: string;
106
+ parameterName?: string;
107
+ expression?: {
108
+ pointer: string;
109
+ syntax: "jptr";
110
+ failureAction?: "t" | "p" | "c" | "a";
111
+ failureLogLevel?: "e" | "w" | "i";
112
+ failureDefault?: string;
113
+ };
114
+ dataName?: string;
115
+ dataType?: string;
116
+ inputName?: string;
117
+ code?: string;
118
+ locale?: string;
119
+ conditionIndex?: number;
120
+ clauseIndex?: number;
121
+ }[];
122
+ } & {
123
+ state: number;
124
+ uiStatus?: "Draft" | "Modified" | "Published" | "Orphan" | "Previous" | "Unknown";
125
+ projectId: string;
126
+ created: string;
127
+ modified: string;
128
+ creator?: string;
129
+ author?: string;
130
+ categoryId?: string;
131
+ description?: string;
132
+ previewImageUrl?: string;
133
+ pattern: boolean;
134
+ patternType?: "component" | "composition";
135
+ releaseId?: string;
136
+ composition: {
137
+ type: string;
138
+ parameters?: {
139
+ [key: string]: {
140
+ value?: unknown;
141
+ type: string;
142
+ connectedData?: {
143
+ pointer: string;
144
+ syntax: "jptr";
145
+ failureAction?: "t" | "p" | "c" | "a";
146
+ failureLogLevel?: "e" | "w" | "i";
147
+ failureDefault?: string;
148
+ };
149
+ locales?: {
150
+ [key: string]: unknown;
151
+ };
152
+ conditions?: {
153
+ when: {
154
+ op?: "&" | "|";
155
+ clauses: ({
156
+ rule: string;
157
+ source?: string;
158
+ op: string;
159
+ value: string | string[];
160
+ } | /*elided*/ any)[];
161
+ };
162
+ value: unknown;
163
+ id: number;
164
+ }[];
165
+ localesConditions?: {
166
+ [key: string]: {
167
+ when: {
168
+ op?: "&" | "|";
169
+ clauses: ({
170
+ rule: string;
171
+ source?: string;
172
+ op: string;
173
+ value: string | string[];
174
+ } | /*elided*/ any)[];
175
+ };
176
+ value: unknown;
177
+ id: number;
178
+ }[];
179
+ };
180
+ };
181
+ };
182
+ variant?: string;
183
+ projectMapNodes?: {
184
+ id: string;
185
+ path: string;
186
+ projectMapId: string;
187
+ data?: {
188
+ isSearchHit?: boolean;
189
+ queryStrings?: {
190
+ name: string;
191
+ value?: string;
192
+ helpText?: string;
193
+ }[];
194
+ previewValue?: string;
195
+ };
196
+ locales?: {
197
+ [key: string]: {
198
+ path: string;
199
+ inherited: boolean;
200
+ };
201
+ };
202
+ }[];
203
+ slots?: {
204
+ [key: string]: {
205
+ type: string;
206
+ parameters?: {
207
+ [key: string]: {
208
+ value?: unknown;
209
+ type: string;
210
+ connectedData?: {
211
+ pointer: string;
212
+ syntax: "jptr";
213
+ failureAction?: "t" | "p" | "c" | "a";
214
+ failureLogLevel?: "e" | "w" | "i";
215
+ failureDefault?: string;
216
+ };
217
+ locales?: {
218
+ [key: string]: unknown;
219
+ };
220
+ conditions?: {
221
+ when: {
222
+ op?: "&" | "|";
223
+ clauses: ({
224
+ rule: string;
225
+ source?: string;
226
+ op: string;
227
+ value: string | string[];
228
+ } | /*elided*/ any)[];
229
+ };
230
+ value: unknown;
231
+ id: number;
232
+ }[];
233
+ localesConditions?: {
234
+ [key: string]: {
235
+ when: {
236
+ op?: "&" | "|";
237
+ clauses: ({
238
+ rule: string;
239
+ source?: string;
240
+ op: string;
241
+ value: string | string[];
242
+ } | /*elided*/ any)[];
243
+ };
244
+ value: unknown;
245
+ id: number;
246
+ }[];
247
+ };
248
+ };
249
+ };
250
+ variant?: string;
251
+ slots?: {
252
+ [key: string]: /*elided*/ any[];
253
+ };
254
+ _id?: string;
255
+ _pattern?: string;
256
+ _dataResources?: {
257
+ [key: string]: {
258
+ type: string;
259
+ isPatternParameter?: boolean;
260
+ ignorePatternParameterDefault?: boolean;
261
+ optionalPatternParameter?: boolean;
262
+ variables?: {
263
+ [key: string]: string;
264
+ };
265
+ };
266
+ };
267
+ _patternDataResources?: {
268
+ [key: string]: {
269
+ type: string;
270
+ isPatternParameter?: boolean;
271
+ ignorePatternParameterDefault?: boolean;
272
+ optionalPatternParameter?: boolean;
273
+ variables?: {
274
+ [key: string]: string;
275
+ };
276
+ };
277
+ };
278
+ _patternError?: "NOTFOUND" | "CYCLIC";
279
+ _overrides?: {
280
+ [key: string]: {
281
+ parameters?: {
282
+ [key: string]: {
283
+ value?: unknown;
284
+ type: string;
285
+ connectedData?: {
286
+ pointer: string;
287
+ syntax: "jptr";
288
+ failureAction?: "t" | "p" | "c" | "a";
289
+ failureLogLevel?: "e" | "w" | "i";
290
+ failureDefault?: string;
291
+ };
292
+ locales?: {
293
+ [key: string]: unknown;
294
+ };
295
+ conditions?: {
296
+ when: {
297
+ op?: "&" | "|";
298
+ clauses: ({
299
+ rule: string;
300
+ source?: string;
301
+ op: string;
302
+ value: string | string[];
303
+ } | /*elided*/ any)[];
304
+ };
305
+ value: unknown;
306
+ id: number;
307
+ }[];
308
+ localesConditions?: {
309
+ [key: string]: {
310
+ when: {
311
+ op?: "&" | "|";
312
+ clauses: ({
313
+ rule: string;
314
+ source?: string;
315
+ op: string;
316
+ value: string | string[];
317
+ } | /*elided*/ any)[];
318
+ };
319
+ value: unknown;
320
+ id: number;
321
+ }[];
322
+ };
323
+ };
324
+ };
325
+ slots?: {
326
+ [key: string]: /*elided*/ any[];
327
+ };
328
+ variant?: string;
329
+ dataResources?: {
330
+ [key: string]: {
331
+ type: string;
332
+ isPatternParameter?: boolean;
333
+ ignorePatternParameterDefault?: boolean;
334
+ optionalPatternParameter?: boolean;
335
+ variables?: {
336
+ [key: string]: string;
337
+ };
338
+ };
339
+ };
340
+ };
341
+ };
342
+ _patternOverrides?: {
343
+ [key: string]: {
344
+ parameters?: {
345
+ [key: string]: {
346
+ value?: unknown;
347
+ type: string;
348
+ connectedData?: {
349
+ pointer: string;
350
+ syntax: "jptr";
351
+ failureAction?: "t" | "p" | "c" | "a";
352
+ failureLogLevel?: "e" | "w" | "i";
353
+ failureDefault?: string;
354
+ };
355
+ locales?: {
356
+ [key: string]: unknown;
357
+ };
358
+ conditions?: {
359
+ when: {
360
+ op?: "&" | "|";
361
+ clauses: ({
362
+ rule: string;
363
+ source?: string;
364
+ op: string;
365
+ value: string | string[];
366
+ } | /*elided*/ any)[];
367
+ };
368
+ value: unknown;
369
+ id: number;
370
+ }[];
371
+ localesConditions?: {
372
+ [key: string]: {
373
+ when: {
374
+ op?: "&" | "|";
375
+ clauses: ({
376
+ rule: string;
377
+ source?: string;
378
+ op: string;
379
+ value: string | string[];
380
+ } | /*elided*/ any)[];
381
+ };
382
+ value: unknown;
383
+ id: number;
384
+ }[];
385
+ };
386
+ };
387
+ };
388
+ slots?: {
389
+ [key: string]: /*elided*/ any[];
390
+ };
391
+ variant?: string;
392
+ dataResources?: {
393
+ [key: string]: {
394
+ type: string;
395
+ isPatternParameter?: boolean;
396
+ ignorePatternParameterDefault?: boolean;
397
+ optionalPatternParameter?: boolean;
398
+ variables?: {
399
+ [key: string]: string;
400
+ };
401
+ };
402
+ };
403
+ };
404
+ };
405
+ _overridability?: {
406
+ parameters?: {
407
+ [key: string]: "yes" | "no";
408
+ };
409
+ variants?: boolean;
410
+ hideLockedParameters?: boolean;
411
+ };
412
+ _locales?: string[];
413
+ }[];
414
+ };
415
+ _id: string;
416
+ _slug?: string | null;
417
+ _name: string;
418
+ _author?: string;
419
+ _authorSubject?: string;
420
+ _creator?: string;
421
+ _creatorSubject?: string;
422
+ _pattern?: string;
423
+ _patternDataResources?: {
424
+ [key: string]: {
425
+ type: string;
426
+ isPatternParameter?: boolean;
427
+ ignorePatternParameterDefault?: boolean;
428
+ optionalPatternParameter?: boolean;
429
+ variables?: {
430
+ [key: string]: string;
431
+ };
432
+ };
433
+ };
434
+ _dataResources?: {
435
+ [key: string]: {
436
+ type: string;
437
+ isPatternParameter?: boolean;
438
+ ignorePatternParameterDefault?: boolean;
439
+ optionalPatternParameter?: boolean;
440
+ variables?: {
441
+ [key: string]: string;
442
+ };
443
+ };
444
+ };
445
+ _patternError?: "NOTFOUND" | "CYCLIC";
446
+ _overrides?: {
447
+ [key: string]: {
448
+ parameters?: {
449
+ [key: string]: {
450
+ value?: unknown;
451
+ type: string;
452
+ connectedData?: {
453
+ pointer: string;
454
+ syntax: "jptr";
455
+ failureAction?: "t" | "p" | "c" | "a";
456
+ failureLogLevel?: "e" | "w" | "i";
457
+ failureDefault?: string;
458
+ };
459
+ locales?: {
460
+ [key: string]: unknown;
461
+ };
462
+ conditions?: {
463
+ when: {
464
+ op?: "&" | "|";
465
+ clauses: ({
466
+ rule: string;
467
+ source?: string;
468
+ op: string;
469
+ value: string | string[];
470
+ } | /*elided*/ any)[];
471
+ };
472
+ value: unknown;
473
+ id: number;
474
+ }[];
475
+ localesConditions?: {
476
+ [key: string]: {
477
+ when: {
478
+ op?: "&" | "|";
479
+ clauses: ({
480
+ rule: string;
481
+ source?: string;
482
+ op: string;
483
+ value: string | string[];
484
+ } | /*elided*/ any)[];
485
+ };
486
+ value: unknown;
487
+ id: number;
488
+ }[];
489
+ };
490
+ };
491
+ };
492
+ slots?: {
493
+ [key: string]: {
494
+ type: string;
495
+ parameters?: {
496
+ [key: string]: {
497
+ value?: unknown;
498
+ type: string;
499
+ connectedData?: {
500
+ pointer: string;
501
+ syntax: "jptr";
502
+ failureAction?: "t" | "p" | "c" | "a";
503
+ failureLogLevel?: "e" | "w" | "i";
504
+ failureDefault?: string;
505
+ };
506
+ locales?: {
507
+ [key: string]: unknown;
508
+ };
509
+ conditions?: {
510
+ when: {
511
+ op?: "&" | "|";
512
+ clauses: ({
513
+ rule: string;
514
+ source?: string;
515
+ op: string;
516
+ value: string | string[];
517
+ } | /*elided*/ any)[];
518
+ };
519
+ value: unknown;
520
+ id: number;
521
+ }[];
522
+ localesConditions?: {
523
+ [key: string]: {
524
+ when: {
525
+ op?: "&" | "|";
526
+ clauses: ({
527
+ rule: string;
528
+ source?: string;
529
+ op: string;
530
+ value: string | string[];
531
+ } | /*elided*/ any)[];
532
+ };
533
+ value: unknown;
534
+ id: number;
535
+ }[];
536
+ };
537
+ };
538
+ };
539
+ variant?: string;
540
+ slots?: {
541
+ [key: string]: /*elided*/ any[];
542
+ };
543
+ _id?: string;
544
+ _pattern?: string;
545
+ _dataResources?: {
546
+ [key: string]: {
547
+ type: string;
548
+ isPatternParameter?: boolean;
549
+ ignorePatternParameterDefault?: boolean;
550
+ optionalPatternParameter?: boolean;
551
+ variables?: {
552
+ [key: string]: string;
553
+ };
554
+ };
555
+ };
556
+ _patternDataResources?: {
557
+ [key: string]: {
558
+ type: string;
559
+ isPatternParameter?: boolean;
560
+ ignorePatternParameterDefault?: boolean;
561
+ optionalPatternParameter?: boolean;
562
+ variables?: {
563
+ [key: string]: string;
564
+ };
565
+ };
566
+ };
567
+ _patternError?: "NOTFOUND" | "CYCLIC";
568
+ _overrides?: {
569
+ [key: string]: /*elided*/ any;
570
+ };
571
+ _patternOverrides?: {
572
+ [key: string]: /*elided*/ any;
573
+ };
574
+ _overridability?: {
575
+ parameters?: {
576
+ [key: string]: "yes" | "no";
577
+ };
578
+ variants?: boolean;
579
+ hideLockedParameters?: boolean;
580
+ };
581
+ _locales?: string[];
582
+ }[];
583
+ };
584
+ variant?: string;
585
+ dataResources?: {
586
+ [key: string]: {
587
+ type: string;
588
+ isPatternParameter?: boolean;
589
+ ignorePatternParameterDefault?: boolean;
590
+ optionalPatternParameter?: boolean;
591
+ variables?: {
592
+ [key: string]: string;
593
+ };
594
+ };
595
+ };
596
+ };
597
+ };
598
+ _patternOverrides?: {
599
+ [key: string]: {
600
+ parameters?: {
601
+ [key: string]: {
602
+ value?: unknown;
603
+ type: string;
604
+ connectedData?: {
605
+ pointer: string;
606
+ syntax: "jptr";
607
+ failureAction?: "t" | "p" | "c" | "a";
608
+ failureLogLevel?: "e" | "w" | "i";
609
+ failureDefault?: string;
610
+ };
611
+ locales?: {
612
+ [key: string]: unknown;
613
+ };
614
+ conditions?: {
615
+ when: {
616
+ op?: "&" | "|";
617
+ clauses: ({
618
+ rule: string;
619
+ source?: string;
620
+ op: string;
621
+ value: string | string[];
622
+ } | /*elided*/ any)[];
623
+ };
624
+ value: unknown;
625
+ id: number;
626
+ }[];
627
+ localesConditions?: {
628
+ [key: string]: {
629
+ when: {
630
+ op?: "&" | "|";
631
+ clauses: ({
632
+ rule: string;
633
+ source?: string;
634
+ op: string;
635
+ value: string | string[];
636
+ } | /*elided*/ any)[];
637
+ };
638
+ value: unknown;
639
+ id: number;
640
+ }[];
641
+ };
642
+ };
643
+ };
644
+ slots?: {
645
+ [key: string]: {
646
+ type: string;
647
+ parameters?: {
648
+ [key: string]: {
649
+ value?: unknown;
650
+ type: string;
651
+ connectedData?: {
652
+ pointer: string;
653
+ syntax: "jptr";
654
+ failureAction?: "t" | "p" | "c" | "a";
655
+ failureLogLevel?: "e" | "w" | "i";
656
+ failureDefault?: string;
657
+ };
658
+ locales?: {
659
+ [key: string]: unknown;
660
+ };
661
+ conditions?: {
662
+ when: {
663
+ op?: "&" | "|";
664
+ clauses: ({
665
+ rule: string;
666
+ source?: string;
667
+ op: string;
668
+ value: string | string[];
669
+ } | /*elided*/ any)[];
670
+ };
671
+ value: unknown;
672
+ id: number;
673
+ }[];
674
+ localesConditions?: {
675
+ [key: string]: {
676
+ when: {
677
+ op?: "&" | "|";
678
+ clauses: ({
679
+ rule: string;
680
+ source?: string;
681
+ op: string;
682
+ value: string | string[];
683
+ } | /*elided*/ any)[];
684
+ };
685
+ value: unknown;
686
+ id: number;
687
+ }[];
688
+ };
689
+ };
690
+ };
691
+ variant?: string;
692
+ slots?: {
693
+ [key: string]: /*elided*/ any[];
694
+ };
695
+ _id?: string;
696
+ _pattern?: string;
697
+ _dataResources?: {
698
+ [key: string]: {
699
+ type: string;
700
+ isPatternParameter?: boolean;
701
+ ignorePatternParameterDefault?: boolean;
702
+ optionalPatternParameter?: boolean;
703
+ variables?: {
704
+ [key: string]: string;
705
+ };
706
+ };
707
+ };
708
+ _patternDataResources?: {
709
+ [key: string]: {
710
+ type: string;
711
+ isPatternParameter?: boolean;
712
+ ignorePatternParameterDefault?: boolean;
713
+ optionalPatternParameter?: boolean;
714
+ variables?: {
715
+ [key: string]: string;
716
+ };
717
+ };
718
+ };
719
+ _patternError?: "NOTFOUND" | "CYCLIC";
720
+ _overrides?: {
721
+ [key: string]: /*elided*/ any;
722
+ };
723
+ _patternOverrides?: {
724
+ [key: string]: /*elided*/ any;
725
+ };
726
+ _overridability?: {
727
+ parameters?: {
728
+ [key: string]: "yes" | "no";
729
+ };
730
+ variants?: boolean;
731
+ hideLockedParameters?: boolean;
732
+ };
733
+ _locales?: string[];
734
+ }[];
735
+ };
736
+ variant?: string;
737
+ dataResources?: {
738
+ [key: string]: {
739
+ type: string;
740
+ isPatternParameter?: boolean;
741
+ ignorePatternParameterDefault?: boolean;
742
+ optionalPatternParameter?: boolean;
743
+ variables?: {
744
+ [key: string]: string;
745
+ };
746
+ };
747
+ };
748
+ };
749
+ };
750
+ _overridability?: {
751
+ parameters?: {
752
+ [key: string]: "yes" | "no";
753
+ };
754
+ variants?: boolean;
755
+ hideLockedParameters?: boolean;
756
+ };
757
+ _locales?: string[];
758
+ };
759
+ workflowId?: string;
760
+ workflowStageId?: string;
761
+ workflowDefinition?: {
762
+ id: string;
763
+ name: string;
764
+ initialStage: string;
765
+ stages: {
766
+ [key: string]: {
767
+ name: string;
768
+ permissions: {
769
+ [key: string]: {
770
+ write?: boolean;
771
+ publish?: boolean;
772
+ };
773
+ };
774
+ autoPublish?: boolean;
775
+ requireValidity?: boolean;
776
+ transitions: {
777
+ to: string;
778
+ name: string;
779
+ permissions: {
780
+ [key: string]: {
781
+ execute?: boolean;
782
+ };
783
+ };
784
+ }[];
785
+ icon?: string;
786
+ order?: number;
787
+ };
788
+ };
789
+ modified?: string;
790
+ created?: string;
791
+ createdBy?: string;
792
+ modifiedBy?: string;
793
+ };
794
+ editionId?: string;
795
+ editionName?: string;
796
+ editionPriority?: number;
797
+ }) | null | undefined, ({
798
+ wholeResponseCacheDiagnostics?: {
799
+ info: string;
800
+ cacheTtl: number;
801
+ cachedAt: string;
802
+ edgeLocation?: string;
803
+ requestId: string;
804
+ };
805
+ diagnostics?: {
806
+ edgeLocation?: string;
807
+ originFetch?: {
808
+ duration: number;
809
+ cacheHit: boolean;
810
+ isValid: boolean;
811
+ sourceCache?: "edge-cdn-cache" | "long-term-cache" | "api-cache";
812
+ cacheLocation?: string;
813
+ requestId?: string;
814
+ };
815
+ configRetrieval?: {
816
+ duration: number;
817
+ dataTypeCount: number;
818
+ };
819
+ } & {
820
+ data?: {
821
+ componentPath: string;
822
+ dataType: string;
823
+ dataName: string;
824
+ performance: {
825
+ cacheHit: boolean;
826
+ total: number;
827
+ retryCount: number;
828
+ retryDelay: number;
829
+ sourceCache?: string;
830
+ statusCodes: number[];
831
+ };
832
+ data: unknown;
833
+ }[];
834
+ };
835
+ errors?: {
836
+ componentId?: string;
837
+ componentPath?: string;
838
+ componentType?: string;
839
+ message: string;
840
+ type: string;
841
+ parameterName?: string;
842
+ expression?: {
843
+ pointer: string;
844
+ syntax: "jptr";
845
+ failureAction?: "t" | "p" | "c" | "a";
846
+ failureLogLevel?: "e" | "w" | "i";
847
+ failureDefault?: string;
848
+ };
849
+ dataName?: string;
850
+ dataType?: string;
851
+ inputName?: string;
852
+ code?: string;
853
+ locale?: string;
854
+ conditionIndex?: number;
855
+ clauseIndex?: number;
856
+ }[];
857
+ warnings?: {
858
+ componentId?: string;
859
+ componentPath?: string;
860
+ componentType?: string;
861
+ message: string;
862
+ type: string;
863
+ parameterName?: string;
864
+ expression?: {
865
+ pointer: string;
866
+ syntax: "jptr";
867
+ failureAction?: "t" | "p" | "c" | "a";
868
+ failureLogLevel?: "e" | "w" | "i";
869
+ failureDefault?: string;
870
+ };
871
+ dataName?: string;
872
+ dataType?: string;
873
+ inputName?: string;
874
+ code?: string;
875
+ locale?: string;
876
+ conditionIndex?: number;
877
+ clauseIndex?: number;
878
+ }[];
879
+ infos?: {
880
+ componentId?: string;
881
+ componentPath?: string;
882
+ componentType?: string;
883
+ message: string;
884
+ type: string;
885
+ parameterName?: string;
886
+ expression?: {
887
+ pointer: string;
888
+ syntax: "jptr";
889
+ failureAction?: "t" | "p" | "c" | "a";
890
+ failureLogLevel?: "e" | "w" | "i";
891
+ failureDefault?: string;
892
+ };
893
+ dataName?: string;
894
+ dataType?: string;
895
+ inputName?: string;
896
+ code?: string;
897
+ locale?: string;
898
+ conditionIndex?: number;
899
+ clauseIndex?: number;
900
+ }[];
901
+ } & {
902
+ state: number;
903
+ uiStatus?: "Draft" | "Modified" | "Published" | "Orphan" | "Previous" | "Unknown";
904
+ projectId: string;
905
+ created: string;
906
+ modified: string;
907
+ creator?: string;
908
+ author?: string;
909
+ categoryId?: string;
910
+ description?: string;
911
+ previewImageUrl?: string;
912
+ pattern: boolean;
913
+ patternType?: "component" | "composition";
914
+ releaseId?: string;
915
+ composition: {
916
+ type: string;
917
+ parameters?: {
918
+ [key: string]: {
919
+ value?: unknown;
920
+ type: string;
921
+ connectedData?: {
922
+ pointer: string;
923
+ syntax: "jptr";
924
+ failureAction?: "t" | "p" | "c" | "a";
925
+ failureLogLevel?: "e" | "w" | "i";
926
+ failureDefault?: string;
927
+ };
928
+ locales?: {
929
+ [key: string]: unknown;
930
+ };
931
+ conditions?: {
932
+ when: {
933
+ op?: "&" | "|";
934
+ clauses: ({
935
+ rule: string;
936
+ source?: string;
937
+ op: string;
938
+ value: string | string[];
939
+ } | /*elided*/ any)[];
940
+ };
941
+ value: unknown;
942
+ id: number;
943
+ }[];
944
+ localesConditions?: {
945
+ [key: string]: {
946
+ when: {
947
+ op?: "&" | "|";
948
+ clauses: ({
949
+ rule: string;
950
+ source?: string;
951
+ op: string;
952
+ value: string | string[];
953
+ } | /*elided*/ any)[];
954
+ };
955
+ value: unknown;
956
+ id: number;
957
+ }[];
958
+ };
959
+ };
960
+ };
961
+ variant?: string;
962
+ projectMapNodes?: {
963
+ id: string;
964
+ path: string;
965
+ projectMapId: string;
966
+ data?: {
967
+ isSearchHit?: boolean;
968
+ queryStrings?: {
969
+ name: string;
970
+ value?: string;
971
+ helpText?: string;
972
+ }[];
973
+ previewValue?: string;
974
+ };
975
+ locales?: {
976
+ [key: string]: {
977
+ path: string;
978
+ inherited: boolean;
979
+ };
980
+ };
981
+ }[];
982
+ slots?: {
983
+ [key: string]: {
984
+ type: string;
985
+ parameters?: {
986
+ [key: string]: {
987
+ value?: unknown;
988
+ type: string;
989
+ connectedData?: {
990
+ pointer: string;
991
+ syntax: "jptr";
992
+ failureAction?: "t" | "p" | "c" | "a";
993
+ failureLogLevel?: "e" | "w" | "i";
994
+ failureDefault?: string;
995
+ };
996
+ locales?: {
997
+ [key: string]: unknown;
998
+ };
999
+ conditions?: {
1000
+ when: {
1001
+ op?: "&" | "|";
1002
+ clauses: ({
1003
+ rule: string;
1004
+ source?: string;
1005
+ op: string;
1006
+ value: string | string[];
1007
+ } | /*elided*/ any)[];
1008
+ };
1009
+ value: unknown;
1010
+ id: number;
1011
+ }[];
1012
+ localesConditions?: {
1013
+ [key: string]: {
1014
+ when: {
1015
+ op?: "&" | "|";
1016
+ clauses: ({
1017
+ rule: string;
1018
+ source?: string;
1019
+ op: string;
1020
+ value: string | string[];
1021
+ } | /*elided*/ any)[];
1022
+ };
1023
+ value: unknown;
1024
+ id: number;
1025
+ }[];
1026
+ };
1027
+ };
1028
+ };
1029
+ variant?: string;
1030
+ slots?: {
1031
+ [key: string]: /*elided*/ any[];
1032
+ };
1033
+ _id?: string;
1034
+ _pattern?: string;
1035
+ _dataResources?: {
1036
+ [key: string]: {
1037
+ type: string;
1038
+ isPatternParameter?: boolean;
1039
+ ignorePatternParameterDefault?: boolean;
1040
+ optionalPatternParameter?: boolean;
1041
+ variables?: {
1042
+ [key: string]: string;
1043
+ };
1044
+ };
1045
+ };
1046
+ _patternDataResources?: {
1047
+ [key: string]: {
1048
+ type: string;
1049
+ isPatternParameter?: boolean;
1050
+ ignorePatternParameterDefault?: boolean;
1051
+ optionalPatternParameter?: boolean;
1052
+ variables?: {
1053
+ [key: string]: string;
1054
+ };
1055
+ };
1056
+ };
1057
+ _patternError?: "NOTFOUND" | "CYCLIC";
1058
+ _overrides?: {
1059
+ [key: string]: {
1060
+ parameters?: {
1061
+ [key: string]: {
1062
+ value?: unknown;
1063
+ type: string;
1064
+ connectedData?: {
1065
+ pointer: string;
1066
+ syntax: "jptr";
1067
+ failureAction?: "t" | "p" | "c" | "a";
1068
+ failureLogLevel?: "e" | "w" | "i";
1069
+ failureDefault?: string;
1070
+ };
1071
+ locales?: {
1072
+ [key: string]: unknown;
1073
+ };
1074
+ conditions?: {
1075
+ when: {
1076
+ op?: "&" | "|";
1077
+ clauses: ({
1078
+ rule: string;
1079
+ source?: string;
1080
+ op: string;
1081
+ value: string | string[];
1082
+ } | /*elided*/ any)[];
1083
+ };
1084
+ value: unknown;
1085
+ id: number;
1086
+ }[];
1087
+ localesConditions?: {
1088
+ [key: string]: {
1089
+ when: {
1090
+ op?: "&" | "|";
1091
+ clauses: ({
1092
+ rule: string;
1093
+ source?: string;
1094
+ op: string;
1095
+ value: string | string[];
1096
+ } | /*elided*/ any)[];
1097
+ };
1098
+ value: unknown;
1099
+ id: number;
1100
+ }[];
1101
+ };
1102
+ };
1103
+ };
1104
+ slots?: {
1105
+ [key: string]: /*elided*/ any[];
1106
+ };
1107
+ variant?: string;
1108
+ dataResources?: {
1109
+ [key: string]: {
1110
+ type: string;
1111
+ isPatternParameter?: boolean;
1112
+ ignorePatternParameterDefault?: boolean;
1113
+ optionalPatternParameter?: boolean;
1114
+ variables?: {
1115
+ [key: string]: string;
1116
+ };
1117
+ };
1118
+ };
1119
+ };
1120
+ };
1121
+ _patternOverrides?: {
1122
+ [key: string]: {
1123
+ parameters?: {
1124
+ [key: string]: {
1125
+ value?: unknown;
1126
+ type: string;
1127
+ connectedData?: {
1128
+ pointer: string;
1129
+ syntax: "jptr";
1130
+ failureAction?: "t" | "p" | "c" | "a";
1131
+ failureLogLevel?: "e" | "w" | "i";
1132
+ failureDefault?: string;
1133
+ };
1134
+ locales?: {
1135
+ [key: string]: unknown;
1136
+ };
1137
+ conditions?: {
1138
+ when: {
1139
+ op?: "&" | "|";
1140
+ clauses: ({
1141
+ rule: string;
1142
+ source?: string;
1143
+ op: string;
1144
+ value: string | string[];
1145
+ } | /*elided*/ any)[];
1146
+ };
1147
+ value: unknown;
1148
+ id: number;
1149
+ }[];
1150
+ localesConditions?: {
1151
+ [key: string]: {
1152
+ when: {
1153
+ op?: "&" | "|";
1154
+ clauses: ({
1155
+ rule: string;
1156
+ source?: string;
1157
+ op: string;
1158
+ value: string | string[];
1159
+ } | /*elided*/ any)[];
1160
+ };
1161
+ value: unknown;
1162
+ id: number;
1163
+ }[];
1164
+ };
1165
+ };
1166
+ };
1167
+ slots?: {
1168
+ [key: string]: /*elided*/ any[];
1169
+ };
1170
+ variant?: string;
1171
+ dataResources?: {
1172
+ [key: string]: {
1173
+ type: string;
1174
+ isPatternParameter?: boolean;
1175
+ ignorePatternParameterDefault?: boolean;
1176
+ optionalPatternParameter?: boolean;
1177
+ variables?: {
1178
+ [key: string]: string;
1179
+ };
1180
+ };
1181
+ };
1182
+ };
1183
+ };
1184
+ _overridability?: {
1185
+ parameters?: {
1186
+ [key: string]: "yes" | "no";
1187
+ };
1188
+ variants?: boolean;
1189
+ hideLockedParameters?: boolean;
1190
+ };
1191
+ _locales?: string[];
1192
+ }[];
1193
+ };
1194
+ _id: string;
1195
+ _slug?: string | null;
1196
+ _name: string;
1197
+ _author?: string;
1198
+ _authorSubject?: string;
1199
+ _creator?: string;
1200
+ _creatorSubject?: string;
1201
+ _pattern?: string;
1202
+ _patternDataResources?: {
1203
+ [key: string]: {
1204
+ type: string;
1205
+ isPatternParameter?: boolean;
1206
+ ignorePatternParameterDefault?: boolean;
1207
+ optionalPatternParameter?: boolean;
1208
+ variables?: {
1209
+ [key: string]: string;
1210
+ };
1211
+ };
1212
+ };
1213
+ _dataResources?: {
1214
+ [key: string]: {
1215
+ type: string;
1216
+ isPatternParameter?: boolean;
1217
+ ignorePatternParameterDefault?: boolean;
1218
+ optionalPatternParameter?: boolean;
1219
+ variables?: {
1220
+ [key: string]: string;
1221
+ };
1222
+ };
1223
+ };
1224
+ _patternError?: "NOTFOUND" | "CYCLIC";
1225
+ _overrides?: {
1226
+ [key: string]: {
1227
+ parameters?: {
1228
+ [key: string]: {
1229
+ value?: unknown;
1230
+ type: string;
1231
+ connectedData?: {
1232
+ pointer: string;
1233
+ syntax: "jptr";
1234
+ failureAction?: "t" | "p" | "c" | "a";
1235
+ failureLogLevel?: "e" | "w" | "i";
1236
+ failureDefault?: string;
1237
+ };
1238
+ locales?: {
1239
+ [key: string]: unknown;
1240
+ };
1241
+ conditions?: {
1242
+ when: {
1243
+ op?: "&" | "|";
1244
+ clauses: ({
1245
+ rule: string;
1246
+ source?: string;
1247
+ op: string;
1248
+ value: string | string[];
1249
+ } | /*elided*/ any)[];
1250
+ };
1251
+ value: unknown;
1252
+ id: number;
1253
+ }[];
1254
+ localesConditions?: {
1255
+ [key: string]: {
1256
+ when: {
1257
+ op?: "&" | "|";
1258
+ clauses: ({
1259
+ rule: string;
1260
+ source?: string;
1261
+ op: string;
1262
+ value: string | string[];
1263
+ } | /*elided*/ any)[];
1264
+ };
1265
+ value: unknown;
1266
+ id: number;
1267
+ }[];
1268
+ };
1269
+ };
1270
+ };
1271
+ slots?: {
1272
+ [key: string]: {
1273
+ type: string;
1274
+ parameters?: {
1275
+ [key: string]: {
1276
+ value?: unknown;
1277
+ type: string;
1278
+ connectedData?: {
1279
+ pointer: string;
1280
+ syntax: "jptr";
1281
+ failureAction?: "t" | "p" | "c" | "a";
1282
+ failureLogLevel?: "e" | "w" | "i";
1283
+ failureDefault?: string;
1284
+ };
1285
+ locales?: {
1286
+ [key: string]: unknown;
1287
+ };
1288
+ conditions?: {
1289
+ when: {
1290
+ op?: "&" | "|";
1291
+ clauses: ({
1292
+ rule: string;
1293
+ source?: string;
1294
+ op: string;
1295
+ value: string | string[];
1296
+ } | /*elided*/ any)[];
1297
+ };
1298
+ value: unknown;
1299
+ id: number;
1300
+ }[];
1301
+ localesConditions?: {
1302
+ [key: string]: {
1303
+ when: {
1304
+ op?: "&" | "|";
1305
+ clauses: ({
1306
+ rule: string;
1307
+ source?: string;
1308
+ op: string;
1309
+ value: string | string[];
1310
+ } | /*elided*/ any)[];
1311
+ };
1312
+ value: unknown;
1313
+ id: number;
1314
+ }[];
1315
+ };
1316
+ };
1317
+ };
1318
+ variant?: string;
1319
+ slots?: {
1320
+ [key: string]: /*elided*/ any[];
1321
+ };
1322
+ _id?: string;
1323
+ _pattern?: string;
1324
+ _dataResources?: {
1325
+ [key: string]: {
1326
+ type: string;
1327
+ isPatternParameter?: boolean;
1328
+ ignorePatternParameterDefault?: boolean;
1329
+ optionalPatternParameter?: boolean;
1330
+ variables?: {
1331
+ [key: string]: string;
1332
+ };
1333
+ };
1334
+ };
1335
+ _patternDataResources?: {
1336
+ [key: string]: {
1337
+ type: string;
1338
+ isPatternParameter?: boolean;
1339
+ ignorePatternParameterDefault?: boolean;
1340
+ optionalPatternParameter?: boolean;
1341
+ variables?: {
1342
+ [key: string]: string;
1343
+ };
1344
+ };
1345
+ };
1346
+ _patternError?: "NOTFOUND" | "CYCLIC";
1347
+ _overrides?: {
1348
+ [key: string]: /*elided*/ any;
1349
+ };
1350
+ _patternOverrides?: {
1351
+ [key: string]: /*elided*/ any;
1352
+ };
1353
+ _overridability?: {
1354
+ parameters?: {
1355
+ [key: string]: "yes" | "no";
1356
+ };
1357
+ variants?: boolean;
1358
+ hideLockedParameters?: boolean;
1359
+ };
1360
+ _locales?: string[];
1361
+ }[];
1362
+ };
1363
+ variant?: string;
1364
+ dataResources?: {
1365
+ [key: string]: {
1366
+ type: string;
1367
+ isPatternParameter?: boolean;
1368
+ ignorePatternParameterDefault?: boolean;
1369
+ optionalPatternParameter?: boolean;
1370
+ variables?: {
1371
+ [key: string]: string;
1372
+ };
1373
+ };
1374
+ };
1375
+ };
1376
+ };
1377
+ _patternOverrides?: {
1378
+ [key: string]: {
1379
+ parameters?: {
1380
+ [key: string]: {
1381
+ value?: unknown;
1382
+ type: string;
1383
+ connectedData?: {
1384
+ pointer: string;
1385
+ syntax: "jptr";
1386
+ failureAction?: "t" | "p" | "c" | "a";
1387
+ failureLogLevel?: "e" | "w" | "i";
1388
+ failureDefault?: string;
1389
+ };
1390
+ locales?: {
1391
+ [key: string]: unknown;
1392
+ };
1393
+ conditions?: {
1394
+ when: {
1395
+ op?: "&" | "|";
1396
+ clauses: ({
1397
+ rule: string;
1398
+ source?: string;
1399
+ op: string;
1400
+ value: string | string[];
1401
+ } | /*elided*/ any)[];
1402
+ };
1403
+ value: unknown;
1404
+ id: number;
1405
+ }[];
1406
+ localesConditions?: {
1407
+ [key: string]: {
1408
+ when: {
1409
+ op?: "&" | "|";
1410
+ clauses: ({
1411
+ rule: string;
1412
+ source?: string;
1413
+ op: string;
1414
+ value: string | string[];
1415
+ } | /*elided*/ any)[];
1416
+ };
1417
+ value: unknown;
1418
+ id: number;
1419
+ }[];
1420
+ };
1421
+ };
1422
+ };
1423
+ slots?: {
1424
+ [key: string]: {
1425
+ type: string;
1426
+ parameters?: {
1427
+ [key: string]: {
1428
+ value?: unknown;
1429
+ type: string;
1430
+ connectedData?: {
1431
+ pointer: string;
1432
+ syntax: "jptr";
1433
+ failureAction?: "t" | "p" | "c" | "a";
1434
+ failureLogLevel?: "e" | "w" | "i";
1435
+ failureDefault?: string;
1436
+ };
1437
+ locales?: {
1438
+ [key: string]: unknown;
1439
+ };
1440
+ conditions?: {
1441
+ when: {
1442
+ op?: "&" | "|";
1443
+ clauses: ({
1444
+ rule: string;
1445
+ source?: string;
1446
+ op: string;
1447
+ value: string | string[];
1448
+ } | /*elided*/ any)[];
1449
+ };
1450
+ value: unknown;
1451
+ id: number;
1452
+ }[];
1453
+ localesConditions?: {
1454
+ [key: string]: {
1455
+ when: {
1456
+ op?: "&" | "|";
1457
+ clauses: ({
1458
+ rule: string;
1459
+ source?: string;
1460
+ op: string;
1461
+ value: string | string[];
1462
+ } | /*elided*/ any)[];
1463
+ };
1464
+ value: unknown;
1465
+ id: number;
1466
+ }[];
1467
+ };
1468
+ };
1469
+ };
1470
+ variant?: string;
1471
+ slots?: {
1472
+ [key: string]: /*elided*/ any[];
1473
+ };
1474
+ _id?: string;
1475
+ _pattern?: string;
1476
+ _dataResources?: {
1477
+ [key: string]: {
1478
+ type: string;
1479
+ isPatternParameter?: boolean;
1480
+ ignorePatternParameterDefault?: boolean;
1481
+ optionalPatternParameter?: boolean;
1482
+ variables?: {
1483
+ [key: string]: string;
1484
+ };
1485
+ };
1486
+ };
1487
+ _patternDataResources?: {
1488
+ [key: string]: {
1489
+ type: string;
1490
+ isPatternParameter?: boolean;
1491
+ ignorePatternParameterDefault?: boolean;
1492
+ optionalPatternParameter?: boolean;
1493
+ variables?: {
1494
+ [key: string]: string;
1495
+ };
1496
+ };
1497
+ };
1498
+ _patternError?: "NOTFOUND" | "CYCLIC";
1499
+ _overrides?: {
1500
+ [key: string]: /*elided*/ any;
1501
+ };
1502
+ _patternOverrides?: {
1503
+ [key: string]: /*elided*/ any;
1504
+ };
1505
+ _overridability?: {
1506
+ parameters?: {
1507
+ [key: string]: "yes" | "no";
1508
+ };
1509
+ variants?: boolean;
1510
+ hideLockedParameters?: boolean;
1511
+ };
1512
+ _locales?: string[];
1513
+ }[];
1514
+ };
1515
+ variant?: string;
1516
+ dataResources?: {
1517
+ [key: string]: {
1518
+ type: string;
1519
+ isPatternParameter?: boolean;
1520
+ ignorePatternParameterDefault?: boolean;
1521
+ optionalPatternParameter?: boolean;
1522
+ variables?: {
1523
+ [key: string]: string;
1524
+ };
1525
+ };
1526
+ };
1527
+ };
1528
+ };
1529
+ _overridability?: {
1530
+ parameters?: {
1531
+ [key: string]: "yes" | "no";
1532
+ };
1533
+ variants?: boolean;
1534
+ hideLockedParameters?: boolean;
1535
+ };
1536
+ _locales?: string[];
1537
+ };
1538
+ workflowId?: string;
1539
+ workflowStageId?: string;
1540
+ workflowDefinition?: {
1541
+ id: string;
1542
+ name: string;
1543
+ initialStage: string;
1544
+ stages: {
1545
+ [key: string]: {
1546
+ name: string;
1547
+ permissions: {
1548
+ [key: string]: {
1549
+ write?: boolean;
1550
+ publish?: boolean;
1551
+ };
1552
+ };
1553
+ autoPublish?: boolean;
1554
+ requireValidity?: boolean;
1555
+ transitions: {
1556
+ to: string;
1557
+ name: string;
1558
+ permissions: {
1559
+ [key: string]: {
1560
+ execute?: boolean;
1561
+ };
1562
+ };
1563
+ }[];
1564
+ icon?: string;
1565
+ order?: number;
1566
+ };
1567
+ };
1568
+ modified?: string;
1569
+ created?: string;
1570
+ createdBy?: string;
1571
+ modifiedBy?: string;
1572
+ };
1573
+ editionId?: string;
1574
+ editionName?: string;
1575
+ editionPriority?: number;
1576
+ }) | null | undefined>;
1577
+ pending: Ref<boolean, boolean>;
1578
+ error: Ref<import("#app").NuxtError<unknown> | null, import("#app").NuxtError<unknown> | null>;
1579
+ }>;
1580
+ }> & import("#app").ObjectPlugin<{
1581
+ uniformIsSetup: boolean;
1582
+ useUniformContext: () => import("@uniformdev/context-vue").UniformContextProps;
1583
+ preview: PreviewState | undefined;
1584
+ uniformCanvasClient: CanvasClient;
1585
+ uniformContext: Context;
1586
+ useComposition: (options: Pick<CompositionGetParameters, "compositionId" | "slug" | "state">) => Promise<{
1587
+ data: Ref<({
1588
+ wholeResponseCacheDiagnostics?: {
1589
+ info: string;
1590
+ cacheTtl: number;
1591
+ cachedAt: string;
1592
+ edgeLocation?: string;
1593
+ requestId: string;
1594
+ };
1595
+ diagnostics?: {
1596
+ edgeLocation?: string;
1597
+ originFetch?: {
1598
+ duration: number;
1599
+ cacheHit: boolean;
1600
+ isValid: boolean;
1601
+ sourceCache?: "edge-cdn-cache" | "long-term-cache" | "api-cache";
1602
+ cacheLocation?: string;
1603
+ requestId?: string;
1604
+ };
1605
+ configRetrieval?: {
1606
+ duration: number;
1607
+ dataTypeCount: number;
1608
+ };
1609
+ } & {
1610
+ data?: {
1611
+ componentPath: string;
1612
+ dataType: string;
1613
+ dataName: string;
1614
+ performance: {
1615
+ cacheHit: boolean;
1616
+ total: number;
1617
+ retryCount: number;
1618
+ retryDelay: number;
1619
+ sourceCache?: string;
1620
+ statusCodes: number[];
1621
+ };
1622
+ data: unknown;
1623
+ }[];
1624
+ };
1625
+ errors?: {
1626
+ componentId?: string;
1627
+ componentPath?: string;
1628
+ componentType?: string;
1629
+ message: string;
1630
+ type: string;
1631
+ parameterName?: string;
1632
+ expression?: {
1633
+ pointer: string;
1634
+ syntax: "jptr";
1635
+ failureAction?: "t" | "p" | "c" | "a";
1636
+ failureLogLevel?: "e" | "w" | "i";
1637
+ failureDefault?: string;
1638
+ };
1639
+ dataName?: string;
1640
+ dataType?: string;
1641
+ inputName?: string;
1642
+ code?: string;
1643
+ locale?: string;
1644
+ conditionIndex?: number;
1645
+ clauseIndex?: number;
1646
+ }[];
1647
+ warnings?: {
1648
+ componentId?: string;
1649
+ componentPath?: string;
1650
+ componentType?: string;
1651
+ message: string;
1652
+ type: string;
1653
+ parameterName?: string;
1654
+ expression?: {
1655
+ pointer: string;
1656
+ syntax: "jptr";
1657
+ failureAction?: "t" | "p" | "c" | "a";
1658
+ failureLogLevel?: "e" | "w" | "i";
1659
+ failureDefault?: string;
1660
+ };
1661
+ dataName?: string;
1662
+ dataType?: string;
1663
+ inputName?: string;
1664
+ code?: string;
1665
+ locale?: string;
1666
+ conditionIndex?: number;
1667
+ clauseIndex?: number;
1668
+ }[];
1669
+ infos?: {
1670
+ componentId?: string;
1671
+ componentPath?: string;
1672
+ componentType?: string;
1673
+ message: string;
1674
+ type: string;
1675
+ parameterName?: string;
1676
+ expression?: {
1677
+ pointer: string;
1678
+ syntax: "jptr";
1679
+ failureAction?: "t" | "p" | "c" | "a";
1680
+ failureLogLevel?: "e" | "w" | "i";
1681
+ failureDefault?: string;
1682
+ };
1683
+ dataName?: string;
1684
+ dataType?: string;
1685
+ inputName?: string;
1686
+ code?: string;
1687
+ locale?: string;
1688
+ conditionIndex?: number;
1689
+ clauseIndex?: number;
1690
+ }[];
1691
+ } & {
1692
+ state: number;
1693
+ uiStatus?: "Draft" | "Modified" | "Published" | "Orphan" | "Previous" | "Unknown";
1694
+ projectId: string;
1695
+ created: string;
1696
+ modified: string;
1697
+ creator?: string;
1698
+ author?: string;
1699
+ categoryId?: string;
1700
+ description?: string;
1701
+ previewImageUrl?: string;
1702
+ pattern: boolean;
1703
+ patternType?: "component" | "composition";
1704
+ releaseId?: string;
1705
+ composition: {
1706
+ type: string;
1707
+ parameters?: {
1708
+ [key: string]: {
1709
+ value?: unknown;
1710
+ type: string;
1711
+ connectedData?: {
1712
+ pointer: string;
1713
+ syntax: "jptr";
1714
+ failureAction?: "t" | "p" | "c" | "a";
1715
+ failureLogLevel?: "e" | "w" | "i";
1716
+ failureDefault?: string;
1717
+ };
1718
+ locales?: {
1719
+ [key: string]: unknown;
1720
+ };
1721
+ conditions?: {
1722
+ when: {
1723
+ op?: "&" | "|";
1724
+ clauses: ({
1725
+ rule: string;
1726
+ source?: string;
1727
+ op: string;
1728
+ value: string | string[];
1729
+ } | /*elided*/ any)[];
1730
+ };
1731
+ value: unknown;
1732
+ id: number;
1733
+ }[];
1734
+ localesConditions?: {
1735
+ [key: string]: {
1736
+ when: {
1737
+ op?: "&" | "|";
1738
+ clauses: ({
1739
+ rule: string;
1740
+ source?: string;
1741
+ op: string;
1742
+ value: string | string[];
1743
+ } | /*elided*/ any)[];
1744
+ };
1745
+ value: unknown;
1746
+ id: number;
1747
+ }[];
1748
+ };
1749
+ };
1750
+ };
1751
+ variant?: string;
1752
+ projectMapNodes?: {
1753
+ id: string;
1754
+ path: string;
1755
+ projectMapId: string;
1756
+ data?: {
1757
+ isSearchHit?: boolean;
1758
+ queryStrings?: {
1759
+ name: string;
1760
+ value?: string;
1761
+ helpText?: string;
1762
+ }[];
1763
+ previewValue?: string;
1764
+ };
1765
+ locales?: {
1766
+ [key: string]: {
1767
+ path: string;
1768
+ inherited: boolean;
1769
+ };
1770
+ };
1771
+ }[];
1772
+ slots?: {
1773
+ [key: string]: {
1774
+ type: string;
1775
+ parameters?: {
1776
+ [key: string]: {
1777
+ value?: unknown;
1778
+ type: string;
1779
+ connectedData?: {
1780
+ pointer: string;
1781
+ syntax: "jptr";
1782
+ failureAction?: "t" | "p" | "c" | "a";
1783
+ failureLogLevel?: "e" | "w" | "i";
1784
+ failureDefault?: string;
1785
+ };
1786
+ locales?: {
1787
+ [key: string]: unknown;
1788
+ };
1789
+ conditions?: {
1790
+ when: {
1791
+ op?: "&" | "|";
1792
+ clauses: ({
1793
+ rule: string;
1794
+ source?: string;
1795
+ op: string;
1796
+ value: string | string[];
1797
+ } | /*elided*/ any)[];
1798
+ };
1799
+ value: unknown;
1800
+ id: number;
1801
+ }[];
1802
+ localesConditions?: {
1803
+ [key: string]: {
1804
+ when: {
1805
+ op?: "&" | "|";
1806
+ clauses: ({
1807
+ rule: string;
1808
+ source?: string;
1809
+ op: string;
1810
+ value: string | string[];
1811
+ } | /*elided*/ any)[];
1812
+ };
1813
+ value: unknown;
1814
+ id: number;
1815
+ }[];
1816
+ };
1817
+ };
1818
+ };
1819
+ variant?: string;
1820
+ slots?: {
1821
+ [key: string]: /*elided*/ any[];
1822
+ };
1823
+ _id?: string;
1824
+ _pattern?: string;
1825
+ _dataResources?: {
1826
+ [key: string]: {
1827
+ type: string;
1828
+ isPatternParameter?: boolean;
1829
+ ignorePatternParameterDefault?: boolean;
1830
+ optionalPatternParameter?: boolean;
1831
+ variables?: {
1832
+ [key: string]: string;
1833
+ };
1834
+ };
1835
+ };
1836
+ _patternDataResources?: {
1837
+ [key: string]: {
1838
+ type: string;
1839
+ isPatternParameter?: boolean;
1840
+ ignorePatternParameterDefault?: boolean;
1841
+ optionalPatternParameter?: boolean;
1842
+ variables?: {
1843
+ [key: string]: string;
1844
+ };
1845
+ };
1846
+ };
1847
+ _patternError?: "NOTFOUND" | "CYCLIC";
1848
+ _overrides?: {
1849
+ [key: string]: {
1850
+ parameters?: {
1851
+ [key: string]: {
1852
+ value?: unknown;
1853
+ type: string;
1854
+ connectedData?: {
1855
+ pointer: string;
1856
+ syntax: "jptr";
1857
+ failureAction?: "t" | "p" | "c" | "a";
1858
+ failureLogLevel?: "e" | "w" | "i";
1859
+ failureDefault?: string;
1860
+ };
1861
+ locales?: {
1862
+ [key: string]: unknown;
1863
+ };
1864
+ conditions?: {
1865
+ when: {
1866
+ op?: "&" | "|";
1867
+ clauses: ({
1868
+ rule: string;
1869
+ source?: string;
1870
+ op: string;
1871
+ value: string | string[];
1872
+ } | /*elided*/ any)[];
1873
+ };
1874
+ value: unknown;
1875
+ id: number;
1876
+ }[];
1877
+ localesConditions?: {
1878
+ [key: string]: {
1879
+ when: {
1880
+ op?: "&" | "|";
1881
+ clauses: ({
1882
+ rule: string;
1883
+ source?: string;
1884
+ op: string;
1885
+ value: string | string[];
1886
+ } | /*elided*/ any)[];
1887
+ };
1888
+ value: unknown;
1889
+ id: number;
1890
+ }[];
1891
+ };
1892
+ };
1893
+ };
1894
+ slots?: {
1895
+ [key: string]: /*elided*/ any[];
1896
+ };
1897
+ variant?: string;
1898
+ dataResources?: {
1899
+ [key: string]: {
1900
+ type: string;
1901
+ isPatternParameter?: boolean;
1902
+ ignorePatternParameterDefault?: boolean;
1903
+ optionalPatternParameter?: boolean;
1904
+ variables?: {
1905
+ [key: string]: string;
1906
+ };
1907
+ };
1908
+ };
1909
+ };
1910
+ };
1911
+ _patternOverrides?: {
1912
+ [key: string]: {
1913
+ parameters?: {
1914
+ [key: string]: {
1915
+ value?: unknown;
1916
+ type: string;
1917
+ connectedData?: {
1918
+ pointer: string;
1919
+ syntax: "jptr";
1920
+ failureAction?: "t" | "p" | "c" | "a";
1921
+ failureLogLevel?: "e" | "w" | "i";
1922
+ failureDefault?: string;
1923
+ };
1924
+ locales?: {
1925
+ [key: string]: unknown;
1926
+ };
1927
+ conditions?: {
1928
+ when: {
1929
+ op?: "&" | "|";
1930
+ clauses: ({
1931
+ rule: string;
1932
+ source?: string;
1933
+ op: string;
1934
+ value: string | string[];
1935
+ } | /*elided*/ any)[];
1936
+ };
1937
+ value: unknown;
1938
+ id: number;
1939
+ }[];
1940
+ localesConditions?: {
1941
+ [key: string]: {
1942
+ when: {
1943
+ op?: "&" | "|";
1944
+ clauses: ({
1945
+ rule: string;
1946
+ source?: string;
1947
+ op: string;
1948
+ value: string | string[];
1949
+ } | /*elided*/ any)[];
1950
+ };
1951
+ value: unknown;
1952
+ id: number;
1953
+ }[];
1954
+ };
1955
+ };
1956
+ };
1957
+ slots?: {
1958
+ [key: string]: /*elided*/ any[];
1959
+ };
1960
+ variant?: string;
1961
+ dataResources?: {
1962
+ [key: string]: {
1963
+ type: string;
1964
+ isPatternParameter?: boolean;
1965
+ ignorePatternParameterDefault?: boolean;
1966
+ optionalPatternParameter?: boolean;
1967
+ variables?: {
1968
+ [key: string]: string;
1969
+ };
1970
+ };
1971
+ };
1972
+ };
1973
+ };
1974
+ _overridability?: {
1975
+ parameters?: {
1976
+ [key: string]: "yes" | "no";
1977
+ };
1978
+ variants?: boolean;
1979
+ hideLockedParameters?: boolean;
1980
+ };
1981
+ _locales?: string[];
1982
+ }[];
1983
+ };
1984
+ _id: string;
1985
+ _slug?: string | null;
1986
+ _name: string;
1987
+ _author?: string;
1988
+ _authorSubject?: string;
1989
+ _creator?: string;
1990
+ _creatorSubject?: string;
1991
+ _pattern?: string;
1992
+ _patternDataResources?: {
1993
+ [key: string]: {
1994
+ type: string;
1995
+ isPatternParameter?: boolean;
1996
+ ignorePatternParameterDefault?: boolean;
1997
+ optionalPatternParameter?: boolean;
1998
+ variables?: {
1999
+ [key: string]: string;
2000
+ };
2001
+ };
2002
+ };
2003
+ _dataResources?: {
2004
+ [key: string]: {
2005
+ type: string;
2006
+ isPatternParameter?: boolean;
2007
+ ignorePatternParameterDefault?: boolean;
2008
+ optionalPatternParameter?: boolean;
2009
+ variables?: {
2010
+ [key: string]: string;
2011
+ };
2012
+ };
2013
+ };
2014
+ _patternError?: "NOTFOUND" | "CYCLIC";
2015
+ _overrides?: {
2016
+ [key: string]: {
2017
+ parameters?: {
2018
+ [key: string]: {
2019
+ value?: unknown;
2020
+ type: string;
2021
+ connectedData?: {
2022
+ pointer: string;
2023
+ syntax: "jptr";
2024
+ failureAction?: "t" | "p" | "c" | "a";
2025
+ failureLogLevel?: "e" | "w" | "i";
2026
+ failureDefault?: string;
2027
+ };
2028
+ locales?: {
2029
+ [key: string]: unknown;
2030
+ };
2031
+ conditions?: {
2032
+ when: {
2033
+ op?: "&" | "|";
2034
+ clauses: ({
2035
+ rule: string;
2036
+ source?: string;
2037
+ op: string;
2038
+ value: string | string[];
2039
+ } | /*elided*/ any)[];
2040
+ };
2041
+ value: unknown;
2042
+ id: number;
2043
+ }[];
2044
+ localesConditions?: {
2045
+ [key: string]: {
2046
+ when: {
2047
+ op?: "&" | "|";
2048
+ clauses: ({
2049
+ rule: string;
2050
+ source?: string;
2051
+ op: string;
2052
+ value: string | string[];
2053
+ } | /*elided*/ any)[];
2054
+ };
2055
+ value: unknown;
2056
+ id: number;
2057
+ }[];
2058
+ };
2059
+ };
2060
+ };
2061
+ slots?: {
2062
+ [key: string]: {
2063
+ type: string;
2064
+ parameters?: {
2065
+ [key: string]: {
2066
+ value?: unknown;
2067
+ type: string;
2068
+ connectedData?: {
2069
+ pointer: string;
2070
+ syntax: "jptr";
2071
+ failureAction?: "t" | "p" | "c" | "a";
2072
+ failureLogLevel?: "e" | "w" | "i";
2073
+ failureDefault?: string;
2074
+ };
2075
+ locales?: {
2076
+ [key: string]: unknown;
2077
+ };
2078
+ conditions?: {
2079
+ when: {
2080
+ op?: "&" | "|";
2081
+ clauses: ({
2082
+ rule: string;
2083
+ source?: string;
2084
+ op: string;
2085
+ value: string | string[];
2086
+ } | /*elided*/ any)[];
2087
+ };
2088
+ value: unknown;
2089
+ id: number;
2090
+ }[];
2091
+ localesConditions?: {
2092
+ [key: string]: {
2093
+ when: {
2094
+ op?: "&" | "|";
2095
+ clauses: ({
2096
+ rule: string;
2097
+ source?: string;
2098
+ op: string;
2099
+ value: string | string[];
2100
+ } | /*elided*/ any)[];
2101
+ };
2102
+ value: unknown;
2103
+ id: number;
2104
+ }[];
2105
+ };
2106
+ };
2107
+ };
2108
+ variant?: string;
2109
+ slots?: {
2110
+ [key: string]: /*elided*/ any[];
2111
+ };
2112
+ _id?: string;
2113
+ _pattern?: string;
2114
+ _dataResources?: {
2115
+ [key: string]: {
2116
+ type: string;
2117
+ isPatternParameter?: boolean;
2118
+ ignorePatternParameterDefault?: boolean;
2119
+ optionalPatternParameter?: boolean;
2120
+ variables?: {
2121
+ [key: string]: string;
2122
+ };
2123
+ };
2124
+ };
2125
+ _patternDataResources?: {
2126
+ [key: string]: {
2127
+ type: string;
2128
+ isPatternParameter?: boolean;
2129
+ ignorePatternParameterDefault?: boolean;
2130
+ optionalPatternParameter?: boolean;
2131
+ variables?: {
2132
+ [key: string]: string;
2133
+ };
2134
+ };
2135
+ };
2136
+ _patternError?: "NOTFOUND" | "CYCLIC";
2137
+ _overrides?: {
2138
+ [key: string]: /*elided*/ any;
2139
+ };
2140
+ _patternOverrides?: {
2141
+ [key: string]: /*elided*/ any;
2142
+ };
2143
+ _overridability?: {
2144
+ parameters?: {
2145
+ [key: string]: "yes" | "no";
2146
+ };
2147
+ variants?: boolean;
2148
+ hideLockedParameters?: boolean;
2149
+ };
2150
+ _locales?: string[];
2151
+ }[];
2152
+ };
2153
+ variant?: string;
2154
+ dataResources?: {
2155
+ [key: string]: {
2156
+ type: string;
2157
+ isPatternParameter?: boolean;
2158
+ ignorePatternParameterDefault?: boolean;
2159
+ optionalPatternParameter?: boolean;
2160
+ variables?: {
2161
+ [key: string]: string;
2162
+ };
2163
+ };
2164
+ };
2165
+ };
2166
+ };
2167
+ _patternOverrides?: {
2168
+ [key: string]: {
2169
+ parameters?: {
2170
+ [key: string]: {
2171
+ value?: unknown;
2172
+ type: string;
2173
+ connectedData?: {
2174
+ pointer: string;
2175
+ syntax: "jptr";
2176
+ failureAction?: "t" | "p" | "c" | "a";
2177
+ failureLogLevel?: "e" | "w" | "i";
2178
+ failureDefault?: string;
2179
+ };
2180
+ locales?: {
2181
+ [key: string]: unknown;
2182
+ };
2183
+ conditions?: {
2184
+ when: {
2185
+ op?: "&" | "|";
2186
+ clauses: ({
2187
+ rule: string;
2188
+ source?: string;
2189
+ op: string;
2190
+ value: string | string[];
2191
+ } | /*elided*/ any)[];
2192
+ };
2193
+ value: unknown;
2194
+ id: number;
2195
+ }[];
2196
+ localesConditions?: {
2197
+ [key: string]: {
2198
+ when: {
2199
+ op?: "&" | "|";
2200
+ clauses: ({
2201
+ rule: string;
2202
+ source?: string;
2203
+ op: string;
2204
+ value: string | string[];
2205
+ } | /*elided*/ any)[];
2206
+ };
2207
+ value: unknown;
2208
+ id: number;
2209
+ }[];
2210
+ };
2211
+ };
2212
+ };
2213
+ slots?: {
2214
+ [key: string]: {
2215
+ type: string;
2216
+ parameters?: {
2217
+ [key: string]: {
2218
+ value?: unknown;
2219
+ type: string;
2220
+ connectedData?: {
2221
+ pointer: string;
2222
+ syntax: "jptr";
2223
+ failureAction?: "t" | "p" | "c" | "a";
2224
+ failureLogLevel?: "e" | "w" | "i";
2225
+ failureDefault?: string;
2226
+ };
2227
+ locales?: {
2228
+ [key: string]: unknown;
2229
+ };
2230
+ conditions?: {
2231
+ when: {
2232
+ op?: "&" | "|";
2233
+ clauses: ({
2234
+ rule: string;
2235
+ source?: string;
2236
+ op: string;
2237
+ value: string | string[];
2238
+ } | /*elided*/ any)[];
2239
+ };
2240
+ value: unknown;
2241
+ id: number;
2242
+ }[];
2243
+ localesConditions?: {
2244
+ [key: string]: {
2245
+ when: {
2246
+ op?: "&" | "|";
2247
+ clauses: ({
2248
+ rule: string;
2249
+ source?: string;
2250
+ op: string;
2251
+ value: string | string[];
2252
+ } | /*elided*/ any)[];
2253
+ };
2254
+ value: unknown;
2255
+ id: number;
2256
+ }[];
2257
+ };
2258
+ };
2259
+ };
2260
+ variant?: string;
2261
+ slots?: {
2262
+ [key: string]: /*elided*/ any[];
2263
+ };
2264
+ _id?: string;
2265
+ _pattern?: string;
2266
+ _dataResources?: {
2267
+ [key: string]: {
2268
+ type: string;
2269
+ isPatternParameter?: boolean;
2270
+ ignorePatternParameterDefault?: boolean;
2271
+ optionalPatternParameter?: boolean;
2272
+ variables?: {
2273
+ [key: string]: string;
2274
+ };
2275
+ };
2276
+ };
2277
+ _patternDataResources?: {
2278
+ [key: string]: {
2279
+ type: string;
2280
+ isPatternParameter?: boolean;
2281
+ ignorePatternParameterDefault?: boolean;
2282
+ optionalPatternParameter?: boolean;
2283
+ variables?: {
2284
+ [key: string]: string;
2285
+ };
2286
+ };
2287
+ };
2288
+ _patternError?: "NOTFOUND" | "CYCLIC";
2289
+ _overrides?: {
2290
+ [key: string]: /*elided*/ any;
2291
+ };
2292
+ _patternOverrides?: {
2293
+ [key: string]: /*elided*/ any;
2294
+ };
2295
+ _overridability?: {
2296
+ parameters?: {
2297
+ [key: string]: "yes" | "no";
2298
+ };
2299
+ variants?: boolean;
2300
+ hideLockedParameters?: boolean;
2301
+ };
2302
+ _locales?: string[];
2303
+ }[];
2304
+ };
2305
+ variant?: string;
2306
+ dataResources?: {
2307
+ [key: string]: {
2308
+ type: string;
2309
+ isPatternParameter?: boolean;
2310
+ ignorePatternParameterDefault?: boolean;
2311
+ optionalPatternParameter?: boolean;
2312
+ variables?: {
2313
+ [key: string]: string;
2314
+ };
2315
+ };
2316
+ };
2317
+ };
2318
+ };
2319
+ _overridability?: {
2320
+ parameters?: {
2321
+ [key: string]: "yes" | "no";
2322
+ };
2323
+ variants?: boolean;
2324
+ hideLockedParameters?: boolean;
2325
+ };
2326
+ _locales?: string[];
2327
+ };
2328
+ workflowId?: string;
2329
+ workflowStageId?: string;
2330
+ workflowDefinition?: {
2331
+ id: string;
2332
+ name: string;
2333
+ initialStage: string;
2334
+ stages: {
2335
+ [key: string]: {
2336
+ name: string;
2337
+ permissions: {
2338
+ [key: string]: {
2339
+ write?: boolean;
2340
+ publish?: boolean;
2341
+ };
2342
+ };
2343
+ autoPublish?: boolean;
2344
+ requireValidity?: boolean;
2345
+ transitions: {
2346
+ to: string;
2347
+ name: string;
2348
+ permissions: {
2349
+ [key: string]: {
2350
+ execute?: boolean;
2351
+ };
2352
+ };
2353
+ }[];
2354
+ icon?: string;
2355
+ order?: number;
2356
+ };
2357
+ };
2358
+ modified?: string;
2359
+ created?: string;
2360
+ createdBy?: string;
2361
+ modifiedBy?: string;
2362
+ };
2363
+ editionId?: string;
2364
+ editionName?: string;
2365
+ editionPriority?: number;
2366
+ }) | null | undefined, ({
2367
+ wholeResponseCacheDiagnostics?: {
2368
+ info: string;
2369
+ cacheTtl: number;
2370
+ cachedAt: string;
2371
+ edgeLocation?: string;
2372
+ requestId: string;
2373
+ };
2374
+ diagnostics?: {
2375
+ edgeLocation?: string;
2376
+ originFetch?: {
2377
+ duration: number;
2378
+ cacheHit: boolean;
2379
+ isValid: boolean;
2380
+ sourceCache?: "edge-cdn-cache" | "long-term-cache" | "api-cache";
2381
+ cacheLocation?: string;
2382
+ requestId?: string;
2383
+ };
2384
+ configRetrieval?: {
2385
+ duration: number;
2386
+ dataTypeCount: number;
2387
+ };
2388
+ } & {
2389
+ data?: {
2390
+ componentPath: string;
2391
+ dataType: string;
2392
+ dataName: string;
2393
+ performance: {
2394
+ cacheHit: boolean;
2395
+ total: number;
2396
+ retryCount: number;
2397
+ retryDelay: number;
2398
+ sourceCache?: string;
2399
+ statusCodes: number[];
2400
+ };
2401
+ data: unknown;
2402
+ }[];
2403
+ };
2404
+ errors?: {
2405
+ componentId?: string;
2406
+ componentPath?: string;
2407
+ componentType?: string;
2408
+ message: string;
2409
+ type: string;
2410
+ parameterName?: string;
2411
+ expression?: {
2412
+ pointer: string;
2413
+ syntax: "jptr";
2414
+ failureAction?: "t" | "p" | "c" | "a";
2415
+ failureLogLevel?: "e" | "w" | "i";
2416
+ failureDefault?: string;
2417
+ };
2418
+ dataName?: string;
2419
+ dataType?: string;
2420
+ inputName?: string;
2421
+ code?: string;
2422
+ locale?: string;
2423
+ conditionIndex?: number;
2424
+ clauseIndex?: number;
2425
+ }[];
2426
+ warnings?: {
2427
+ componentId?: string;
2428
+ componentPath?: string;
2429
+ componentType?: string;
2430
+ message: string;
2431
+ type: string;
2432
+ parameterName?: string;
2433
+ expression?: {
2434
+ pointer: string;
2435
+ syntax: "jptr";
2436
+ failureAction?: "t" | "p" | "c" | "a";
2437
+ failureLogLevel?: "e" | "w" | "i";
2438
+ failureDefault?: string;
2439
+ };
2440
+ dataName?: string;
2441
+ dataType?: string;
2442
+ inputName?: string;
2443
+ code?: string;
2444
+ locale?: string;
2445
+ conditionIndex?: number;
2446
+ clauseIndex?: number;
2447
+ }[];
2448
+ infos?: {
2449
+ componentId?: string;
2450
+ componentPath?: string;
2451
+ componentType?: string;
2452
+ message: string;
2453
+ type: string;
2454
+ parameterName?: string;
2455
+ expression?: {
2456
+ pointer: string;
2457
+ syntax: "jptr";
2458
+ failureAction?: "t" | "p" | "c" | "a";
2459
+ failureLogLevel?: "e" | "w" | "i";
2460
+ failureDefault?: string;
2461
+ };
2462
+ dataName?: string;
2463
+ dataType?: string;
2464
+ inputName?: string;
2465
+ code?: string;
2466
+ locale?: string;
2467
+ conditionIndex?: number;
2468
+ clauseIndex?: number;
2469
+ }[];
2470
+ } & {
2471
+ state: number;
2472
+ uiStatus?: "Draft" | "Modified" | "Published" | "Orphan" | "Previous" | "Unknown";
2473
+ projectId: string;
2474
+ created: string;
2475
+ modified: string;
2476
+ creator?: string;
2477
+ author?: string;
2478
+ categoryId?: string;
2479
+ description?: string;
2480
+ previewImageUrl?: string;
2481
+ pattern: boolean;
2482
+ patternType?: "component" | "composition";
2483
+ releaseId?: string;
2484
+ composition: {
2485
+ type: string;
2486
+ parameters?: {
2487
+ [key: string]: {
2488
+ value?: unknown;
2489
+ type: string;
2490
+ connectedData?: {
2491
+ pointer: string;
2492
+ syntax: "jptr";
2493
+ failureAction?: "t" | "p" | "c" | "a";
2494
+ failureLogLevel?: "e" | "w" | "i";
2495
+ failureDefault?: string;
2496
+ };
2497
+ locales?: {
2498
+ [key: string]: unknown;
2499
+ };
2500
+ conditions?: {
2501
+ when: {
2502
+ op?: "&" | "|";
2503
+ clauses: ({
2504
+ rule: string;
2505
+ source?: string;
2506
+ op: string;
2507
+ value: string | string[];
2508
+ } | /*elided*/ any)[];
2509
+ };
2510
+ value: unknown;
2511
+ id: number;
2512
+ }[];
2513
+ localesConditions?: {
2514
+ [key: string]: {
2515
+ when: {
2516
+ op?: "&" | "|";
2517
+ clauses: ({
2518
+ rule: string;
2519
+ source?: string;
2520
+ op: string;
2521
+ value: string | string[];
2522
+ } | /*elided*/ any)[];
2523
+ };
2524
+ value: unknown;
2525
+ id: number;
2526
+ }[];
2527
+ };
2528
+ };
2529
+ };
2530
+ variant?: string;
2531
+ projectMapNodes?: {
2532
+ id: string;
2533
+ path: string;
2534
+ projectMapId: string;
2535
+ data?: {
2536
+ isSearchHit?: boolean;
2537
+ queryStrings?: {
2538
+ name: string;
2539
+ value?: string;
2540
+ helpText?: string;
2541
+ }[];
2542
+ previewValue?: string;
2543
+ };
2544
+ locales?: {
2545
+ [key: string]: {
2546
+ path: string;
2547
+ inherited: boolean;
2548
+ };
2549
+ };
2550
+ }[];
2551
+ slots?: {
2552
+ [key: string]: {
2553
+ type: string;
2554
+ parameters?: {
2555
+ [key: string]: {
2556
+ value?: unknown;
2557
+ type: string;
2558
+ connectedData?: {
2559
+ pointer: string;
2560
+ syntax: "jptr";
2561
+ failureAction?: "t" | "p" | "c" | "a";
2562
+ failureLogLevel?: "e" | "w" | "i";
2563
+ failureDefault?: string;
2564
+ };
2565
+ locales?: {
2566
+ [key: string]: unknown;
2567
+ };
2568
+ conditions?: {
2569
+ when: {
2570
+ op?: "&" | "|";
2571
+ clauses: ({
2572
+ rule: string;
2573
+ source?: string;
2574
+ op: string;
2575
+ value: string | string[];
2576
+ } | /*elided*/ any)[];
2577
+ };
2578
+ value: unknown;
2579
+ id: number;
2580
+ }[];
2581
+ localesConditions?: {
2582
+ [key: string]: {
2583
+ when: {
2584
+ op?: "&" | "|";
2585
+ clauses: ({
2586
+ rule: string;
2587
+ source?: string;
2588
+ op: string;
2589
+ value: string | string[];
2590
+ } | /*elided*/ any)[];
2591
+ };
2592
+ value: unknown;
2593
+ id: number;
2594
+ }[];
2595
+ };
2596
+ };
2597
+ };
2598
+ variant?: string;
2599
+ slots?: {
2600
+ [key: string]: /*elided*/ any[];
2601
+ };
2602
+ _id?: string;
2603
+ _pattern?: string;
2604
+ _dataResources?: {
2605
+ [key: string]: {
2606
+ type: string;
2607
+ isPatternParameter?: boolean;
2608
+ ignorePatternParameterDefault?: boolean;
2609
+ optionalPatternParameter?: boolean;
2610
+ variables?: {
2611
+ [key: string]: string;
2612
+ };
2613
+ };
2614
+ };
2615
+ _patternDataResources?: {
2616
+ [key: string]: {
2617
+ type: string;
2618
+ isPatternParameter?: boolean;
2619
+ ignorePatternParameterDefault?: boolean;
2620
+ optionalPatternParameter?: boolean;
2621
+ variables?: {
2622
+ [key: string]: string;
2623
+ };
2624
+ };
2625
+ };
2626
+ _patternError?: "NOTFOUND" | "CYCLIC";
2627
+ _overrides?: {
2628
+ [key: string]: {
2629
+ parameters?: {
2630
+ [key: string]: {
2631
+ value?: unknown;
2632
+ type: string;
2633
+ connectedData?: {
2634
+ pointer: string;
2635
+ syntax: "jptr";
2636
+ failureAction?: "t" | "p" | "c" | "a";
2637
+ failureLogLevel?: "e" | "w" | "i";
2638
+ failureDefault?: string;
2639
+ };
2640
+ locales?: {
2641
+ [key: string]: unknown;
2642
+ };
2643
+ conditions?: {
2644
+ when: {
2645
+ op?: "&" | "|";
2646
+ clauses: ({
2647
+ rule: string;
2648
+ source?: string;
2649
+ op: string;
2650
+ value: string | string[];
2651
+ } | /*elided*/ any)[];
2652
+ };
2653
+ value: unknown;
2654
+ id: number;
2655
+ }[];
2656
+ localesConditions?: {
2657
+ [key: string]: {
2658
+ when: {
2659
+ op?: "&" | "|";
2660
+ clauses: ({
2661
+ rule: string;
2662
+ source?: string;
2663
+ op: string;
2664
+ value: string | string[];
2665
+ } | /*elided*/ any)[];
2666
+ };
2667
+ value: unknown;
2668
+ id: number;
2669
+ }[];
2670
+ };
2671
+ };
2672
+ };
2673
+ slots?: {
2674
+ [key: string]: /*elided*/ any[];
2675
+ };
2676
+ variant?: string;
2677
+ dataResources?: {
2678
+ [key: string]: {
2679
+ type: string;
2680
+ isPatternParameter?: boolean;
2681
+ ignorePatternParameterDefault?: boolean;
2682
+ optionalPatternParameter?: boolean;
2683
+ variables?: {
2684
+ [key: string]: string;
2685
+ };
2686
+ };
2687
+ };
2688
+ };
2689
+ };
2690
+ _patternOverrides?: {
2691
+ [key: string]: {
2692
+ parameters?: {
2693
+ [key: string]: {
2694
+ value?: unknown;
2695
+ type: string;
2696
+ connectedData?: {
2697
+ pointer: string;
2698
+ syntax: "jptr";
2699
+ failureAction?: "t" | "p" | "c" | "a";
2700
+ failureLogLevel?: "e" | "w" | "i";
2701
+ failureDefault?: string;
2702
+ };
2703
+ locales?: {
2704
+ [key: string]: unknown;
2705
+ };
2706
+ conditions?: {
2707
+ when: {
2708
+ op?: "&" | "|";
2709
+ clauses: ({
2710
+ rule: string;
2711
+ source?: string;
2712
+ op: string;
2713
+ value: string | string[];
2714
+ } | /*elided*/ any)[];
2715
+ };
2716
+ value: unknown;
2717
+ id: number;
2718
+ }[];
2719
+ localesConditions?: {
2720
+ [key: string]: {
2721
+ when: {
2722
+ op?: "&" | "|";
2723
+ clauses: ({
2724
+ rule: string;
2725
+ source?: string;
2726
+ op: string;
2727
+ value: string | string[];
2728
+ } | /*elided*/ any)[];
2729
+ };
2730
+ value: unknown;
2731
+ id: number;
2732
+ }[];
2733
+ };
2734
+ };
2735
+ };
2736
+ slots?: {
2737
+ [key: string]: /*elided*/ any[];
2738
+ };
2739
+ variant?: string;
2740
+ dataResources?: {
2741
+ [key: string]: {
2742
+ type: string;
2743
+ isPatternParameter?: boolean;
2744
+ ignorePatternParameterDefault?: boolean;
2745
+ optionalPatternParameter?: boolean;
2746
+ variables?: {
2747
+ [key: string]: string;
2748
+ };
2749
+ };
2750
+ };
2751
+ };
2752
+ };
2753
+ _overridability?: {
2754
+ parameters?: {
2755
+ [key: string]: "yes" | "no";
2756
+ };
2757
+ variants?: boolean;
2758
+ hideLockedParameters?: boolean;
2759
+ };
2760
+ _locales?: string[];
2761
+ }[];
2762
+ };
2763
+ _id: string;
2764
+ _slug?: string | null;
2765
+ _name: string;
2766
+ _author?: string;
2767
+ _authorSubject?: string;
2768
+ _creator?: string;
2769
+ _creatorSubject?: string;
2770
+ _pattern?: string;
2771
+ _patternDataResources?: {
2772
+ [key: string]: {
2773
+ type: string;
2774
+ isPatternParameter?: boolean;
2775
+ ignorePatternParameterDefault?: boolean;
2776
+ optionalPatternParameter?: boolean;
2777
+ variables?: {
2778
+ [key: string]: string;
2779
+ };
2780
+ };
2781
+ };
2782
+ _dataResources?: {
2783
+ [key: string]: {
2784
+ type: string;
2785
+ isPatternParameter?: boolean;
2786
+ ignorePatternParameterDefault?: boolean;
2787
+ optionalPatternParameter?: boolean;
2788
+ variables?: {
2789
+ [key: string]: string;
2790
+ };
2791
+ };
2792
+ };
2793
+ _patternError?: "NOTFOUND" | "CYCLIC";
2794
+ _overrides?: {
2795
+ [key: string]: {
2796
+ parameters?: {
2797
+ [key: string]: {
2798
+ value?: unknown;
2799
+ type: string;
2800
+ connectedData?: {
2801
+ pointer: string;
2802
+ syntax: "jptr";
2803
+ failureAction?: "t" | "p" | "c" | "a";
2804
+ failureLogLevel?: "e" | "w" | "i";
2805
+ failureDefault?: string;
2806
+ };
2807
+ locales?: {
2808
+ [key: string]: unknown;
2809
+ };
2810
+ conditions?: {
2811
+ when: {
2812
+ op?: "&" | "|";
2813
+ clauses: ({
2814
+ rule: string;
2815
+ source?: string;
2816
+ op: string;
2817
+ value: string | string[];
2818
+ } | /*elided*/ any)[];
2819
+ };
2820
+ value: unknown;
2821
+ id: number;
2822
+ }[];
2823
+ localesConditions?: {
2824
+ [key: string]: {
2825
+ when: {
2826
+ op?: "&" | "|";
2827
+ clauses: ({
2828
+ rule: string;
2829
+ source?: string;
2830
+ op: string;
2831
+ value: string | string[];
2832
+ } | /*elided*/ any)[];
2833
+ };
2834
+ value: unknown;
2835
+ id: number;
2836
+ }[];
2837
+ };
2838
+ };
2839
+ };
2840
+ slots?: {
2841
+ [key: string]: {
2842
+ type: string;
2843
+ parameters?: {
2844
+ [key: string]: {
2845
+ value?: unknown;
2846
+ type: string;
2847
+ connectedData?: {
2848
+ pointer: string;
2849
+ syntax: "jptr";
2850
+ failureAction?: "t" | "p" | "c" | "a";
2851
+ failureLogLevel?: "e" | "w" | "i";
2852
+ failureDefault?: string;
2853
+ };
2854
+ locales?: {
2855
+ [key: string]: unknown;
2856
+ };
2857
+ conditions?: {
2858
+ when: {
2859
+ op?: "&" | "|";
2860
+ clauses: ({
2861
+ rule: string;
2862
+ source?: string;
2863
+ op: string;
2864
+ value: string | string[];
2865
+ } | /*elided*/ any)[];
2866
+ };
2867
+ value: unknown;
2868
+ id: number;
2869
+ }[];
2870
+ localesConditions?: {
2871
+ [key: string]: {
2872
+ when: {
2873
+ op?: "&" | "|";
2874
+ clauses: ({
2875
+ rule: string;
2876
+ source?: string;
2877
+ op: string;
2878
+ value: string | string[];
2879
+ } | /*elided*/ any)[];
2880
+ };
2881
+ value: unknown;
2882
+ id: number;
2883
+ }[];
2884
+ };
2885
+ };
2886
+ };
2887
+ variant?: string;
2888
+ slots?: {
2889
+ [key: string]: /*elided*/ any[];
2890
+ };
2891
+ _id?: string;
2892
+ _pattern?: string;
2893
+ _dataResources?: {
2894
+ [key: string]: {
2895
+ type: string;
2896
+ isPatternParameter?: boolean;
2897
+ ignorePatternParameterDefault?: boolean;
2898
+ optionalPatternParameter?: boolean;
2899
+ variables?: {
2900
+ [key: string]: string;
2901
+ };
2902
+ };
2903
+ };
2904
+ _patternDataResources?: {
2905
+ [key: string]: {
2906
+ type: string;
2907
+ isPatternParameter?: boolean;
2908
+ ignorePatternParameterDefault?: boolean;
2909
+ optionalPatternParameter?: boolean;
2910
+ variables?: {
2911
+ [key: string]: string;
2912
+ };
2913
+ };
2914
+ };
2915
+ _patternError?: "NOTFOUND" | "CYCLIC";
2916
+ _overrides?: {
2917
+ [key: string]: /*elided*/ any;
2918
+ };
2919
+ _patternOverrides?: {
2920
+ [key: string]: /*elided*/ any;
2921
+ };
2922
+ _overridability?: {
2923
+ parameters?: {
2924
+ [key: string]: "yes" | "no";
2925
+ };
2926
+ variants?: boolean;
2927
+ hideLockedParameters?: boolean;
2928
+ };
2929
+ _locales?: string[];
2930
+ }[];
2931
+ };
2932
+ variant?: string;
2933
+ dataResources?: {
2934
+ [key: string]: {
2935
+ type: string;
2936
+ isPatternParameter?: boolean;
2937
+ ignorePatternParameterDefault?: boolean;
2938
+ optionalPatternParameter?: boolean;
2939
+ variables?: {
2940
+ [key: string]: string;
2941
+ };
2942
+ };
2943
+ };
2944
+ };
2945
+ };
2946
+ _patternOverrides?: {
2947
+ [key: string]: {
2948
+ parameters?: {
2949
+ [key: string]: {
2950
+ value?: unknown;
2951
+ type: string;
2952
+ connectedData?: {
2953
+ pointer: string;
2954
+ syntax: "jptr";
2955
+ failureAction?: "t" | "p" | "c" | "a";
2956
+ failureLogLevel?: "e" | "w" | "i";
2957
+ failureDefault?: string;
2958
+ };
2959
+ locales?: {
2960
+ [key: string]: unknown;
2961
+ };
2962
+ conditions?: {
2963
+ when: {
2964
+ op?: "&" | "|";
2965
+ clauses: ({
2966
+ rule: string;
2967
+ source?: string;
2968
+ op: string;
2969
+ value: string | string[];
2970
+ } | /*elided*/ any)[];
2971
+ };
2972
+ value: unknown;
2973
+ id: number;
2974
+ }[];
2975
+ localesConditions?: {
2976
+ [key: string]: {
2977
+ when: {
2978
+ op?: "&" | "|";
2979
+ clauses: ({
2980
+ rule: string;
2981
+ source?: string;
2982
+ op: string;
2983
+ value: string | string[];
2984
+ } | /*elided*/ any)[];
2985
+ };
2986
+ value: unknown;
2987
+ id: number;
2988
+ }[];
2989
+ };
2990
+ };
2991
+ };
2992
+ slots?: {
2993
+ [key: string]: {
2994
+ type: string;
2995
+ parameters?: {
2996
+ [key: string]: {
2997
+ value?: unknown;
2998
+ type: string;
2999
+ connectedData?: {
3000
+ pointer: string;
3001
+ syntax: "jptr";
3002
+ failureAction?: "t" | "p" | "c" | "a";
3003
+ failureLogLevel?: "e" | "w" | "i";
3004
+ failureDefault?: string;
3005
+ };
3006
+ locales?: {
3007
+ [key: string]: unknown;
3008
+ };
3009
+ conditions?: {
3010
+ when: {
3011
+ op?: "&" | "|";
3012
+ clauses: ({
3013
+ rule: string;
3014
+ source?: string;
3015
+ op: string;
3016
+ value: string | string[];
3017
+ } | /*elided*/ any)[];
3018
+ };
3019
+ value: unknown;
3020
+ id: number;
3021
+ }[];
3022
+ localesConditions?: {
3023
+ [key: string]: {
3024
+ when: {
3025
+ op?: "&" | "|";
3026
+ clauses: ({
3027
+ rule: string;
3028
+ source?: string;
3029
+ op: string;
3030
+ value: string | string[];
3031
+ } | /*elided*/ any)[];
3032
+ };
3033
+ value: unknown;
3034
+ id: number;
3035
+ }[];
3036
+ };
3037
+ };
3038
+ };
3039
+ variant?: string;
3040
+ slots?: {
3041
+ [key: string]: /*elided*/ any[];
3042
+ };
3043
+ _id?: string;
3044
+ _pattern?: string;
3045
+ _dataResources?: {
3046
+ [key: string]: {
3047
+ type: string;
3048
+ isPatternParameter?: boolean;
3049
+ ignorePatternParameterDefault?: boolean;
3050
+ optionalPatternParameter?: boolean;
3051
+ variables?: {
3052
+ [key: string]: string;
3053
+ };
3054
+ };
3055
+ };
3056
+ _patternDataResources?: {
3057
+ [key: string]: {
3058
+ type: string;
3059
+ isPatternParameter?: boolean;
3060
+ ignorePatternParameterDefault?: boolean;
3061
+ optionalPatternParameter?: boolean;
3062
+ variables?: {
3063
+ [key: string]: string;
3064
+ };
3065
+ };
3066
+ };
3067
+ _patternError?: "NOTFOUND" | "CYCLIC";
3068
+ _overrides?: {
3069
+ [key: string]: /*elided*/ any;
3070
+ };
3071
+ _patternOverrides?: {
3072
+ [key: string]: /*elided*/ any;
3073
+ };
3074
+ _overridability?: {
3075
+ parameters?: {
3076
+ [key: string]: "yes" | "no";
3077
+ };
3078
+ variants?: boolean;
3079
+ hideLockedParameters?: boolean;
3080
+ };
3081
+ _locales?: string[];
3082
+ }[];
3083
+ };
3084
+ variant?: string;
3085
+ dataResources?: {
3086
+ [key: string]: {
3087
+ type: string;
3088
+ isPatternParameter?: boolean;
3089
+ ignorePatternParameterDefault?: boolean;
3090
+ optionalPatternParameter?: boolean;
3091
+ variables?: {
3092
+ [key: string]: string;
3093
+ };
3094
+ };
3095
+ };
3096
+ };
3097
+ };
3098
+ _overridability?: {
3099
+ parameters?: {
3100
+ [key: string]: "yes" | "no";
3101
+ };
3102
+ variants?: boolean;
3103
+ hideLockedParameters?: boolean;
3104
+ };
3105
+ _locales?: string[];
3106
+ };
3107
+ workflowId?: string;
3108
+ workflowStageId?: string;
3109
+ workflowDefinition?: {
3110
+ id: string;
3111
+ name: string;
3112
+ initialStage: string;
3113
+ stages: {
3114
+ [key: string]: {
3115
+ name: string;
3116
+ permissions: {
3117
+ [key: string]: {
3118
+ write?: boolean;
3119
+ publish?: boolean;
3120
+ };
3121
+ };
3122
+ autoPublish?: boolean;
3123
+ requireValidity?: boolean;
3124
+ transitions: {
3125
+ to: string;
3126
+ name: string;
3127
+ permissions: {
3128
+ [key: string]: {
3129
+ execute?: boolean;
3130
+ };
3131
+ };
3132
+ }[];
3133
+ icon?: string;
3134
+ order?: number;
3135
+ };
3136
+ };
3137
+ modified?: string;
3138
+ created?: string;
3139
+ createdBy?: string;
3140
+ modifiedBy?: string;
3141
+ };
3142
+ editionId?: string;
3143
+ editionName?: string;
3144
+ editionPriority?: number;
3145
+ }) | null | undefined>;
3146
+ pending: Ref<boolean, boolean>;
3147
+ error: Ref<import("#app").NuxtError<unknown> | null, import("#app").NuxtError<unknown> | null>;
3148
+ }>;
3149
+ }>;
9
3150
  export default _default;