@uniformdev/uniform-nuxt 20.7.1-alpha.12 → 20.7.1-alpha.121

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