@oak-digital/types-4-strapi-2 1.0.7 → 1.0.8

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 (16) hide show
  1. package/lib/readers/types/attributes.d.ts +2470 -0
  2. package/lib/readers/types/attributes.js +159 -0
  3. package/lib/readers/types/component.d.ts +855 -0
  4. package/lib/readers/types/component.js +11 -0
  5. package/lib/readers/types/content-type-reader.d.ts +16 -0
  6. package/lib/readers/types/content-type-reader.js +2 -0
  7. package/lib/readers/types/content-type.d.ts +899 -0
  8. package/lib/readers/types/content-type.js +16 -0
  9. package/lib/tsconfig.tsbuildinfo +1 -0
  10. package/lib/writers/types/writer.d.ts +4 -0
  11. package/lib/writers/types/writer.js +2 -0
  12. package/package.json +9 -2
  13. package/.editorconfig +0 -9
  14. package/.eslintrc.json +0 -49
  15. package/.github/workflows/publish.yml +0 -48
  16. package/.prettierrc.json +0 -8
package/lib/readers/types/attributes.d.ts ADDED
@@ -0,0 +1,2470 @@
1
+ import { z } from 'zod';
2
+ export declare const baseAttribute: z.ZodObject<{
3
+ pluginOptions: z.ZodOptional<z.ZodAny>;
4
+ required: z.ZodOptional<z.ZodBoolean>;
5
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
6
+ }, "strip", z.ZodTypeAny, {
7
+ __t4s_required?: boolean;
8
+ pluginOptions?: any;
9
+ required?: boolean;
10
+ }, {
11
+ __t4s_required?: boolean;
12
+ pluginOptions?: any;
13
+ required?: boolean;
14
+ }>;
15
+ export declare const textAttribute: z.ZodObject<{
16
+ pluginOptions: z.ZodOptional<z.ZodAny>;
17
+ required: z.ZodOptional<z.ZodBoolean>;
18
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
19
+ } & {
20
+ type: z.ZodEnum<["text", "string"]>;
21
+ }, "strip", z.ZodTypeAny, {
22
+ __t4s_required?: boolean;
23
+ pluginOptions?: any;
24
+ required?: boolean;
25
+ type?: "string" | "text";
26
+ }, {
27
+ __t4s_required?: boolean;
28
+ pluginOptions?: any;
29
+ required?: boolean;
30
+ type?: "string" | "text";
31
+ }>;
32
+ export type TextAttribute = z.infer<typeof textAttribute>;
33
+ export declare const emailAttribute: z.ZodObject<{
34
+ pluginOptions: z.ZodOptional<z.ZodAny>;
35
+ required: z.ZodOptional<z.ZodBoolean>;
36
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
37
+ } & {
38
+ type: z.ZodLiteral<"email">;
39
+ }, "strip", z.ZodTypeAny, {
40
+ __t4s_required?: boolean;
41
+ pluginOptions?: any;
42
+ required?: boolean;
43
+ type?: "email";
44
+ }, {
45
+ __t4s_required?: boolean;
46
+ pluginOptions?: any;
47
+ required?: boolean;
48
+ type?: "email";
49
+ }>;
50
+ export type EmailAttribute = z.infer<typeof emailAttribute>;
51
+ export declare const uidAttribute: z.ZodObject<{
52
+ pluginOptions: z.ZodOptional<z.ZodAny>;
53
+ required: z.ZodOptional<z.ZodBoolean>;
54
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
55
+ } & {
56
+ type: z.ZodLiteral<"uid">;
57
+ targetField: z.ZodOptional<z.ZodString>;
58
+ }, "strip", z.ZodTypeAny, {
59
+ __t4s_required?: boolean;
60
+ pluginOptions?: any;
61
+ required?: boolean;
62
+ type?: "uid";
63
+ targetField?: string;
64
+ }, {
65
+ __t4s_required?: boolean;
66
+ pluginOptions?: any;
67
+ required?: boolean;
68
+ type?: "uid";
69
+ targetField?: string;
70
+ }>;
71
+ export type UidAttribute = z.infer<typeof uidAttribute>;
72
+ export declare const richTextAttribute: z.ZodObject<{
73
+ pluginOptions: z.ZodOptional<z.ZodAny>;
74
+ required: z.ZodOptional<z.ZodBoolean>;
75
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
76
+ } & {
77
+ type: z.ZodLiteral<"richtext">;
78
+ }, "strip", z.ZodTypeAny, {
79
+ __t4s_required?: boolean;
80
+ pluginOptions?: any;
81
+ required?: boolean;
82
+ type?: "richtext";
83
+ }, {
84
+ __t4s_required?: boolean;
85
+ pluginOptions?: any;
86
+ required?: boolean;
87
+ type?: "richtext";
88
+ }>;
89
+ export type RichTextAttribute = z.infer<typeof richTextAttribute>;
90
+ export declare const blocksAttribute: z.ZodObject<{
91
+ pluginOptions: z.ZodOptional<z.ZodAny>;
92
+ required: z.ZodOptional<z.ZodBoolean>;
93
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
94
+ } & {
95
+ type: z.ZodLiteral<"blocks">;
96
+ }, "strip", z.ZodTypeAny, {
97
+ __t4s_required?: boolean;
98
+ pluginOptions?: any;
99
+ required?: boolean;
100
+ type?: "blocks";
101
+ }, {
102
+ __t4s_required?: boolean;
103
+ pluginOptions?: any;
104
+ required?: boolean;
105
+ type?: "blocks";
106
+ }>;
107
+ export declare const jsonAttribute: z.ZodObject<{
108
+ pluginOptions: z.ZodOptional<z.ZodAny>;
109
+ required: z.ZodOptional<z.ZodBoolean>;
110
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
111
+ } & {
112
+ type: z.ZodLiteral<"json">;
113
+ }, "strip", z.ZodTypeAny, {
114
+ __t4s_required?: boolean;
115
+ pluginOptions?: any;
116
+ required?: boolean;
117
+ type?: "json";
118
+ }, {
119
+ __t4s_required?: boolean;
120
+ pluginOptions?: any;
121
+ required?: boolean;
122
+ type?: "json";
123
+ }>;
124
+ export type JsonAttribute = z.infer<typeof jsonAttribute>;
125
+ export declare const passwordAttribute: z.ZodObject<{
126
+ pluginOptions: z.ZodOptional<z.ZodAny>;
127
+ required: z.ZodOptional<z.ZodBoolean>;
128
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
129
+ } & {
130
+ type: z.ZodLiteral<"password">;
131
+ }, "strip", z.ZodTypeAny, {
132
+ __t4s_required?: boolean;
133
+ pluginOptions?: any;
134
+ required?: boolean;
135
+ type?: "password";
136
+ }, {
137
+ __t4s_required?: boolean;
138
+ pluginOptions?: any;
139
+ required?: boolean;
140
+ type?: "password";
141
+ }>;
142
+ export type PasswordAttribute = z.infer<typeof passwordAttribute>;
143
+ export declare const integerAttribute: z.ZodObject<{
144
+ pluginOptions: z.ZodOptional<z.ZodAny>;
145
+ required: z.ZodOptional<z.ZodBoolean>;
146
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
147
+ } & {
148
+ type: z.ZodLiteral<"integer">;
149
+ }, "strip", z.ZodTypeAny, {
150
+ __t4s_required?: boolean;
151
+ pluginOptions?: any;
152
+ required?: boolean;
153
+ type?: "integer";
154
+ }, {
155
+ __t4s_required?: boolean;
156
+ pluginOptions?: any;
157
+ required?: boolean;
158
+ type?: "integer";
159
+ }>;
160
+ export declare const floatAttribute: z.ZodObject<{
161
+ pluginOptions: z.ZodOptional<z.ZodAny>;
162
+ required: z.ZodOptional<z.ZodBoolean>;
163
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
164
+ } & {
165
+ type: z.ZodLiteral<"float">;
166
+ }, "strip", z.ZodTypeAny, {
167
+ __t4s_required?: boolean;
168
+ pluginOptions?: any;
169
+ required?: boolean;
170
+ type?: "float";
171
+ }, {
172
+ __t4s_required?: boolean;
173
+ pluginOptions?: any;
174
+ required?: boolean;
175
+ type?: "float";
176
+ }>;
177
+ export declare const bigIntAttribute: z.ZodObject<{
178
+ pluginOptions: z.ZodOptional<z.ZodAny>;
179
+ required: z.ZodOptional<z.ZodBoolean>;
180
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
181
+ } & {
182
+ type: z.ZodLiteral<"biginteger">;
183
+ }, "strip", z.ZodTypeAny, {
184
+ __t4s_required?: boolean;
185
+ pluginOptions?: any;
186
+ required?: boolean;
187
+ type?: "biginteger";
188
+ }, {
189
+ __t4s_required?: boolean;
190
+ pluginOptions?: any;
191
+ required?: boolean;
192
+ type?: "biginteger";
193
+ }>;
194
+ export declare const decimalAttribute: z.ZodObject<{
195
+ pluginOptions: z.ZodOptional<z.ZodAny>;
196
+ required: z.ZodOptional<z.ZodBoolean>;
197
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
198
+ } & {
199
+ type: z.ZodLiteral<"decimal">;
200
+ }, "strip", z.ZodTypeAny, {
201
+ __t4s_required?: boolean;
202
+ pluginOptions?: any;
203
+ required?: boolean;
204
+ type?: "decimal";
205
+ }, {
206
+ __t4s_required?: boolean;
207
+ pluginOptions?: any;
208
+ required?: boolean;
209
+ type?: "decimal";
210
+ }>;
211
+ export declare const numberAttribute: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
212
+ pluginOptions: z.ZodOptional<z.ZodAny>;
213
+ required: z.ZodOptional<z.ZodBoolean>;
214
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
215
+ } & {
216
+ type: z.ZodLiteral<"integer">;
217
+ }, "strip", z.ZodTypeAny, {
218
+ __t4s_required?: boolean;
219
+ pluginOptions?: any;
220
+ required?: boolean;
221
+ type?: "integer";
222
+ }, {
223
+ __t4s_required?: boolean;
224
+ pluginOptions?: any;
225
+ required?: boolean;
226
+ type?: "integer";
227
+ }>, z.ZodObject<{
228
+ pluginOptions: z.ZodOptional<z.ZodAny>;
229
+ required: z.ZodOptional<z.ZodBoolean>;
230
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
231
+ } & {
232
+ type: z.ZodLiteral<"float">;
233
+ }, "strip", z.ZodTypeAny, {
234
+ __t4s_required?: boolean;
235
+ pluginOptions?: any;
236
+ required?: boolean;
237
+ type?: "float";
238
+ }, {
239
+ __t4s_required?: boolean;
240
+ pluginOptions?: any;
241
+ required?: boolean;
242
+ type?: "float";
243
+ }>, z.ZodObject<{
244
+ pluginOptions: z.ZodOptional<z.ZodAny>;
245
+ required: z.ZodOptional<z.ZodBoolean>;
246
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
247
+ } & {
248
+ type: z.ZodLiteral<"biginteger">;
249
+ }, "strip", z.ZodTypeAny, {
250
+ __t4s_required?: boolean;
251
+ pluginOptions?: any;
252
+ required?: boolean;
253
+ type?: "biginteger";
254
+ }, {
255
+ __t4s_required?: boolean;
256
+ pluginOptions?: any;
257
+ required?: boolean;
258
+ type?: "biginteger";
259
+ }>, z.ZodObject<{
260
+ pluginOptions: z.ZodOptional<z.ZodAny>;
261
+ required: z.ZodOptional<z.ZodBoolean>;
262
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
263
+ } & {
264
+ type: z.ZodLiteral<"decimal">;
265
+ }, "strip", z.ZodTypeAny, {
266
+ __t4s_required?: boolean;
267
+ pluginOptions?: any;
268
+ required?: boolean;
269
+ type?: "decimal";
270
+ }, {
271
+ __t4s_required?: boolean;
272
+ pluginOptions?: any;
273
+ required?: boolean;
274
+ type?: "decimal";
275
+ }>]>;
276
+ export type NumberAttribute = z.infer<typeof numberAttribute>;
277
+ export declare const enumAttribute: z.ZodObject<{
278
+ pluginOptions: z.ZodOptional<z.ZodAny>;
279
+ required: z.ZodOptional<z.ZodBoolean>;
280
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
281
+ } & {
282
+ type: z.ZodLiteral<"enumeration">;
283
+ enum: z.ZodArray<z.ZodString, "many">;
284
+ }, "strip", z.ZodTypeAny, {
285
+ __t4s_required?: boolean;
286
+ pluginOptions?: any;
287
+ required?: boolean;
288
+ type?: "enumeration";
289
+ enum?: string[];
290
+ }, {
291
+ __t4s_required?: boolean;
292
+ pluginOptions?: any;
293
+ required?: boolean;
294
+ type?: "enumeration";
295
+ enum?: string[];
296
+ }>;
297
+ export type EnumAttribute = z.infer<typeof enumAttribute>;
298
+ export declare const dateOnlyAttribute: z.ZodObject<{
299
+ pluginOptions: z.ZodOptional<z.ZodAny>;
300
+ required: z.ZodOptional<z.ZodBoolean>;
301
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
302
+ } & {
303
+ type: z.ZodLiteral<"date">;
304
+ }, "strip", z.ZodTypeAny, {
305
+ __t4s_required?: boolean;
306
+ pluginOptions?: any;
307
+ required?: boolean;
308
+ type?: "date";
309
+ }, {
310
+ __t4s_required?: boolean;
311
+ pluginOptions?: any;
312
+ required?: boolean;
313
+ type?: "date";
314
+ }>;
315
+ export declare const dateTimeAttribute: z.ZodObject<{
316
+ pluginOptions: z.ZodOptional<z.ZodAny>;
317
+ required: z.ZodOptional<z.ZodBoolean>;
318
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
319
+ } & {
320
+ type: z.ZodLiteral<"datetime">;
321
+ }, "strip", z.ZodTypeAny, {
322
+ __t4s_required?: boolean;
323
+ pluginOptions?: any;
324
+ required?: boolean;
325
+ type?: "datetime";
326
+ }, {
327
+ __t4s_required?: boolean;
328
+ pluginOptions?: any;
329
+ required?: boolean;
330
+ type?: "datetime";
331
+ }>;
332
+ export declare const timeAttribute: z.ZodObject<{
333
+ pluginOptions: z.ZodOptional<z.ZodAny>;
334
+ required: z.ZodOptional<z.ZodBoolean>;
335
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
336
+ } & {
337
+ type: z.ZodLiteral<"time">;
338
+ }, "strip", z.ZodTypeAny, {
339
+ __t4s_required?: boolean;
340
+ pluginOptions?: any;
341
+ required?: boolean;
342
+ type?: "time";
343
+ }, {
344
+ __t4s_required?: boolean;
345
+ pluginOptions?: any;
346
+ required?: boolean;
347
+ type?: "time";
348
+ }>;
349
+ export declare const dateAttribute: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
350
+ pluginOptions: z.ZodOptional<z.ZodAny>;
351
+ required: z.ZodOptional<z.ZodBoolean>;
352
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
353
+ } & {
354
+ type: z.ZodLiteral<"date">;
355
+ }, "strip", z.ZodTypeAny, {
356
+ __t4s_required?: boolean;
357
+ pluginOptions?: any;
358
+ required?: boolean;
359
+ type?: "date";
360
+ }, {
361
+ __t4s_required?: boolean;
362
+ pluginOptions?: any;
363
+ required?: boolean;
364
+ type?: "date";
365
+ }>, z.ZodObject<{
366
+ pluginOptions: z.ZodOptional<z.ZodAny>;
367
+ required: z.ZodOptional<z.ZodBoolean>;
368
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
369
+ } & {
370
+ type: z.ZodLiteral<"datetime">;
371
+ }, "strip", z.ZodTypeAny, {
372
+ __t4s_required?: boolean;
373
+ pluginOptions?: any;
374
+ required?: boolean;
375
+ type?: "datetime";
376
+ }, {
377
+ __t4s_required?: boolean;
378
+ pluginOptions?: any;
379
+ required?: boolean;
380
+ type?: "datetime";
381
+ }>, z.ZodObject<{
382
+ pluginOptions: z.ZodOptional<z.ZodAny>;
383
+ required: z.ZodOptional<z.ZodBoolean>;
384
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
385
+ } & {
386
+ type: z.ZodLiteral<"time">;
387
+ }, "strip", z.ZodTypeAny, {
388
+ __t4s_required?: boolean;
389
+ pluginOptions?: any;
390
+ required?: boolean;
391
+ type?: "time";
392
+ }, {
393
+ __t4s_required?: boolean;
394
+ pluginOptions?: any;
395
+ required?: boolean;
396
+ type?: "time";
397
+ }>]>;
398
+ export type DateAttribute = z.infer<typeof dateAttribute>;
399
+ export declare const mediaAttribute: z.ZodObject<{
400
+ pluginOptions: z.ZodOptional<z.ZodAny>;
401
+ required: z.ZodOptional<z.ZodBoolean>;
402
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
403
+ } & {
404
+ type: z.ZodLiteral<"media">;
405
+ multiple: z.ZodOptional<z.ZodBoolean>;
406
+ allowedTypes: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<["images", "videos", "audios", "files"]>, "many">>>;
407
+ }, "strip", z.ZodTypeAny, {
408
+ __t4s_required?: boolean;
409
+ pluginOptions?: any;
410
+ required?: boolean;
411
+ type?: "media";
412
+ multiple?: boolean;
413
+ allowedTypes?: ("images" | "videos" | "audios" | "files")[];
414
+ }, {
415
+ __t4s_required?: boolean;
416
+ pluginOptions?: any;
417
+ required?: boolean;
418
+ type?: "media";
419
+ multiple?: boolean;
420
+ allowedTypes?: ("images" | "videos" | "audios" | "files")[];
421
+ }>;
422
+ export type MediaAttribute = z.infer<typeof mediaAttribute>;
423
+ export declare const booleanAttribute: z.ZodObject<{
424
+ pluginOptions: z.ZodOptional<z.ZodAny>;
425
+ required: z.ZodOptional<z.ZodBoolean>;
426
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
427
+ } & {
428
+ type: z.ZodLiteral<"boolean">;
429
+ }, "strip", z.ZodTypeAny, {
430
+ __t4s_required?: boolean;
431
+ pluginOptions?: any;
432
+ required?: boolean;
433
+ type?: "boolean";
434
+ }, {
435
+ __t4s_required?: boolean;
436
+ pluginOptions?: any;
437
+ required?: boolean;
438
+ type?: "boolean";
439
+ }>;
440
+ export type BooleanAttribute = z.infer<typeof booleanAttribute>;
441
+ export declare const baseRelationAttribute: z.ZodObject<{
442
+ pluginOptions: z.ZodOptional<z.ZodAny>;
443
+ required: z.ZodOptional<z.ZodBoolean>;
444
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
445
+ } & {
446
+ type: z.ZodLiteral<"relation">;
447
+ target: z.ZodString;
448
+ }, "strip", z.ZodTypeAny, {
449
+ __t4s_required?: boolean;
450
+ pluginOptions?: any;
451
+ required?: boolean;
452
+ type?: "relation";
453
+ target?: string;
454
+ }, {
455
+ __t4s_required?: boolean;
456
+ pluginOptions?: any;
457
+ required?: boolean;
458
+ type?: "relation";
459
+ target?: string;
460
+ }>;
461
+ export declare const hasOneAttribute: z.ZodObject<{
462
+ pluginOptions: z.ZodOptional<z.ZodAny>;
463
+ required: z.ZodOptional<z.ZodBoolean>;
464
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
465
+ } & {
466
+ type: z.ZodLiteral<"relation">;
467
+ target: z.ZodString;
468
+ } & {
469
+ relation: z.ZodLiteral<"oneToOne">;
470
+ }, "strip", z.ZodTypeAny, {
471
+ __t4s_required?: boolean;
472
+ pluginOptions?: any;
473
+ required?: boolean;
474
+ type?: "relation";
475
+ relation?: "oneToOne";
476
+ target?: string;
477
+ }, {
478
+ __t4s_required?: boolean;
479
+ pluginOptions?: any;
480
+ required?: boolean;
481
+ type?: "relation";
482
+ relation?: "oneToOne";
483
+ target?: string;
484
+ }>;
485
+ export declare const oneToOneAttribute: z.ZodObject<{
486
+ pluginOptions: z.ZodOptional<z.ZodAny>;
487
+ required: z.ZodOptional<z.ZodBoolean>;
488
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
489
+ } & {
490
+ type: z.ZodLiteral<"relation">;
491
+ target: z.ZodString;
492
+ } & {
493
+ relation: z.ZodLiteral<"oneToOne">;
494
+ inversedBy: z.ZodString;
495
+ }, "strip", z.ZodTypeAny, {
496
+ __t4s_required?: boolean;
497
+ pluginOptions?: any;
498
+ required?: boolean;
499
+ type?: "relation";
500
+ relation?: "oneToOne";
501
+ target?: string;
502
+ inversedBy?: string;
503
+ }, {
504
+ __t4s_required?: boolean;
505
+ pluginOptions?: any;
506
+ required?: boolean;
507
+ type?: "relation";
508
+ relation?: "oneToOne";
509
+ target?: string;
510
+ inversedBy?: string;
511
+ }>;
512
+ export declare const belongsToManyAttribute: z.ZodObject<{
513
+ pluginOptions: z.ZodOptional<z.ZodAny>;
514
+ required: z.ZodOptional<z.ZodBoolean>;
515
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
516
+ } & {
517
+ type: z.ZodLiteral<"relation">;
518
+ target: z.ZodString;
519
+ } & {
520
+ mappedBy: z.ZodString;
521
+ relation: z.ZodLiteral<"oneToMany">;
522
+ }, "strip", z.ZodTypeAny, {
523
+ __t4s_required?: boolean;
524
+ pluginOptions?: any;
525
+ required?: boolean;
526
+ type?: "relation";
527
+ relation?: "oneToMany";
528
+ target?: string;
529
+ mappedBy?: string;
530
+ }, {
531
+ __t4s_required?: boolean;
532
+ pluginOptions?: any;
533
+ required?: boolean;
534
+ type?: "relation";
535
+ relation?: "oneToMany";
536
+ target?: string;
537
+ mappedBy?: string;
538
+ }>;
539
+ export declare const manyToOneAttribute: z.ZodObject<{
540
+ pluginOptions: z.ZodOptional<z.ZodAny>;
541
+ required: z.ZodOptional<z.ZodBoolean>;
542
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
543
+ } & {
544
+ type: z.ZodLiteral<"relation">;
545
+ target: z.ZodString;
546
+ } & {
547
+ relation: z.ZodLiteral<"manyToOne">;
548
+ inversedBy: z.ZodString;
549
+ }, "strip", z.ZodTypeAny, {
550
+ __t4s_required?: boolean;
551
+ pluginOptions?: any;
552
+ required?: boolean;
553
+ type?: "relation";
554
+ relation?: "manyToOne";
555
+ target?: string;
556
+ inversedBy?: string;
557
+ }, {
558
+ __t4s_required?: boolean;
559
+ pluginOptions?: any;
560
+ required?: boolean;
561
+ type?: "relation";
562
+ relation?: "manyToOne";
563
+ target?: string;
564
+ inversedBy?: string;
565
+ }>;
566
+ export declare const manyToManyAttribute: z.ZodObject<{
567
+ pluginOptions: z.ZodOptional<z.ZodAny>;
568
+ required: z.ZodOptional<z.ZodBoolean>;
569
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
570
+ } & {
571
+ type: z.ZodLiteral<"relation">;
572
+ target: z.ZodString;
573
+ } & {
574
+ relation: z.ZodLiteral<"manyToMany">;
575
+ inversedBy: z.ZodOptional<z.ZodString>;
576
+ mappedBy: z.ZodOptional<z.ZodString>;
577
+ }, "strip", z.ZodTypeAny, {
578
+ __t4s_required?: boolean;
579
+ pluginOptions?: any;
580
+ required?: boolean;
581
+ type?: "relation";
582
+ relation?: "manyToMany";
583
+ target?: string;
584
+ inversedBy?: string;
585
+ mappedBy?: string;
586
+ }, {
587
+ __t4s_required?: boolean;
588
+ pluginOptions?: any;
589
+ required?: boolean;
590
+ type?: "relation";
591
+ relation?: "manyToMany";
592
+ target?: string;
593
+ inversedBy?: string;
594
+ mappedBy?: string;
595
+ }>;
596
+ export declare const hasManyAttribute: z.ZodObject<{
597
+ pluginOptions: z.ZodOptional<z.ZodAny>;
598
+ required: z.ZodOptional<z.ZodBoolean>;
599
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
600
+ } & {
601
+ type: z.ZodLiteral<"relation">;
602
+ target: z.ZodString;
603
+ } & {
604
+ relation: z.ZodLiteral<"oneToMany">;
605
+ }, "strip", z.ZodTypeAny, {
606
+ __t4s_required?: boolean;
607
+ pluginOptions?: any;
608
+ required?: boolean;
609
+ type?: "relation";
610
+ relation?: "oneToMany";
611
+ target?: string;
612
+ }, {
613
+ __t4s_required?: boolean;
614
+ pluginOptions?: any;
615
+ required?: boolean;
616
+ type?: "relation";
617
+ relation?: "oneToMany";
618
+ target?: string;
619
+ }>;
620
+ export declare const morphToManyAttribute: z.ZodObject<{
621
+ pluginOptions: z.ZodOptional<z.ZodAny>;
622
+ required: z.ZodOptional<z.ZodBoolean>;
623
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
624
+ } & {
625
+ type: z.ZodLiteral<"relation">;
626
+ relation: z.ZodLiteral<"morphToMany">;
627
+ }, "strip", z.ZodTypeAny, {
628
+ __t4s_required?: boolean;
629
+ pluginOptions?: any;
630
+ required?: boolean;
631
+ type?: "relation";
632
+ relation?: "morphToMany";
633
+ }, {
634
+ __t4s_required?: boolean;
635
+ pluginOptions?: any;
636
+ required?: boolean;
637
+ type?: "relation";
638
+ relation?: "morphToMany";
639
+ }>;
640
+ export declare const morphOneAttribute: z.ZodObject<{
641
+ pluginOptions: z.ZodOptional<z.ZodAny>;
642
+ required: z.ZodOptional<z.ZodBoolean>;
643
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
644
+ } & {
645
+ type: z.ZodLiteral<"relation">;
646
+ relation: z.ZodLiteral<"morphToOne">;
647
+ }, "strip", z.ZodTypeAny, {
648
+ __t4s_required?: boolean;
649
+ pluginOptions?: any;
650
+ required?: boolean;
651
+ type?: "relation";
652
+ relation?: "morphToOne";
653
+ }, {
654
+ __t4s_required?: boolean;
655
+ pluginOptions?: any;
656
+ required?: boolean;
657
+ type?: "relation";
658
+ relation?: "morphToOne";
659
+ }>;
660
+ export declare const relationAttribute: z.ZodUnion<[z.ZodObject<{
661
+ pluginOptions: z.ZodOptional<z.ZodAny>;
662
+ required: z.ZodOptional<z.ZodBoolean>;
663
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
664
+ } & {
665
+ type: z.ZodLiteral<"relation">;
666
+ target: z.ZodString;
667
+ } & {
668
+ relation: z.ZodLiteral<"oneToOne">;
669
+ }, "strip", z.ZodTypeAny, {
670
+ __t4s_required?: boolean;
671
+ pluginOptions?: any;
672
+ required?: boolean;
673
+ type?: "relation";
674
+ relation?: "oneToOne";
675
+ target?: string;
676
+ }, {
677
+ __t4s_required?: boolean;
678
+ pluginOptions?: any;
679
+ required?: boolean;
680
+ type?: "relation";
681
+ relation?: "oneToOne";
682
+ target?: string;
683
+ }>, z.ZodObject<{
684
+ pluginOptions: z.ZodOptional<z.ZodAny>;
685
+ required: z.ZodOptional<z.ZodBoolean>;
686
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
687
+ } & {
688
+ type: z.ZodLiteral<"relation">;
689
+ target: z.ZodString;
690
+ } & {
691
+ relation: z.ZodLiteral<"oneToOne">;
692
+ inversedBy: z.ZodString;
693
+ }, "strip", z.ZodTypeAny, {
694
+ __t4s_required?: boolean;
695
+ pluginOptions?: any;
696
+ required?: boolean;
697
+ type?: "relation";
698
+ relation?: "oneToOne";
699
+ target?: string;
700
+ inversedBy?: string;
701
+ }, {
702
+ __t4s_required?: boolean;
703
+ pluginOptions?: any;
704
+ required?: boolean;
705
+ type?: "relation";
706
+ relation?: "oneToOne";
707
+ target?: string;
708
+ inversedBy?: string;
709
+ }>, z.ZodObject<{
710
+ pluginOptions: z.ZodOptional<z.ZodAny>;
711
+ required: z.ZodOptional<z.ZodBoolean>;
712
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
713
+ } & {
714
+ type: z.ZodLiteral<"relation">;
715
+ target: z.ZodString;
716
+ } & {
717
+ mappedBy: z.ZodString;
718
+ relation: z.ZodLiteral<"oneToMany">;
719
+ }, "strip", z.ZodTypeAny, {
720
+ __t4s_required?: boolean;
721
+ pluginOptions?: any;
722
+ required?: boolean;
723
+ type?: "relation";
724
+ relation?: "oneToMany";
725
+ target?: string;
726
+ mappedBy?: string;
727
+ }, {
728
+ __t4s_required?: boolean;
729
+ pluginOptions?: any;
730
+ required?: boolean;
731
+ type?: "relation";
732
+ relation?: "oneToMany";
733
+ target?: string;
734
+ mappedBy?: string;
735
+ }>, z.ZodObject<{
736
+ pluginOptions: z.ZodOptional<z.ZodAny>;
737
+ required: z.ZodOptional<z.ZodBoolean>;
738
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
739
+ } & {
740
+ type: z.ZodLiteral<"relation">;
741
+ target: z.ZodString;
742
+ } & {
743
+ relation: z.ZodLiteral<"manyToOne">;
744
+ inversedBy: z.ZodString;
745
+ }, "strip", z.ZodTypeAny, {
746
+ __t4s_required?: boolean;
747
+ pluginOptions?: any;
748
+ required?: boolean;
749
+ type?: "relation";
750
+ relation?: "manyToOne";
751
+ target?: string;
752
+ inversedBy?: string;
753
+ }, {
754
+ __t4s_required?: boolean;
755
+ pluginOptions?: any;
756
+ required?: boolean;
757
+ type?: "relation";
758
+ relation?: "manyToOne";
759
+ target?: string;
760
+ inversedBy?: string;
761
+ }>, z.ZodObject<{
762
+ pluginOptions: z.ZodOptional<z.ZodAny>;
763
+ required: z.ZodOptional<z.ZodBoolean>;
764
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
765
+ } & {
766
+ type: z.ZodLiteral<"relation">;
767
+ target: z.ZodString;
768
+ } & {
769
+ relation: z.ZodLiteral<"manyToMany">;
770
+ inversedBy: z.ZodOptional<z.ZodString>;
771
+ mappedBy: z.ZodOptional<z.ZodString>;
772
+ }, "strip", z.ZodTypeAny, {
773
+ __t4s_required?: boolean;
774
+ pluginOptions?: any;
775
+ required?: boolean;
776
+ type?: "relation";
777
+ relation?: "manyToMany";
778
+ target?: string;
779
+ inversedBy?: string;
780
+ mappedBy?: string;
781
+ }, {
782
+ __t4s_required?: boolean;
783
+ pluginOptions?: any;
784
+ required?: boolean;
785
+ type?: "relation";
786
+ relation?: "manyToMany";
787
+ target?: string;
788
+ inversedBy?: string;
789
+ mappedBy?: string;
790
+ }>, z.ZodObject<{
791
+ pluginOptions: z.ZodOptional<z.ZodAny>;
792
+ required: z.ZodOptional<z.ZodBoolean>;
793
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
794
+ } & {
795
+ type: z.ZodLiteral<"relation">;
796
+ target: z.ZodString;
797
+ } & {
798
+ relation: z.ZodLiteral<"oneToMany">;
799
+ }, "strip", z.ZodTypeAny, {
800
+ __t4s_required?: boolean;
801
+ pluginOptions?: any;
802
+ required?: boolean;
803
+ type?: "relation";
804
+ relation?: "oneToMany";
805
+ target?: string;
806
+ }, {
807
+ __t4s_required?: boolean;
808
+ pluginOptions?: any;
809
+ required?: boolean;
810
+ type?: "relation";
811
+ relation?: "oneToMany";
812
+ target?: string;
813
+ }>, z.ZodObject<{
814
+ pluginOptions: z.ZodOptional<z.ZodAny>;
815
+ required: z.ZodOptional<z.ZodBoolean>;
816
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
817
+ } & {
818
+ type: z.ZodLiteral<"relation">;
819
+ relation: z.ZodLiteral<"morphToMany">;
820
+ }, "strip", z.ZodTypeAny, {
821
+ __t4s_required?: boolean;
822
+ pluginOptions?: any;
823
+ required?: boolean;
824
+ type?: "relation";
825
+ relation?: "morphToMany";
826
+ }, {
827
+ __t4s_required?: boolean;
828
+ pluginOptions?: any;
829
+ required?: boolean;
830
+ type?: "relation";
831
+ relation?: "morphToMany";
832
+ }>, z.ZodObject<{
833
+ pluginOptions: z.ZodOptional<z.ZodAny>;
834
+ required: z.ZodOptional<z.ZodBoolean>;
835
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
836
+ } & {
837
+ type: z.ZodLiteral<"relation">;
838
+ relation: z.ZodLiteral<"morphToOne">;
839
+ }, "strip", z.ZodTypeAny, {
840
+ __t4s_required?: boolean;
841
+ pluginOptions?: any;
842
+ required?: boolean;
843
+ type?: "relation";
844
+ relation?: "morphToOne";
845
+ }, {
846
+ __t4s_required?: boolean;
847
+ pluginOptions?: any;
848
+ required?: boolean;
849
+ type?: "relation";
850
+ relation?: "morphToOne";
851
+ }>]>;
852
+ export type RelationAttribute = z.infer<typeof relationAttribute>;
853
+ export declare const componentAttribute: z.ZodObject<{
854
+ pluginOptions: z.ZodOptional<z.ZodAny>;
855
+ required: z.ZodOptional<z.ZodBoolean>;
856
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
857
+ } & {
858
+ type: z.ZodLiteral<"component">;
859
+ repeatable: z.ZodOptional<z.ZodBoolean>;
860
+ component: z.ZodString;
861
+ }, "strip", z.ZodTypeAny, {
862
+ __t4s_required?: boolean;
863
+ pluginOptions?: any;
864
+ required?: boolean;
865
+ type?: "component";
866
+ component?: string;
867
+ repeatable?: boolean;
868
+ }, {
869
+ __t4s_required?: boolean;
870
+ pluginOptions?: any;
871
+ required?: boolean;
872
+ type?: "component";
873
+ component?: string;
874
+ repeatable?: boolean;
875
+ }>;
876
+ export type ComponentAttribute = z.infer<typeof componentAttribute>;
877
+ export declare const dynamiczoneAttribute: z.ZodObject<{
878
+ pluginOptions: z.ZodOptional<z.ZodAny>;
879
+ required: z.ZodOptional<z.ZodBoolean>;
880
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
881
+ } & {
882
+ type: z.ZodLiteral<"dynamiczone">;
883
+ components: z.ZodArray<z.ZodString, "many">;
884
+ }, "strip", z.ZodTypeAny, {
885
+ __t4s_required?: boolean;
886
+ pluginOptions?: any;
887
+ required?: boolean;
888
+ type?: "dynamiczone";
889
+ components?: string[];
890
+ }, {
891
+ __t4s_required?: boolean;
892
+ pluginOptions?: any;
893
+ required?: boolean;
894
+ type?: "dynamiczone";
895
+ components?: string[];
896
+ }>;
897
+ export type DynamiczoneAttribute = z.infer<typeof dynamiczoneAttribute>;
898
+ export declare const knownAttribute: z.ZodUnion<[z.ZodObject<{
899
+ pluginOptions: z.ZodOptional<z.ZodAny>;
900
+ required: z.ZodOptional<z.ZodBoolean>;
901
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
902
+ } & {
903
+ type: z.ZodEnum<["text", "string"]>;
904
+ }, "strip", z.ZodTypeAny, {
905
+ __t4s_required?: boolean;
906
+ pluginOptions?: any;
907
+ required?: boolean;
908
+ type?: "string" | "text";
909
+ }, {
910
+ __t4s_required?: boolean;
911
+ pluginOptions?: any;
912
+ required?: boolean;
913
+ type?: "string" | "text";
914
+ }>, z.ZodObject<{
915
+ pluginOptions: z.ZodOptional<z.ZodAny>;
916
+ required: z.ZodOptional<z.ZodBoolean>;
917
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
918
+ } & {
919
+ type: z.ZodLiteral<"email">;
920
+ }, "strip", z.ZodTypeAny, {
921
+ __t4s_required?: boolean;
922
+ pluginOptions?: any;
923
+ required?: boolean;
924
+ type?: "email";
925
+ }, {
926
+ __t4s_required?: boolean;
927
+ pluginOptions?: any;
928
+ required?: boolean;
929
+ type?: "email";
930
+ }>, z.ZodObject<{
931
+ pluginOptions: z.ZodOptional<z.ZodAny>;
932
+ required: z.ZodOptional<z.ZodBoolean>;
933
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
934
+ } & {
935
+ type: z.ZodLiteral<"uid">;
936
+ targetField: z.ZodOptional<z.ZodString>;
937
+ }, "strip", z.ZodTypeAny, {
938
+ __t4s_required?: boolean;
939
+ pluginOptions?: any;
940
+ required?: boolean;
941
+ type?: "uid";
942
+ targetField?: string;
943
+ }, {
944
+ __t4s_required?: boolean;
945
+ pluginOptions?: any;
946
+ required?: boolean;
947
+ type?: "uid";
948
+ targetField?: string;
949
+ }>, z.ZodObject<{
950
+ pluginOptions: z.ZodOptional<z.ZodAny>;
951
+ required: z.ZodOptional<z.ZodBoolean>;
952
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
953
+ } & {
954
+ type: z.ZodLiteral<"richtext">;
955
+ }, "strip", z.ZodTypeAny, {
956
+ __t4s_required?: boolean;
957
+ pluginOptions?: any;
958
+ required?: boolean;
959
+ type?: "richtext";
960
+ }, {
961
+ __t4s_required?: boolean;
962
+ pluginOptions?: any;
963
+ required?: boolean;
964
+ type?: "richtext";
965
+ }>, z.ZodObject<{
966
+ pluginOptions: z.ZodOptional<z.ZodAny>;
967
+ required: z.ZodOptional<z.ZodBoolean>;
968
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
969
+ } & {
970
+ type: z.ZodLiteral<"blocks">;
971
+ }, "strip", z.ZodTypeAny, {
972
+ __t4s_required?: boolean;
973
+ pluginOptions?: any;
974
+ required?: boolean;
975
+ type?: "blocks";
976
+ }, {
977
+ __t4s_required?: boolean;
978
+ pluginOptions?: any;
979
+ required?: boolean;
980
+ type?: "blocks";
981
+ }>, z.ZodObject<{
982
+ pluginOptions: z.ZodOptional<z.ZodAny>;
983
+ required: z.ZodOptional<z.ZodBoolean>;
984
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
985
+ } & {
986
+ type: z.ZodLiteral<"json">;
987
+ }, "strip", z.ZodTypeAny, {
988
+ __t4s_required?: boolean;
989
+ pluginOptions?: any;
990
+ required?: boolean;
991
+ type?: "json";
992
+ }, {
993
+ __t4s_required?: boolean;
994
+ pluginOptions?: any;
995
+ required?: boolean;
996
+ type?: "json";
997
+ }>, z.ZodObject<{
998
+ pluginOptions: z.ZodOptional<z.ZodAny>;
999
+ required: z.ZodOptional<z.ZodBoolean>;
1000
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1001
+ } & {
1002
+ type: z.ZodLiteral<"password">;
1003
+ }, "strip", z.ZodTypeAny, {
1004
+ __t4s_required?: boolean;
1005
+ pluginOptions?: any;
1006
+ required?: boolean;
1007
+ type?: "password";
1008
+ }, {
1009
+ __t4s_required?: boolean;
1010
+ pluginOptions?: any;
1011
+ required?: boolean;
1012
+ type?: "password";
1013
+ }>, z.ZodObject<{
1014
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1015
+ required: z.ZodOptional<z.ZodBoolean>;
1016
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1017
+ } & {
1018
+ type: z.ZodLiteral<"integer">;
1019
+ }, "strip", z.ZodTypeAny, {
1020
+ __t4s_required?: boolean;
1021
+ pluginOptions?: any;
1022
+ required?: boolean;
1023
+ type?: "integer";
1024
+ }, {
1025
+ __t4s_required?: boolean;
1026
+ pluginOptions?: any;
1027
+ required?: boolean;
1028
+ type?: "integer";
1029
+ }>, z.ZodObject<{
1030
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1031
+ required: z.ZodOptional<z.ZodBoolean>;
1032
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1033
+ } & {
1034
+ type: z.ZodLiteral<"float">;
1035
+ }, "strip", z.ZodTypeAny, {
1036
+ __t4s_required?: boolean;
1037
+ pluginOptions?: any;
1038
+ required?: boolean;
1039
+ type?: "float";
1040
+ }, {
1041
+ __t4s_required?: boolean;
1042
+ pluginOptions?: any;
1043
+ required?: boolean;
1044
+ type?: "float";
1045
+ }>, z.ZodObject<{
1046
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1047
+ required: z.ZodOptional<z.ZodBoolean>;
1048
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1049
+ } & {
1050
+ type: z.ZodLiteral<"biginteger">;
1051
+ }, "strip", z.ZodTypeAny, {
1052
+ __t4s_required?: boolean;
1053
+ pluginOptions?: any;
1054
+ required?: boolean;
1055
+ type?: "biginteger";
1056
+ }, {
1057
+ __t4s_required?: boolean;
1058
+ pluginOptions?: any;
1059
+ required?: boolean;
1060
+ type?: "biginteger";
1061
+ }>, z.ZodObject<{
1062
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1063
+ required: z.ZodOptional<z.ZodBoolean>;
1064
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1065
+ } & {
1066
+ type: z.ZodLiteral<"decimal">;
1067
+ }, "strip", z.ZodTypeAny, {
1068
+ __t4s_required?: boolean;
1069
+ pluginOptions?: any;
1070
+ required?: boolean;
1071
+ type?: "decimal";
1072
+ }, {
1073
+ __t4s_required?: boolean;
1074
+ pluginOptions?: any;
1075
+ required?: boolean;
1076
+ type?: "decimal";
1077
+ }>, z.ZodObject<{
1078
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1079
+ required: z.ZodOptional<z.ZodBoolean>;
1080
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1081
+ } & {
1082
+ type: z.ZodLiteral<"enumeration">;
1083
+ enum: z.ZodArray<z.ZodString, "many">;
1084
+ }, "strip", z.ZodTypeAny, {
1085
+ __t4s_required?: boolean;
1086
+ pluginOptions?: any;
1087
+ required?: boolean;
1088
+ type?: "enumeration";
1089
+ enum?: string[];
1090
+ }, {
1091
+ __t4s_required?: boolean;
1092
+ pluginOptions?: any;
1093
+ required?: boolean;
1094
+ type?: "enumeration";
1095
+ enum?: string[];
1096
+ }>, z.ZodObject<{
1097
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1098
+ required: z.ZodOptional<z.ZodBoolean>;
1099
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1100
+ } & {
1101
+ type: z.ZodLiteral<"date">;
1102
+ }, "strip", z.ZodTypeAny, {
1103
+ __t4s_required?: boolean;
1104
+ pluginOptions?: any;
1105
+ required?: boolean;
1106
+ type?: "date";
1107
+ }, {
1108
+ __t4s_required?: boolean;
1109
+ pluginOptions?: any;
1110
+ required?: boolean;
1111
+ type?: "date";
1112
+ }>, z.ZodObject<{
1113
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1114
+ required: z.ZodOptional<z.ZodBoolean>;
1115
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1116
+ } & {
1117
+ type: z.ZodLiteral<"datetime">;
1118
+ }, "strip", z.ZodTypeAny, {
1119
+ __t4s_required?: boolean;
1120
+ pluginOptions?: any;
1121
+ required?: boolean;
1122
+ type?: "datetime";
1123
+ }, {
1124
+ __t4s_required?: boolean;
1125
+ pluginOptions?: any;
1126
+ required?: boolean;
1127
+ type?: "datetime";
1128
+ }>, z.ZodObject<{
1129
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1130
+ required: z.ZodOptional<z.ZodBoolean>;
1131
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1132
+ } & {
1133
+ type: z.ZodLiteral<"time">;
1134
+ }, "strip", z.ZodTypeAny, {
1135
+ __t4s_required?: boolean;
1136
+ pluginOptions?: any;
1137
+ required?: boolean;
1138
+ type?: "time";
1139
+ }, {
1140
+ __t4s_required?: boolean;
1141
+ pluginOptions?: any;
1142
+ required?: boolean;
1143
+ type?: "time";
1144
+ }>, z.ZodObject<{
1145
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1146
+ required: z.ZodOptional<z.ZodBoolean>;
1147
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1148
+ } & {
1149
+ type: z.ZodLiteral<"media">;
1150
+ multiple: z.ZodOptional<z.ZodBoolean>;
1151
+ allowedTypes: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<["images", "videos", "audios", "files"]>, "many">>>;
1152
+ }, "strip", z.ZodTypeAny, {
1153
+ __t4s_required?: boolean;
1154
+ pluginOptions?: any;
1155
+ required?: boolean;
1156
+ type?: "media";
1157
+ multiple?: boolean;
1158
+ allowedTypes?: ("images" | "videos" | "audios" | "files")[];
1159
+ }, {
1160
+ __t4s_required?: boolean;
1161
+ pluginOptions?: any;
1162
+ required?: boolean;
1163
+ type?: "media";
1164
+ multiple?: boolean;
1165
+ allowedTypes?: ("images" | "videos" | "audios" | "files")[];
1166
+ }>, z.ZodObject<{
1167
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1168
+ required: z.ZodOptional<z.ZodBoolean>;
1169
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1170
+ } & {
1171
+ type: z.ZodLiteral<"boolean">;
1172
+ }, "strip", z.ZodTypeAny, {
1173
+ __t4s_required?: boolean;
1174
+ pluginOptions?: any;
1175
+ required?: boolean;
1176
+ type?: "boolean";
1177
+ }, {
1178
+ __t4s_required?: boolean;
1179
+ pluginOptions?: any;
1180
+ required?: boolean;
1181
+ type?: "boolean";
1182
+ }>, z.ZodObject<{
1183
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1184
+ required: z.ZodOptional<z.ZodBoolean>;
1185
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1186
+ } & {
1187
+ type: z.ZodLiteral<"relation">;
1188
+ target: z.ZodString;
1189
+ } & {
1190
+ relation: z.ZodLiteral<"oneToOne">;
1191
+ }, "strip", z.ZodTypeAny, {
1192
+ __t4s_required?: boolean;
1193
+ pluginOptions?: any;
1194
+ required?: boolean;
1195
+ type?: "relation";
1196
+ relation?: "oneToOne";
1197
+ target?: string;
1198
+ }, {
1199
+ __t4s_required?: boolean;
1200
+ pluginOptions?: any;
1201
+ required?: boolean;
1202
+ type?: "relation";
1203
+ relation?: "oneToOne";
1204
+ target?: string;
1205
+ }>, z.ZodObject<{
1206
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1207
+ required: z.ZodOptional<z.ZodBoolean>;
1208
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1209
+ } & {
1210
+ type: z.ZodLiteral<"relation">;
1211
+ target: z.ZodString;
1212
+ } & {
1213
+ relation: z.ZodLiteral<"oneToOne">;
1214
+ inversedBy: z.ZodString;
1215
+ }, "strip", z.ZodTypeAny, {
1216
+ __t4s_required?: boolean;
1217
+ pluginOptions?: any;
1218
+ required?: boolean;
1219
+ type?: "relation";
1220
+ relation?: "oneToOne";
1221
+ target?: string;
1222
+ inversedBy?: string;
1223
+ }, {
1224
+ __t4s_required?: boolean;
1225
+ pluginOptions?: any;
1226
+ required?: boolean;
1227
+ type?: "relation";
1228
+ relation?: "oneToOne";
1229
+ target?: string;
1230
+ inversedBy?: string;
1231
+ }>, z.ZodObject<{
1232
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1233
+ required: z.ZodOptional<z.ZodBoolean>;
1234
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1235
+ } & {
1236
+ type: z.ZodLiteral<"relation">;
1237
+ target: z.ZodString;
1238
+ } & {
1239
+ mappedBy: z.ZodString;
1240
+ relation: z.ZodLiteral<"oneToMany">;
1241
+ }, "strip", z.ZodTypeAny, {
1242
+ __t4s_required?: boolean;
1243
+ pluginOptions?: any;
1244
+ required?: boolean;
1245
+ type?: "relation";
1246
+ relation?: "oneToMany";
1247
+ target?: string;
1248
+ mappedBy?: string;
1249
+ }, {
1250
+ __t4s_required?: boolean;
1251
+ pluginOptions?: any;
1252
+ required?: boolean;
1253
+ type?: "relation";
1254
+ relation?: "oneToMany";
1255
+ target?: string;
1256
+ mappedBy?: string;
1257
+ }>, z.ZodObject<{
1258
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1259
+ required: z.ZodOptional<z.ZodBoolean>;
1260
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1261
+ } & {
1262
+ type: z.ZodLiteral<"relation">;
1263
+ target: z.ZodString;
1264
+ } & {
1265
+ relation: z.ZodLiteral<"manyToOne">;
1266
+ inversedBy: z.ZodString;
1267
+ }, "strip", z.ZodTypeAny, {
1268
+ __t4s_required?: boolean;
1269
+ pluginOptions?: any;
1270
+ required?: boolean;
1271
+ type?: "relation";
1272
+ relation?: "manyToOne";
1273
+ target?: string;
1274
+ inversedBy?: string;
1275
+ }, {
1276
+ __t4s_required?: boolean;
1277
+ pluginOptions?: any;
1278
+ required?: boolean;
1279
+ type?: "relation";
1280
+ relation?: "manyToOne";
1281
+ target?: string;
1282
+ inversedBy?: string;
1283
+ }>, z.ZodObject<{
1284
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1285
+ required: z.ZodOptional<z.ZodBoolean>;
1286
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1287
+ } & {
1288
+ type: z.ZodLiteral<"relation">;
1289
+ target: z.ZodString;
1290
+ } & {
1291
+ relation: z.ZodLiteral<"manyToMany">;
1292
+ inversedBy: z.ZodOptional<z.ZodString>;
1293
+ mappedBy: z.ZodOptional<z.ZodString>;
1294
+ }, "strip", z.ZodTypeAny, {
1295
+ __t4s_required?: boolean;
1296
+ pluginOptions?: any;
1297
+ required?: boolean;
1298
+ type?: "relation";
1299
+ relation?: "manyToMany";
1300
+ target?: string;
1301
+ inversedBy?: string;
1302
+ mappedBy?: string;
1303
+ }, {
1304
+ __t4s_required?: boolean;
1305
+ pluginOptions?: any;
1306
+ required?: boolean;
1307
+ type?: "relation";
1308
+ relation?: "manyToMany";
1309
+ target?: string;
1310
+ inversedBy?: string;
1311
+ mappedBy?: string;
1312
+ }>, z.ZodObject<{
1313
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1314
+ required: z.ZodOptional<z.ZodBoolean>;
1315
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1316
+ } & {
1317
+ type: z.ZodLiteral<"relation">;
1318
+ target: z.ZodString;
1319
+ } & {
1320
+ relation: z.ZodLiteral<"oneToMany">;
1321
+ }, "strip", z.ZodTypeAny, {
1322
+ __t4s_required?: boolean;
1323
+ pluginOptions?: any;
1324
+ required?: boolean;
1325
+ type?: "relation";
1326
+ relation?: "oneToMany";
1327
+ target?: string;
1328
+ }, {
1329
+ __t4s_required?: boolean;
1330
+ pluginOptions?: any;
1331
+ required?: boolean;
1332
+ type?: "relation";
1333
+ relation?: "oneToMany";
1334
+ target?: string;
1335
+ }>, z.ZodObject<{
1336
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1337
+ required: z.ZodOptional<z.ZodBoolean>;
1338
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1339
+ } & {
1340
+ type: z.ZodLiteral<"relation">;
1341
+ relation: z.ZodLiteral<"morphToMany">;
1342
+ }, "strip", z.ZodTypeAny, {
1343
+ __t4s_required?: boolean;
1344
+ pluginOptions?: any;
1345
+ required?: boolean;
1346
+ type?: "relation";
1347
+ relation?: "morphToMany";
1348
+ }, {
1349
+ __t4s_required?: boolean;
1350
+ pluginOptions?: any;
1351
+ required?: boolean;
1352
+ type?: "relation";
1353
+ relation?: "morphToMany";
1354
+ }>, z.ZodObject<{
1355
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1356
+ required: z.ZodOptional<z.ZodBoolean>;
1357
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1358
+ } & {
1359
+ type: z.ZodLiteral<"relation">;
1360
+ relation: z.ZodLiteral<"morphToOne">;
1361
+ }, "strip", z.ZodTypeAny, {
1362
+ __t4s_required?: boolean;
1363
+ pluginOptions?: any;
1364
+ required?: boolean;
1365
+ type?: "relation";
1366
+ relation?: "morphToOne";
1367
+ }, {
1368
+ __t4s_required?: boolean;
1369
+ pluginOptions?: any;
1370
+ required?: boolean;
1371
+ type?: "relation";
1372
+ relation?: "morphToOne";
1373
+ }>, z.ZodObject<{
1374
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1375
+ required: z.ZodOptional<z.ZodBoolean>;
1376
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1377
+ } & {
1378
+ type: z.ZodLiteral<"component">;
1379
+ repeatable: z.ZodOptional<z.ZodBoolean>;
1380
+ component: z.ZodString;
1381
+ }, "strip", z.ZodTypeAny, {
1382
+ __t4s_required?: boolean;
1383
+ pluginOptions?: any;
1384
+ required?: boolean;
1385
+ type?: "component";
1386
+ component?: string;
1387
+ repeatable?: boolean;
1388
+ }, {
1389
+ __t4s_required?: boolean;
1390
+ pluginOptions?: any;
1391
+ required?: boolean;
1392
+ type?: "component";
1393
+ component?: string;
1394
+ repeatable?: boolean;
1395
+ }>]>;
1396
+ export type KnownAttribute = z.infer<typeof knownAttribute>;
1397
+ export declare const anyAttribute: z.ZodObject<{
1398
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1399
+ required: z.ZodOptional<z.ZodBoolean>;
1400
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1401
+ } & {
1402
+ type: z.ZodEffects<z.ZodType<"any", z.ZodTypeDef, "any">, "any", "any">;
1403
+ }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
1404
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1405
+ required: z.ZodOptional<z.ZodBoolean>;
1406
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1407
+ } & {
1408
+ type: z.ZodEffects<z.ZodType<"any", z.ZodTypeDef, "any">, "any", "any">;
1409
+ }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
1410
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1411
+ required: z.ZodOptional<z.ZodBoolean>;
1412
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1413
+ } & {
1414
+ type: z.ZodEffects<z.ZodType<"any", z.ZodTypeDef, "any">, "any", "any">;
1415
+ }, z.ZodTypeAny, "passthrough">>;
1416
+ export type AnyAttribute = z.infer<typeof anyAttribute>;
1417
+ export declare const attribute: z.ZodUnion<[z.ZodObject<{
1418
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1419
+ required: z.ZodOptional<z.ZodBoolean>;
1420
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1421
+ } & {
1422
+ type: z.ZodEnum<["text", "string"]>;
1423
+ }, "strip", z.ZodTypeAny, {
1424
+ __t4s_required?: boolean;
1425
+ pluginOptions?: any;
1426
+ required?: boolean;
1427
+ type?: "string" | "text";
1428
+ }, {
1429
+ __t4s_required?: boolean;
1430
+ pluginOptions?: any;
1431
+ required?: boolean;
1432
+ type?: "string" | "text";
1433
+ }>, z.ZodObject<{
1434
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1435
+ required: z.ZodOptional<z.ZodBoolean>;
1436
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1437
+ } & {
1438
+ type: z.ZodLiteral<"email">;
1439
+ }, "strip", z.ZodTypeAny, {
1440
+ __t4s_required?: boolean;
1441
+ pluginOptions?: any;
1442
+ required?: boolean;
1443
+ type?: "email";
1444
+ }, {
1445
+ __t4s_required?: boolean;
1446
+ pluginOptions?: any;
1447
+ required?: boolean;
1448
+ type?: "email";
1449
+ }>, z.ZodObject<{
1450
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1451
+ required: z.ZodOptional<z.ZodBoolean>;
1452
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1453
+ } & {
1454
+ type: z.ZodLiteral<"uid">;
1455
+ targetField: z.ZodOptional<z.ZodString>;
1456
+ }, "strip", z.ZodTypeAny, {
1457
+ __t4s_required?: boolean;
1458
+ pluginOptions?: any;
1459
+ required?: boolean;
1460
+ type?: "uid";
1461
+ targetField?: string;
1462
+ }, {
1463
+ __t4s_required?: boolean;
1464
+ pluginOptions?: any;
1465
+ required?: boolean;
1466
+ type?: "uid";
1467
+ targetField?: string;
1468
+ }>, z.ZodObject<{
1469
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1470
+ required: z.ZodOptional<z.ZodBoolean>;
1471
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1472
+ } & {
1473
+ type: z.ZodLiteral<"richtext">;
1474
+ }, "strip", z.ZodTypeAny, {
1475
+ __t4s_required?: boolean;
1476
+ pluginOptions?: any;
1477
+ required?: boolean;
1478
+ type?: "richtext";
1479
+ }, {
1480
+ __t4s_required?: boolean;
1481
+ pluginOptions?: any;
1482
+ required?: boolean;
1483
+ type?: "richtext";
1484
+ }>, z.ZodObject<{
1485
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1486
+ required: z.ZodOptional<z.ZodBoolean>;
1487
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1488
+ } & {
1489
+ type: z.ZodLiteral<"blocks">;
1490
+ }, "strip", z.ZodTypeAny, {
1491
+ __t4s_required?: boolean;
1492
+ pluginOptions?: any;
1493
+ required?: boolean;
1494
+ type?: "blocks";
1495
+ }, {
1496
+ __t4s_required?: boolean;
1497
+ pluginOptions?: any;
1498
+ required?: boolean;
1499
+ type?: "blocks";
1500
+ }>, z.ZodObject<{
1501
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1502
+ required: z.ZodOptional<z.ZodBoolean>;
1503
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1504
+ } & {
1505
+ type: z.ZodLiteral<"json">;
1506
+ }, "strip", z.ZodTypeAny, {
1507
+ __t4s_required?: boolean;
1508
+ pluginOptions?: any;
1509
+ required?: boolean;
1510
+ type?: "json";
1511
+ }, {
1512
+ __t4s_required?: boolean;
1513
+ pluginOptions?: any;
1514
+ required?: boolean;
1515
+ type?: "json";
1516
+ }>, z.ZodObject<{
1517
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1518
+ required: z.ZodOptional<z.ZodBoolean>;
1519
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1520
+ } & {
1521
+ type: z.ZodLiteral<"password">;
1522
+ }, "strip", z.ZodTypeAny, {
1523
+ __t4s_required?: boolean;
1524
+ pluginOptions?: any;
1525
+ required?: boolean;
1526
+ type?: "password";
1527
+ }, {
1528
+ __t4s_required?: boolean;
1529
+ pluginOptions?: any;
1530
+ required?: boolean;
1531
+ type?: "password";
1532
+ }>, z.ZodObject<{
1533
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1534
+ required: z.ZodOptional<z.ZodBoolean>;
1535
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1536
+ } & {
1537
+ type: z.ZodLiteral<"integer">;
1538
+ }, "strip", z.ZodTypeAny, {
1539
+ __t4s_required?: boolean;
1540
+ pluginOptions?: any;
1541
+ required?: boolean;
1542
+ type?: "integer";
1543
+ }, {
1544
+ __t4s_required?: boolean;
1545
+ pluginOptions?: any;
1546
+ required?: boolean;
1547
+ type?: "integer";
1548
+ }>, z.ZodObject<{
1549
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1550
+ required: z.ZodOptional<z.ZodBoolean>;
1551
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1552
+ } & {
1553
+ type: z.ZodLiteral<"float">;
1554
+ }, "strip", z.ZodTypeAny, {
1555
+ __t4s_required?: boolean;
1556
+ pluginOptions?: any;
1557
+ required?: boolean;
1558
+ type?: "float";
1559
+ }, {
1560
+ __t4s_required?: boolean;
1561
+ pluginOptions?: any;
1562
+ required?: boolean;
1563
+ type?: "float";
1564
+ }>, z.ZodObject<{
1565
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1566
+ required: z.ZodOptional<z.ZodBoolean>;
1567
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1568
+ } & {
1569
+ type: z.ZodLiteral<"biginteger">;
1570
+ }, "strip", z.ZodTypeAny, {
1571
+ __t4s_required?: boolean;
1572
+ pluginOptions?: any;
1573
+ required?: boolean;
1574
+ type?: "biginteger";
1575
+ }, {
1576
+ __t4s_required?: boolean;
1577
+ pluginOptions?: any;
1578
+ required?: boolean;
1579
+ type?: "biginteger";
1580
+ }>, z.ZodObject<{
1581
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1582
+ required: z.ZodOptional<z.ZodBoolean>;
1583
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1584
+ } & {
1585
+ type: z.ZodLiteral<"decimal">;
1586
+ }, "strip", z.ZodTypeAny, {
1587
+ __t4s_required?: boolean;
1588
+ pluginOptions?: any;
1589
+ required?: boolean;
1590
+ type?: "decimal";
1591
+ }, {
1592
+ __t4s_required?: boolean;
1593
+ pluginOptions?: any;
1594
+ required?: boolean;
1595
+ type?: "decimal";
1596
+ }>, z.ZodObject<{
1597
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1598
+ required: z.ZodOptional<z.ZodBoolean>;
1599
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1600
+ } & {
1601
+ type: z.ZodLiteral<"enumeration">;
1602
+ enum: z.ZodArray<z.ZodString, "many">;
1603
+ }, "strip", z.ZodTypeAny, {
1604
+ __t4s_required?: boolean;
1605
+ pluginOptions?: any;
1606
+ required?: boolean;
1607
+ type?: "enumeration";
1608
+ enum?: string[];
1609
+ }, {
1610
+ __t4s_required?: boolean;
1611
+ pluginOptions?: any;
1612
+ required?: boolean;
1613
+ type?: "enumeration";
1614
+ enum?: string[];
1615
+ }>, z.ZodObject<{
1616
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1617
+ required: z.ZodOptional<z.ZodBoolean>;
1618
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1619
+ } & {
1620
+ type: z.ZodLiteral<"date">;
1621
+ }, "strip", z.ZodTypeAny, {
1622
+ __t4s_required?: boolean;
1623
+ pluginOptions?: any;
1624
+ required?: boolean;
1625
+ type?: "date";
1626
+ }, {
1627
+ __t4s_required?: boolean;
1628
+ pluginOptions?: any;
1629
+ required?: boolean;
1630
+ type?: "date";
1631
+ }>, z.ZodObject<{
1632
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1633
+ required: z.ZodOptional<z.ZodBoolean>;
1634
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1635
+ } & {
1636
+ type: z.ZodLiteral<"datetime">;
1637
+ }, "strip", z.ZodTypeAny, {
1638
+ __t4s_required?: boolean;
1639
+ pluginOptions?: any;
1640
+ required?: boolean;
1641
+ type?: "datetime";
1642
+ }, {
1643
+ __t4s_required?: boolean;
1644
+ pluginOptions?: any;
1645
+ required?: boolean;
1646
+ type?: "datetime";
1647
+ }>, z.ZodObject<{
1648
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1649
+ required: z.ZodOptional<z.ZodBoolean>;
1650
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1651
+ } & {
1652
+ type: z.ZodLiteral<"time">;
1653
+ }, "strip", z.ZodTypeAny, {
1654
+ __t4s_required?: boolean;
1655
+ pluginOptions?: any;
1656
+ required?: boolean;
1657
+ type?: "time";
1658
+ }, {
1659
+ __t4s_required?: boolean;
1660
+ pluginOptions?: any;
1661
+ required?: boolean;
1662
+ type?: "time";
1663
+ }>, z.ZodObject<{
1664
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1665
+ required: z.ZodOptional<z.ZodBoolean>;
1666
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1667
+ } & {
1668
+ type: z.ZodLiteral<"media">;
1669
+ multiple: z.ZodOptional<z.ZodBoolean>;
1670
+ allowedTypes: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<["images", "videos", "audios", "files"]>, "many">>>;
1671
+ }, "strip", z.ZodTypeAny, {
1672
+ __t4s_required?: boolean;
1673
+ pluginOptions?: any;
1674
+ required?: boolean;
1675
+ type?: "media";
1676
+ multiple?: boolean;
1677
+ allowedTypes?: ("images" | "videos" | "audios" | "files")[];
1678
+ }, {
1679
+ __t4s_required?: boolean;
1680
+ pluginOptions?: any;
1681
+ required?: boolean;
1682
+ type?: "media";
1683
+ multiple?: boolean;
1684
+ allowedTypes?: ("images" | "videos" | "audios" | "files")[];
1685
+ }>, z.ZodObject<{
1686
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1687
+ required: z.ZodOptional<z.ZodBoolean>;
1688
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1689
+ } & {
1690
+ type: z.ZodLiteral<"boolean">;
1691
+ }, "strip", z.ZodTypeAny, {
1692
+ __t4s_required?: boolean;
1693
+ pluginOptions?: any;
1694
+ required?: boolean;
1695
+ type?: "boolean";
1696
+ }, {
1697
+ __t4s_required?: boolean;
1698
+ pluginOptions?: any;
1699
+ required?: boolean;
1700
+ type?: "boolean";
1701
+ }>, z.ZodObject<{
1702
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1703
+ required: z.ZodOptional<z.ZodBoolean>;
1704
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1705
+ } & {
1706
+ type: z.ZodLiteral<"relation">;
1707
+ target: z.ZodString;
1708
+ } & {
1709
+ relation: z.ZodLiteral<"oneToOne">;
1710
+ }, "strip", z.ZodTypeAny, {
1711
+ __t4s_required?: boolean;
1712
+ pluginOptions?: any;
1713
+ required?: boolean;
1714
+ type?: "relation";
1715
+ relation?: "oneToOne";
1716
+ target?: string;
1717
+ }, {
1718
+ __t4s_required?: boolean;
1719
+ pluginOptions?: any;
1720
+ required?: boolean;
1721
+ type?: "relation";
1722
+ relation?: "oneToOne";
1723
+ target?: string;
1724
+ }>, z.ZodObject<{
1725
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1726
+ required: z.ZodOptional<z.ZodBoolean>;
1727
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1728
+ } & {
1729
+ type: z.ZodLiteral<"relation">;
1730
+ target: z.ZodString;
1731
+ } & {
1732
+ relation: z.ZodLiteral<"oneToOne">;
1733
+ inversedBy: z.ZodString;
1734
+ }, "strip", z.ZodTypeAny, {
1735
+ __t4s_required?: boolean;
1736
+ pluginOptions?: any;
1737
+ required?: boolean;
1738
+ type?: "relation";
1739
+ relation?: "oneToOne";
1740
+ target?: string;
1741
+ inversedBy?: string;
1742
+ }, {
1743
+ __t4s_required?: boolean;
1744
+ pluginOptions?: any;
1745
+ required?: boolean;
1746
+ type?: "relation";
1747
+ relation?: "oneToOne";
1748
+ target?: string;
1749
+ inversedBy?: string;
1750
+ }>, z.ZodObject<{
1751
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1752
+ required: z.ZodOptional<z.ZodBoolean>;
1753
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1754
+ } & {
1755
+ type: z.ZodLiteral<"relation">;
1756
+ target: z.ZodString;
1757
+ } & {
1758
+ mappedBy: z.ZodString;
1759
+ relation: z.ZodLiteral<"oneToMany">;
1760
+ }, "strip", z.ZodTypeAny, {
1761
+ __t4s_required?: boolean;
1762
+ pluginOptions?: any;
1763
+ required?: boolean;
1764
+ type?: "relation";
1765
+ relation?: "oneToMany";
1766
+ target?: string;
1767
+ mappedBy?: string;
1768
+ }, {
1769
+ __t4s_required?: boolean;
1770
+ pluginOptions?: any;
1771
+ required?: boolean;
1772
+ type?: "relation";
1773
+ relation?: "oneToMany";
1774
+ target?: string;
1775
+ mappedBy?: string;
1776
+ }>, z.ZodObject<{
1777
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1778
+ required: z.ZodOptional<z.ZodBoolean>;
1779
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1780
+ } & {
1781
+ type: z.ZodLiteral<"relation">;
1782
+ target: z.ZodString;
1783
+ } & {
1784
+ relation: z.ZodLiteral<"manyToOne">;
1785
+ inversedBy: z.ZodString;
1786
+ }, "strip", z.ZodTypeAny, {
1787
+ __t4s_required?: boolean;
1788
+ pluginOptions?: any;
1789
+ required?: boolean;
1790
+ type?: "relation";
1791
+ relation?: "manyToOne";
1792
+ target?: string;
1793
+ inversedBy?: string;
1794
+ }, {
1795
+ __t4s_required?: boolean;
1796
+ pluginOptions?: any;
1797
+ required?: boolean;
1798
+ type?: "relation";
1799
+ relation?: "manyToOne";
1800
+ target?: string;
1801
+ inversedBy?: string;
1802
+ }>, z.ZodObject<{
1803
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1804
+ required: z.ZodOptional<z.ZodBoolean>;
1805
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1806
+ } & {
1807
+ type: z.ZodLiteral<"relation">;
1808
+ target: z.ZodString;
1809
+ } & {
1810
+ relation: z.ZodLiteral<"manyToMany">;
1811
+ inversedBy: z.ZodOptional<z.ZodString>;
1812
+ mappedBy: z.ZodOptional<z.ZodString>;
1813
+ }, "strip", z.ZodTypeAny, {
1814
+ __t4s_required?: boolean;
1815
+ pluginOptions?: any;
1816
+ required?: boolean;
1817
+ type?: "relation";
1818
+ relation?: "manyToMany";
1819
+ target?: string;
1820
+ inversedBy?: string;
1821
+ mappedBy?: string;
1822
+ }, {
1823
+ __t4s_required?: boolean;
1824
+ pluginOptions?: any;
1825
+ required?: boolean;
1826
+ type?: "relation";
1827
+ relation?: "manyToMany";
1828
+ target?: string;
1829
+ inversedBy?: string;
1830
+ mappedBy?: string;
1831
+ }>, z.ZodObject<{
1832
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1833
+ required: z.ZodOptional<z.ZodBoolean>;
1834
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1835
+ } & {
1836
+ type: z.ZodLiteral<"relation">;
1837
+ target: z.ZodString;
1838
+ } & {
1839
+ relation: z.ZodLiteral<"oneToMany">;
1840
+ }, "strip", z.ZodTypeAny, {
1841
+ __t4s_required?: boolean;
1842
+ pluginOptions?: any;
1843
+ required?: boolean;
1844
+ type?: "relation";
1845
+ relation?: "oneToMany";
1846
+ target?: string;
1847
+ }, {
1848
+ __t4s_required?: boolean;
1849
+ pluginOptions?: any;
1850
+ required?: boolean;
1851
+ type?: "relation";
1852
+ relation?: "oneToMany";
1853
+ target?: string;
1854
+ }>, z.ZodObject<{
1855
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1856
+ required: z.ZodOptional<z.ZodBoolean>;
1857
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1858
+ } & {
1859
+ type: z.ZodLiteral<"relation">;
1860
+ relation: z.ZodLiteral<"morphToMany">;
1861
+ }, "strip", z.ZodTypeAny, {
1862
+ __t4s_required?: boolean;
1863
+ pluginOptions?: any;
1864
+ required?: boolean;
1865
+ type?: "relation";
1866
+ relation?: "morphToMany";
1867
+ }, {
1868
+ __t4s_required?: boolean;
1869
+ pluginOptions?: any;
1870
+ required?: boolean;
1871
+ type?: "relation";
1872
+ relation?: "morphToMany";
1873
+ }>, z.ZodObject<{
1874
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1875
+ required: z.ZodOptional<z.ZodBoolean>;
1876
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1877
+ } & {
1878
+ type: z.ZodLiteral<"relation">;
1879
+ relation: z.ZodLiteral<"morphToOne">;
1880
+ }, "strip", z.ZodTypeAny, {
1881
+ __t4s_required?: boolean;
1882
+ pluginOptions?: any;
1883
+ required?: boolean;
1884
+ type?: "relation";
1885
+ relation?: "morphToOne";
1886
+ }, {
1887
+ __t4s_required?: boolean;
1888
+ pluginOptions?: any;
1889
+ required?: boolean;
1890
+ type?: "relation";
1891
+ relation?: "morphToOne";
1892
+ }>, z.ZodObject<{
1893
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1894
+ required: z.ZodOptional<z.ZodBoolean>;
1895
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1896
+ } & {
1897
+ type: z.ZodLiteral<"component">;
1898
+ repeatable: z.ZodOptional<z.ZodBoolean>;
1899
+ component: z.ZodString;
1900
+ }, "strip", z.ZodTypeAny, {
1901
+ __t4s_required?: boolean;
1902
+ pluginOptions?: any;
1903
+ required?: boolean;
1904
+ type?: "component";
1905
+ component?: string;
1906
+ repeatable?: boolean;
1907
+ }, {
1908
+ __t4s_required?: boolean;
1909
+ pluginOptions?: any;
1910
+ required?: boolean;
1911
+ type?: "component";
1912
+ component?: string;
1913
+ repeatable?: boolean;
1914
+ }>, z.ZodObject<{
1915
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1916
+ required: z.ZodOptional<z.ZodBoolean>;
1917
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1918
+ } & {
1919
+ type: z.ZodEffects<z.ZodType<"any", z.ZodTypeDef, "any">, "any", "any">;
1920
+ }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
1921
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1922
+ required: z.ZodOptional<z.ZodBoolean>;
1923
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1924
+ } & {
1925
+ type: z.ZodEffects<z.ZodType<"any", z.ZodTypeDef, "any">, "any", "any">;
1926
+ }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
1927
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1928
+ required: z.ZodOptional<z.ZodBoolean>;
1929
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1930
+ } & {
1931
+ type: z.ZodEffects<z.ZodType<"any", z.ZodTypeDef, "any">, "any", "any">;
1932
+ }, z.ZodTypeAny, "passthrough">>]>;
1933
+ export type Attribute = z.infer<typeof attribute>;
1934
+ export declare const isKnownAttribute: <T extends Attribute>(attributeObject: T) => attributeObject is T & KnownAttribute;
1935
+ export declare const contentTypeAttribute: z.ZodUnion<[z.ZodObject<{
1936
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1937
+ required: z.ZodOptional<z.ZodBoolean>;
1938
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1939
+ } & {
1940
+ type: z.ZodLiteral<"dynamiczone">;
1941
+ components: z.ZodArray<z.ZodString, "many">;
1942
+ }, "strip", z.ZodTypeAny, {
1943
+ __t4s_required?: boolean;
1944
+ pluginOptions?: any;
1945
+ required?: boolean;
1946
+ type?: "dynamiczone";
1947
+ components?: string[];
1948
+ }, {
1949
+ __t4s_required?: boolean;
1950
+ pluginOptions?: any;
1951
+ required?: boolean;
1952
+ type?: "dynamiczone";
1953
+ components?: string[];
1954
+ }>, z.ZodUnion<[z.ZodObject<{
1955
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1956
+ required: z.ZodOptional<z.ZodBoolean>;
1957
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1958
+ } & {
1959
+ type: z.ZodEnum<["text", "string"]>;
1960
+ }, "strip", z.ZodTypeAny, {
1961
+ __t4s_required?: boolean;
1962
+ pluginOptions?: any;
1963
+ required?: boolean;
1964
+ type?: "string" | "text";
1965
+ }, {
1966
+ __t4s_required?: boolean;
1967
+ pluginOptions?: any;
1968
+ required?: boolean;
1969
+ type?: "string" | "text";
1970
+ }>, z.ZodObject<{
1971
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1972
+ required: z.ZodOptional<z.ZodBoolean>;
1973
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1974
+ } & {
1975
+ type: z.ZodLiteral<"email">;
1976
+ }, "strip", z.ZodTypeAny, {
1977
+ __t4s_required?: boolean;
1978
+ pluginOptions?: any;
1979
+ required?: boolean;
1980
+ type?: "email";
1981
+ }, {
1982
+ __t4s_required?: boolean;
1983
+ pluginOptions?: any;
1984
+ required?: boolean;
1985
+ type?: "email";
1986
+ }>, z.ZodObject<{
1987
+ pluginOptions: z.ZodOptional<z.ZodAny>;
1988
+ required: z.ZodOptional<z.ZodBoolean>;
1989
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
1990
+ } & {
1991
+ type: z.ZodLiteral<"uid">;
1992
+ targetField: z.ZodOptional<z.ZodString>;
1993
+ }, "strip", z.ZodTypeAny, {
1994
+ __t4s_required?: boolean;
1995
+ pluginOptions?: any;
1996
+ required?: boolean;
1997
+ type?: "uid";
1998
+ targetField?: string;
1999
+ }, {
2000
+ __t4s_required?: boolean;
2001
+ pluginOptions?: any;
2002
+ required?: boolean;
2003
+ type?: "uid";
2004
+ targetField?: string;
2005
+ }>, z.ZodObject<{
2006
+ pluginOptions: z.ZodOptional<z.ZodAny>;
2007
+ required: z.ZodOptional<z.ZodBoolean>;
2008
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
2009
+ } & {
2010
+ type: z.ZodLiteral<"richtext">;
2011
+ }, "strip", z.ZodTypeAny, {
2012
+ __t4s_required?: boolean;
2013
+ pluginOptions?: any;
2014
+ required?: boolean;
2015
+ type?: "richtext";
2016
+ }, {
2017
+ __t4s_required?: boolean;
2018
+ pluginOptions?: any;
2019
+ required?: boolean;
2020
+ type?: "richtext";
2021
+ }>, z.ZodObject<{
2022
+ pluginOptions: z.ZodOptional<z.ZodAny>;
2023
+ required: z.ZodOptional<z.ZodBoolean>;
2024
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
2025
+ } & {
2026
+ type: z.ZodLiteral<"blocks">;
2027
+ }, "strip", z.ZodTypeAny, {
2028
+ __t4s_required?: boolean;
2029
+ pluginOptions?: any;
2030
+ required?: boolean;
2031
+ type?: "blocks";
2032
+ }, {
2033
+ __t4s_required?: boolean;
2034
+ pluginOptions?: any;
2035
+ required?: boolean;
2036
+ type?: "blocks";
2037
+ }>, z.ZodObject<{
2038
+ pluginOptions: z.ZodOptional<z.ZodAny>;
2039
+ required: z.ZodOptional<z.ZodBoolean>;
2040
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
2041
+ } & {
2042
+ type: z.ZodLiteral<"json">;
2043
+ }, "strip", z.ZodTypeAny, {
2044
+ __t4s_required?: boolean;
2045
+ pluginOptions?: any;
2046
+ required?: boolean;
2047
+ type?: "json";
2048
+ }, {
2049
+ __t4s_required?: boolean;
2050
+ pluginOptions?: any;
2051
+ required?: boolean;
2052
+ type?: "json";
2053
+ }>, z.ZodObject<{
2054
+ pluginOptions: z.ZodOptional<z.ZodAny>;
2055
+ required: z.ZodOptional<z.ZodBoolean>;
2056
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
2057
+ } & {
2058
+ type: z.ZodLiteral<"password">;
2059
+ }, "strip", z.ZodTypeAny, {
2060
+ __t4s_required?: boolean;
2061
+ pluginOptions?: any;
2062
+ required?: boolean;
2063
+ type?: "password";
2064
+ }, {
2065
+ __t4s_required?: boolean;
2066
+ pluginOptions?: any;
2067
+ required?: boolean;
2068
+ type?: "password";
2069
+ }>, z.ZodObject<{
2070
+ pluginOptions: z.ZodOptional<z.ZodAny>;
2071
+ required: z.ZodOptional<z.ZodBoolean>;
2072
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
2073
+ } & {
2074
+ type: z.ZodLiteral<"integer">;
2075
+ }, "strip", z.ZodTypeAny, {
2076
+ __t4s_required?: boolean;
2077
+ pluginOptions?: any;
2078
+ required?: boolean;
2079
+ type?: "integer";
2080
+ }, {
2081
+ __t4s_required?: boolean;
2082
+ pluginOptions?: any;
2083
+ required?: boolean;
2084
+ type?: "integer";
2085
+ }>, z.ZodObject<{
2086
+ pluginOptions: z.ZodOptional<z.ZodAny>;
2087
+ required: z.ZodOptional<z.ZodBoolean>;
2088
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
2089
+ } & {
2090
+ type: z.ZodLiteral<"float">;
2091
+ }, "strip", z.ZodTypeAny, {
2092
+ __t4s_required?: boolean;
2093
+ pluginOptions?: any;
2094
+ required?: boolean;
2095
+ type?: "float";
2096
+ }, {
2097
+ __t4s_required?: boolean;
2098
+ pluginOptions?: any;
2099
+ required?: boolean;
2100
+ type?: "float";
2101
+ }>, z.ZodObject<{
2102
+ pluginOptions: z.ZodOptional<z.ZodAny>;
2103
+ required: z.ZodOptional<z.ZodBoolean>;
2104
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
2105
+ } & {
2106
+ type: z.ZodLiteral<"biginteger">;
2107
+ }, "strip", z.ZodTypeAny, {
2108
+ __t4s_required?: boolean;
2109
+ pluginOptions?: any;
2110
+ required?: boolean;
2111
+ type?: "biginteger";
2112
+ }, {
2113
+ __t4s_required?: boolean;
2114
+ pluginOptions?: any;
2115
+ required?: boolean;
2116
+ type?: "biginteger";
2117
+ }>, z.ZodObject<{
2118
+ pluginOptions: z.ZodOptional<z.ZodAny>;
2119
+ required: z.ZodOptional<z.ZodBoolean>;
2120
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
2121
+ } & {
2122
+ type: z.ZodLiteral<"decimal">;
2123
+ }, "strip", z.ZodTypeAny, {
2124
+ __t4s_required?: boolean;
2125
+ pluginOptions?: any;
2126
+ required?: boolean;
2127
+ type?: "decimal";
2128
+ }, {
2129
+ __t4s_required?: boolean;
2130
+ pluginOptions?: any;
2131
+ required?: boolean;
2132
+ type?: "decimal";
2133
+ }>, z.ZodObject<{
2134
+ pluginOptions: z.ZodOptional<z.ZodAny>;
2135
+ required: z.ZodOptional<z.ZodBoolean>;
2136
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
2137
+ } & {
2138
+ type: z.ZodLiteral<"enumeration">;
2139
+ enum: z.ZodArray<z.ZodString, "many">;
2140
+ }, "strip", z.ZodTypeAny, {
2141
+ __t4s_required?: boolean;
2142
+ pluginOptions?: any;
2143
+ required?: boolean;
2144
+ type?: "enumeration";
2145
+ enum?: string[];
2146
+ }, {
2147
+ __t4s_required?: boolean;
2148
+ pluginOptions?: any;
2149
+ required?: boolean;
2150
+ type?: "enumeration";
2151
+ enum?: string[];
2152
+ }>, z.ZodObject<{
2153
+ pluginOptions: z.ZodOptional<z.ZodAny>;
2154
+ required: z.ZodOptional<z.ZodBoolean>;
2155
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
2156
+ } & {
2157
+ type: z.ZodLiteral<"date">;
2158
+ }, "strip", z.ZodTypeAny, {
2159
+ __t4s_required?: boolean;
2160
+ pluginOptions?: any;
2161
+ required?: boolean;
2162
+ type?: "date";
2163
+ }, {
2164
+ __t4s_required?: boolean;
2165
+ pluginOptions?: any;
2166
+ required?: boolean;
2167
+ type?: "date";
2168
+ }>, z.ZodObject<{
2169
+ pluginOptions: z.ZodOptional<z.ZodAny>;
2170
+ required: z.ZodOptional<z.ZodBoolean>;
2171
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
2172
+ } & {
2173
+ type: z.ZodLiteral<"datetime">;
2174
+ }, "strip", z.ZodTypeAny, {
2175
+ __t4s_required?: boolean;
2176
+ pluginOptions?: any;
2177
+ required?: boolean;
2178
+ type?: "datetime";
2179
+ }, {
2180
+ __t4s_required?: boolean;
2181
+ pluginOptions?: any;
2182
+ required?: boolean;
2183
+ type?: "datetime";
2184
+ }>, z.ZodObject<{
2185
+ pluginOptions: z.ZodOptional<z.ZodAny>;
2186
+ required: z.ZodOptional<z.ZodBoolean>;
2187
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
2188
+ } & {
2189
+ type: z.ZodLiteral<"time">;
2190
+ }, "strip", z.ZodTypeAny, {
2191
+ __t4s_required?: boolean;
2192
+ pluginOptions?: any;
2193
+ required?: boolean;
2194
+ type?: "time";
2195
+ }, {
2196
+ __t4s_required?: boolean;
2197
+ pluginOptions?: any;
2198
+ required?: boolean;
2199
+ type?: "time";
2200
+ }>, z.ZodObject<{
2201
+ pluginOptions: z.ZodOptional<z.ZodAny>;
2202
+ required: z.ZodOptional<z.ZodBoolean>;
2203
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
2204
+ } & {
2205
+ type: z.ZodLiteral<"media">;
2206
+ multiple: z.ZodOptional<z.ZodBoolean>;
2207
+ allowedTypes: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<["images", "videos", "audios", "files"]>, "many">>>;
2208
+ }, "strip", z.ZodTypeAny, {
2209
+ __t4s_required?: boolean;
2210
+ pluginOptions?: any;
2211
+ required?: boolean;
2212
+ type?: "media";
2213
+ multiple?: boolean;
2214
+ allowedTypes?: ("images" | "videos" | "audios" | "files")[];
2215
+ }, {
2216
+ __t4s_required?: boolean;
2217
+ pluginOptions?: any;
2218
+ required?: boolean;
2219
+ type?: "media";
2220
+ multiple?: boolean;
2221
+ allowedTypes?: ("images" | "videos" | "audios" | "files")[];
2222
+ }>, z.ZodObject<{
2223
+ pluginOptions: z.ZodOptional<z.ZodAny>;
2224
+ required: z.ZodOptional<z.ZodBoolean>;
2225
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
2226
+ } & {
2227
+ type: z.ZodLiteral<"boolean">;
2228
+ }, "strip", z.ZodTypeAny, {
2229
+ __t4s_required?: boolean;
2230
+ pluginOptions?: any;
2231
+ required?: boolean;
2232
+ type?: "boolean";
2233
+ }, {
2234
+ __t4s_required?: boolean;
2235
+ pluginOptions?: any;
2236
+ required?: boolean;
2237
+ type?: "boolean";
2238
+ }>, z.ZodObject<{
2239
+ pluginOptions: z.ZodOptional<z.ZodAny>;
2240
+ required: z.ZodOptional<z.ZodBoolean>;
2241
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
2242
+ } & {
2243
+ type: z.ZodLiteral<"relation">;
2244
+ target: z.ZodString;
2245
+ } & {
2246
+ relation: z.ZodLiteral<"oneToOne">;
2247
+ }, "strip", z.ZodTypeAny, {
2248
+ __t4s_required?: boolean;
2249
+ pluginOptions?: any;
2250
+ required?: boolean;
2251
+ type?: "relation";
2252
+ relation?: "oneToOne";
2253
+ target?: string;
2254
+ }, {
2255
+ __t4s_required?: boolean;
2256
+ pluginOptions?: any;
2257
+ required?: boolean;
2258
+ type?: "relation";
2259
+ relation?: "oneToOne";
2260
+ target?: string;
2261
+ }>, z.ZodObject<{
2262
+ pluginOptions: z.ZodOptional<z.ZodAny>;
2263
+ required: z.ZodOptional<z.ZodBoolean>;
2264
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
2265
+ } & {
2266
+ type: z.ZodLiteral<"relation">;
2267
+ target: z.ZodString;
2268
+ } & {
2269
+ relation: z.ZodLiteral<"oneToOne">;
2270
+ inversedBy: z.ZodString;
2271
+ }, "strip", z.ZodTypeAny, {
2272
+ __t4s_required?: boolean;
2273
+ pluginOptions?: any;
2274
+ required?: boolean;
2275
+ type?: "relation";
2276
+ relation?: "oneToOne";
2277
+ target?: string;
2278
+ inversedBy?: string;
2279
+ }, {
2280
+ __t4s_required?: boolean;
2281
+ pluginOptions?: any;
2282
+ required?: boolean;
2283
+ type?: "relation";
2284
+ relation?: "oneToOne";
2285
+ target?: string;
2286
+ inversedBy?: string;
2287
+ }>, z.ZodObject<{
2288
+ pluginOptions: z.ZodOptional<z.ZodAny>;
2289
+ required: z.ZodOptional<z.ZodBoolean>;
2290
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
2291
+ } & {
2292
+ type: z.ZodLiteral<"relation">;
2293
+ target: z.ZodString;
2294
+ } & {
2295
+ mappedBy: z.ZodString;
2296
+ relation: z.ZodLiteral<"oneToMany">;
2297
+ }, "strip", z.ZodTypeAny, {
2298
+ __t4s_required?: boolean;
2299
+ pluginOptions?: any;
2300
+ required?: boolean;
2301
+ type?: "relation";
2302
+ relation?: "oneToMany";
2303
+ target?: string;
2304
+ mappedBy?: string;
2305
+ }, {
2306
+ __t4s_required?: boolean;
2307
+ pluginOptions?: any;
2308
+ required?: boolean;
2309
+ type?: "relation";
2310
+ relation?: "oneToMany";
2311
+ target?: string;
2312
+ mappedBy?: string;
2313
+ }>, z.ZodObject<{
2314
+ pluginOptions: z.ZodOptional<z.ZodAny>;
2315
+ required: z.ZodOptional<z.ZodBoolean>;
2316
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
2317
+ } & {
2318
+ type: z.ZodLiteral<"relation">;
2319
+ target: z.ZodString;
2320
+ } & {
2321
+ relation: z.ZodLiteral<"manyToOne">;
2322
+ inversedBy: z.ZodString;
2323
+ }, "strip", z.ZodTypeAny, {
2324
+ __t4s_required?: boolean;
2325
+ pluginOptions?: any;
2326
+ required?: boolean;
2327
+ type?: "relation";
2328
+ relation?: "manyToOne";
2329
+ target?: string;
2330
+ inversedBy?: string;
2331
+ }, {
2332
+ __t4s_required?: boolean;
2333
+ pluginOptions?: any;
2334
+ required?: boolean;
2335
+ type?: "relation";
2336
+ relation?: "manyToOne";
2337
+ target?: string;
2338
+ inversedBy?: string;
2339
+ }>, z.ZodObject<{
2340
+ pluginOptions: z.ZodOptional<z.ZodAny>;
2341
+ required: z.ZodOptional<z.ZodBoolean>;
2342
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
2343
+ } & {
2344
+ type: z.ZodLiteral<"relation">;
2345
+ target: z.ZodString;
2346
+ } & {
2347
+ relation: z.ZodLiteral<"manyToMany">;
2348
+ inversedBy: z.ZodOptional<z.ZodString>;
2349
+ mappedBy: z.ZodOptional<z.ZodString>;
2350
+ }, "strip", z.ZodTypeAny, {
2351
+ __t4s_required?: boolean;
2352
+ pluginOptions?: any;
2353
+ required?: boolean;
2354
+ type?: "relation";
2355
+ relation?: "manyToMany";
2356
+ target?: string;
2357
+ inversedBy?: string;
2358
+ mappedBy?: string;
2359
+ }, {
2360
+ __t4s_required?: boolean;
2361
+ pluginOptions?: any;
2362
+ required?: boolean;
2363
+ type?: "relation";
2364
+ relation?: "manyToMany";
2365
+ target?: string;
2366
+ inversedBy?: string;
2367
+ mappedBy?: string;
2368
+ }>, z.ZodObject<{
2369
+ pluginOptions: z.ZodOptional<z.ZodAny>;
2370
+ required: z.ZodOptional<z.ZodBoolean>;
2371
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
2372
+ } & {
2373
+ type: z.ZodLiteral<"relation">;
2374
+ target: z.ZodString;
2375
+ } & {
2376
+ relation: z.ZodLiteral<"oneToMany">;
2377
+ }, "strip", z.ZodTypeAny, {
2378
+ __t4s_required?: boolean;
2379
+ pluginOptions?: any;
2380
+ required?: boolean;
2381
+ type?: "relation";
2382
+ relation?: "oneToMany";
2383
+ target?: string;
2384
+ }, {
2385
+ __t4s_required?: boolean;
2386
+ pluginOptions?: any;
2387
+ required?: boolean;
2388
+ type?: "relation";
2389
+ relation?: "oneToMany";
2390
+ target?: string;
2391
+ }>, z.ZodObject<{
2392
+ pluginOptions: z.ZodOptional<z.ZodAny>;
2393
+ required: z.ZodOptional<z.ZodBoolean>;
2394
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
2395
+ } & {
2396
+ type: z.ZodLiteral<"relation">;
2397
+ relation: z.ZodLiteral<"morphToMany">;
2398
+ }, "strip", z.ZodTypeAny, {
2399
+ __t4s_required?: boolean;
2400
+ pluginOptions?: any;
2401
+ required?: boolean;
2402
+ type?: "relation";
2403
+ relation?: "morphToMany";
2404
+ }, {
2405
+ __t4s_required?: boolean;
2406
+ pluginOptions?: any;
2407
+ required?: boolean;
2408
+ type?: "relation";
2409
+ relation?: "morphToMany";
2410
+ }>, z.ZodObject<{
2411
+ pluginOptions: z.ZodOptional<z.ZodAny>;
2412
+ required: z.ZodOptional<z.ZodBoolean>;
2413
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
2414
+ } & {
2415
+ type: z.ZodLiteral<"relation">;
2416
+ relation: z.ZodLiteral<"morphToOne">;
2417
+ }, "strip", z.ZodTypeAny, {
2418
+ __t4s_required?: boolean;
2419
+ pluginOptions?: any;
2420
+ required?: boolean;
2421
+ type?: "relation";
2422
+ relation?: "morphToOne";
2423
+ }, {
2424
+ __t4s_required?: boolean;
2425
+ pluginOptions?: any;
2426
+ required?: boolean;
2427
+ type?: "relation";
2428
+ relation?: "morphToOne";
2429
+ }>, z.ZodObject<{
2430
+ pluginOptions: z.ZodOptional<z.ZodAny>;
2431
+ required: z.ZodOptional<z.ZodBoolean>;
2432
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
2433
+ } & {
2434
+ type: z.ZodLiteral<"component">;
2435
+ repeatable: z.ZodOptional<z.ZodBoolean>;
2436
+ component: z.ZodString;
2437
+ }, "strip", z.ZodTypeAny, {
2438
+ __t4s_required?: boolean;
2439
+ pluginOptions?: any;
2440
+ required?: boolean;
2441
+ type?: "component";
2442
+ component?: string;
2443
+ repeatable?: boolean;
2444
+ }, {
2445
+ __t4s_required?: boolean;
2446
+ pluginOptions?: any;
2447
+ required?: boolean;
2448
+ type?: "component";
2449
+ component?: string;
2450
+ repeatable?: boolean;
2451
+ }>, z.ZodObject<{
2452
+ pluginOptions: z.ZodOptional<z.ZodAny>;
2453
+ required: z.ZodOptional<z.ZodBoolean>;
2454
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
2455
+ } & {
2456
+ type: z.ZodEffects<z.ZodType<"any", z.ZodTypeDef, "any">, "any", "any">;
2457
+ }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
2458
+ pluginOptions: z.ZodOptional<z.ZodAny>;
2459
+ required: z.ZodOptional<z.ZodBoolean>;
2460
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
2461
+ } & {
2462
+ type: z.ZodEffects<z.ZodType<"any", z.ZodTypeDef, "any">, "any", "any">;
2463
+ }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
2464
+ pluginOptions: z.ZodOptional<z.ZodAny>;
2465
+ required: z.ZodOptional<z.ZodBoolean>;
2466
+ __t4s_required: z.ZodOptional<z.ZodBoolean>;
2467
+ } & {
2468
+ type: z.ZodEffects<z.ZodType<"any", z.ZodTypeDef, "any">, "any", "any">;
2469
+ }, z.ZodTypeAny, "passthrough">>]>]>;
2470
+ export type ContentTypeAttribute = z.infer<typeof contentTypeAttribute>;