drizzle-kit 0.19.13-e99bac1 → 0.19.13

Sign up to get free protection for your applications and to get access to all the features.
Files changed (46) hide show
  1. package/index.cjs +30505 -21937
  2. package/index.d.ts +14 -15
  3. package/package.json +2 -3
  4. package/utils.js +11760 -35976
  5. package/@types/utils.d.ts +0 -12
  6. package/cli/commands/migrate.d.ts +0 -141
  7. package/cli/commands/mysqlUp.d.ts +0 -4
  8. package/cli/commands/pgIntrospect.d.ts +0 -118
  9. package/cli/commands/pgPushUtils.d.ts +0 -14
  10. package/cli/commands/pgUp.d.ts +0 -4
  11. package/cli/commands/sqliteIntrospect.d.ts +0 -102
  12. package/cli/commands/sqliteUtils.d.ts +0 -162
  13. package/cli/commands/upFolders.d.ts +0 -27
  14. package/cli/commands/utils.d.ts +0 -265
  15. package/cli/selector-ui.d.ts +0 -13
  16. package/cli/validations/common.d.ts +0 -13
  17. package/cli/validations/mysql.d.ts +0 -414
  18. package/cli/validations/outputs.d.ts +0 -39
  19. package/cli/validations/pg.d.ts +0 -438
  20. package/cli/validations/sqlite.d.ts +0 -220
  21. package/cli/validations/studio.d.ts +0 -469
  22. package/cli/views.d.ts +0 -61
  23. package/drivers/index.d.ts +0 -26
  24. package/global.d.ts +0 -2
  25. package/introspect.d.ts +0 -4
  26. package/jsonDiffer.d.ts +0 -76
  27. package/jsonStatements.d.ts +0 -349
  28. package/migrationPreparator.d.ts +0 -35
  29. package/schemaValidator.d.ts +0 -1236
  30. package/serializer/index.d.ts +0 -9
  31. package/serializer/mysqlImports.d.ts +0 -6
  32. package/serializer/mysqlSchema.d.ts +0 -3833
  33. package/serializer/mysqlSerializer.d.ts +0 -7
  34. package/serializer/pgImports.d.ts +0 -11
  35. package/serializer/pgSchema.d.ts +0 -4000
  36. package/serializer/pgSerializer.d.ts +0 -7
  37. package/serializer/sqliteImports.d.ts +0 -5
  38. package/serializer/sqliteSchema.d.ts +0 -3162
  39. package/serializer/sqliteSerializer.d.ts +0 -8
  40. package/serializer/studioUtils.d.ts +0 -31
  41. package/snapshotsDiffer.d.ts +0 -2660
  42. package/sqlgenerator.d.ts +0 -33
  43. package/sqlite-introspect.d.ts +0 -5
  44. package/utils/words.d.ts +0 -7
  45. package/utils.d.ts +0 -32
  46. package/utilsR.d.ts +0 -209
package/serializer/pgSchema.d.ts DELETED
@@ -1,4000 +0,0 @@
1
- import { TypeOf } from "zod";
2
- declare const enumSchema: import("zod").ZodObject<{
3
- name: import("zod").ZodString;
4
- values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
5
- }, "strict", import("zod").ZodTypeAny, {
6
- name: string;
7
- values: Record<string, string>;
8
- }, {
9
- name: string;
10
- values: Record<string, string>;
11
- }>;
12
- export declare const pgSchemaV2: import("zod").ZodObject<{
13
- version: import("zod").ZodLiteral<"2">;
14
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
15
- name: import("zod").ZodString;
16
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
17
- name: import("zod").ZodString;
18
- type: import("zod").ZodString;
19
- primaryKey: import("zod").ZodBoolean;
20
- notNull: import("zod").ZodBoolean;
21
- default: import("zod").ZodOptional<import("zod").ZodAny>;
22
- references: import("zod").ZodOptional<import("zod").ZodString>;
23
- }, "strict", import("zod").ZodTypeAny, {
24
- default?: any;
25
- references?: string | undefined;
26
- name: string;
27
- type: string;
28
- primaryKey: boolean;
29
- notNull: boolean;
30
- }, {
31
- default?: any;
32
- references?: string | undefined;
33
- name: string;
34
- type: string;
35
- primaryKey: boolean;
36
- notNull: boolean;
37
- }>>;
38
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
39
- name: import("zod").ZodString;
40
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
41
- name: import("zod").ZodString;
42
- }, "strip", import("zod").ZodTypeAny, {
43
- name: string;
44
- }, {
45
- name: string;
46
- }>>;
47
- isUnique: import("zod").ZodBoolean;
48
- }, "strict", import("zod").ZodTypeAny, {
49
- name: string;
50
- columns: Record<string, {
51
- name: string;
52
- }>;
53
- isUnique: boolean;
54
- }, {
55
- name: string;
56
- columns: Record<string, {
57
- name: string;
58
- }>;
59
- isUnique: boolean;
60
- }>>;
61
- }, "strict", import("zod").ZodTypeAny, {
62
- name: string;
63
- columns: Record<string, {
64
- default?: any;
65
- references?: string | undefined;
66
- name: string;
67
- type: string;
68
- primaryKey: boolean;
69
- notNull: boolean;
70
- }>;
71
- indexes: Record<string, {
72
- name: string;
73
- columns: Record<string, {
74
- name: string;
75
- }>;
76
- isUnique: boolean;
77
- }>;
78
- }, {
79
- name: string;
80
- columns: Record<string, {
81
- default?: any;
82
- references?: string | undefined;
83
- name: string;
84
- type: string;
85
- primaryKey: boolean;
86
- notNull: boolean;
87
- }>;
88
- indexes: Record<string, {
89
- name: string;
90
- columns: Record<string, {
91
- name: string;
92
- }>;
93
- isUnique: boolean;
94
- }>;
95
- }>>;
96
- enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
97
- name: import("zod").ZodString;
98
- values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
99
- }, "strict", import("zod").ZodTypeAny, {
100
- name: string;
101
- values: Record<string, string>;
102
- }, {
103
- name: string;
104
- values: Record<string, string>;
105
- }>>;
106
- }, "strict", import("zod").ZodTypeAny, {
107
- version: "2";
108
- tables: Record<string, {
109
- name: string;
110
- columns: Record<string, {
111
- default?: any;
112
- references?: string | undefined;
113
- name: string;
114
- type: string;
115
- primaryKey: boolean;
116
- notNull: boolean;
117
- }>;
118
- indexes: Record<string, {
119
- name: string;
120
- columns: Record<string, {
121
- name: string;
122
- }>;
123
- isUnique: boolean;
124
- }>;
125
- }>;
126
- enums: Record<string, {
127
- name: string;
128
- values: Record<string, string>;
129
- }>;
130
- }, {
131
- version: "2";
132
- tables: Record<string, {
133
- name: string;
134
- columns: Record<string, {
135
- default?: any;
136
- references?: string | undefined;
137
- name: string;
138
- type: string;
139
- primaryKey: boolean;
140
- notNull: boolean;
141
- }>;
142
- indexes: Record<string, {
143
- name: string;
144
- columns: Record<string, {
145
- name: string;
146
- }>;
147
- isUnique: boolean;
148
- }>;
149
- }>;
150
- enums: Record<string, {
151
- name: string;
152
- values: Record<string, string>;
153
- }>;
154
- }>;
155
- export declare const pgSchemaV1: import("zod").ZodObject<{
156
- version: import("zod").ZodLiteral<"1">;
157
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
158
- name: import("zod").ZodString;
159
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
160
- name: import("zod").ZodString;
161
- type: import("zod").ZodString;
162
- primaryKey: import("zod").ZodBoolean;
163
- notNull: import("zod").ZodBoolean;
164
- default: import("zod").ZodOptional<import("zod").ZodAny>;
165
- references: import("zod").ZodOptional<import("zod").ZodObject<{
166
- foreignKeyName: import("zod").ZodString;
167
- table: import("zod").ZodString;
168
- column: import("zod").ZodString;
169
- onDelete: import("zod").ZodOptional<import("zod").ZodString>;
170
- onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
171
- }, "strict", import("zod").ZodTypeAny, {
172
- onUpdate?: string | undefined;
173
- onDelete?: string | undefined;
174
- column: string;
175
- foreignKeyName: string;
176
- table: string;
177
- }, {
178
- onUpdate?: string | undefined;
179
- onDelete?: string | undefined;
180
- column: string;
181
- foreignKeyName: string;
182
- table: string;
183
- }>>;
184
- }, "strict", import("zod").ZodTypeAny, {
185
- default?: any;
186
- references?: {
187
- onUpdate?: string | undefined;
188
- onDelete?: string | undefined;
189
- column: string;
190
- foreignKeyName: string;
191
- table: string;
192
- } | undefined;
193
- name: string;
194
- type: string;
195
- primaryKey: boolean;
196
- notNull: boolean;
197
- }, {
198
- default?: any;
199
- references?: {
200
- onUpdate?: string | undefined;
201
- onDelete?: string | undefined;
202
- column: string;
203
- foreignKeyName: string;
204
- table: string;
205
- } | undefined;
206
- name: string;
207
- type: string;
208
- primaryKey: boolean;
209
- notNull: boolean;
210
- }>>;
211
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
212
- name: import("zod").ZodString;
213
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
214
- name: import("zod").ZodString;
215
- }, "strip", import("zod").ZodTypeAny, {
216
- name: string;
217
- }, {
218
- name: string;
219
- }>>;
220
- isUnique: import("zod").ZodBoolean;
221
- }, "strict", import("zod").ZodTypeAny, {
222
- name: string;
223
- columns: Record<string, {
224
- name: string;
225
- }>;
226
- isUnique: boolean;
227
- }, {
228
- name: string;
229
- columns: Record<string, {
230
- name: string;
231
- }>;
232
- isUnique: boolean;
233
- }>>;
234
- }, "strict", import("zod").ZodTypeAny, {
235
- name: string;
236
- columns: Record<string, {
237
- default?: any;
238
- references?: {
239
- onUpdate?: string | undefined;
240
- onDelete?: string | undefined;
241
- column: string;
242
- foreignKeyName: string;
243
- table: string;
244
- } | undefined;
245
- name: string;
246
- type: string;
247
- primaryKey: boolean;
248
- notNull: boolean;
249
- }>;
250
- indexes: Record<string, {
251
- name: string;
252
- columns: Record<string, {
253
- name: string;
254
- }>;
255
- isUnique: boolean;
256
- }>;
257
- }, {
258
- name: string;
259
- columns: Record<string, {
260
- default?: any;
261
- references?: {
262
- onUpdate?: string | undefined;
263
- onDelete?: string | undefined;
264
- column: string;
265
- foreignKeyName: string;
266
- table: string;
267
- } | undefined;
268
- name: string;
269
- type: string;
270
- primaryKey: boolean;
271
- notNull: boolean;
272
- }>;
273
- indexes: Record<string, {
274
- name: string;
275
- columns: Record<string, {
276
- name: string;
277
- }>;
278
- isUnique: boolean;
279
- }>;
280
- }>>;
281
- enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
282
- name: import("zod").ZodString;
283
- values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
284
- }, "strict", import("zod").ZodTypeAny, {
285
- name: string;
286
- values: Record<string, string>;
287
- }, {
288
- name: string;
289
- values: Record<string, string>;
290
- }>>;
291
- }, "strict", import("zod").ZodTypeAny, {
292
- version: "1";
293
- tables: Record<string, {
294
- name: string;
295
- columns: Record<string, {
296
- default?: any;
297
- references?: {
298
- onUpdate?: string | undefined;
299
- onDelete?: string | undefined;
300
- column: string;
301
- foreignKeyName: string;
302
- table: string;
303
- } | undefined;
304
- name: string;
305
- type: string;
306
- primaryKey: boolean;
307
- notNull: boolean;
308
- }>;
309
- indexes: Record<string, {
310
- name: string;
311
- columns: Record<string, {
312
- name: string;
313
- }>;
314
- isUnique: boolean;
315
- }>;
316
- }>;
317
- enums: Record<string, {
318
- name: string;
319
- values: Record<string, string>;
320
- }>;
321
- }, {
322
- version: "1";
323
- tables: Record<string, {
324
- name: string;
325
- columns: Record<string, {
326
- default?: any;
327
- references?: {
328
- onUpdate?: string | undefined;
329
- onDelete?: string | undefined;
330
- column: string;
331
- foreignKeyName: string;
332
- table: string;
333
- } | undefined;
334
- name: string;
335
- type: string;
336
- primaryKey: boolean;
337
- notNull: boolean;
338
- }>;
339
- indexes: Record<string, {
340
- name: string;
341
- columns: Record<string, {
342
- name: string;
343
- }>;
344
- isUnique: boolean;
345
- }>;
346
- }>;
347
- enums: Record<string, {
348
- name: string;
349
- values: Record<string, string>;
350
- }>;
351
- }>;
352
- declare const index: import("zod").ZodObject<{
353
- name: import("zod").ZodString;
354
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
355
- isUnique: import("zod").ZodBoolean;
356
- }, "strict", import("zod").ZodTypeAny, {
357
- name: string;
358
- columns: string[];
359
- isUnique: boolean;
360
- }, {
361
- name: string;
362
- columns: string[];
363
- isUnique: boolean;
364
- }>;
365
- declare const fk: import("zod").ZodObject<{
366
- name: import("zod").ZodString;
367
- tableFrom: import("zod").ZodString;
368
- columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
369
- tableTo: import("zod").ZodString;
370
- columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
371
- onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
372
- onDelete: import("zod").ZodOptional<import("zod").ZodString>;
373
- }, "strict", import("zod").ZodTypeAny, {
374
- onUpdate?: string | undefined;
375
- onDelete?: string | undefined;
376
- name: string;
377
- tableFrom: string;
378
- columnsFrom: string[];
379
- tableTo: string;
380
- columnsTo: string[];
381
- }, {
382
- onUpdate?: string | undefined;
383
- onDelete?: string | undefined;
384
- name: string;
385
- tableFrom: string;
386
- columnsFrom: string[];
387
- tableTo: string;
388
- columnsTo: string[];
389
- }>;
390
- declare const column: import("zod").ZodObject<{
391
- name: import("zod").ZodString;
392
- type: import("zod").ZodString;
393
- primaryKey: import("zod").ZodBoolean;
394
- notNull: import("zod").ZodBoolean;
395
- default: import("zod").ZodOptional<import("zod").ZodAny>;
396
- isUnique: import("zod").ZodOptional<import("zod").ZodAny>;
397
- uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
398
- nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
399
- }, "strict", import("zod").ZodTypeAny, {
400
- isUnique?: any;
401
- default?: any;
402
- uniqueName?: string | undefined;
403
- nullsNotDistinct?: boolean | undefined;
404
- name: string;
405
- type: string;
406
- primaryKey: boolean;
407
- notNull: boolean;
408
- }, {
409
- isUnique?: any;
410
- default?: any;
411
- uniqueName?: string | undefined;
412
- nullsNotDistinct?: boolean | undefined;
413
- name: string;
414
- type: string;
415
- primaryKey: boolean;
416
- notNull: boolean;
417
- }>;
418
- declare const tableV3: import("zod").ZodObject<{
419
- name: import("zod").ZodString;
420
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
421
- name: import("zod").ZodString;
422
- type: import("zod").ZodString;
423
- primaryKey: import("zod").ZodBoolean;
424
- notNull: import("zod").ZodBoolean;
425
- default: import("zod").ZodOptional<import("zod").ZodAny>;
426
- isUnique: import("zod").ZodOptional<import("zod").ZodAny>;
427
- uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
428
- nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
429
- }, "strict", import("zod").ZodTypeAny, {
430
- isUnique?: any;
431
- default?: any;
432
- uniqueName?: string | undefined;
433
- nullsNotDistinct?: boolean | undefined;
434
- name: string;
435
- type: string;
436
- primaryKey: boolean;
437
- notNull: boolean;
438
- }, {
439
- isUnique?: any;
440
- default?: any;
441
- uniqueName?: string | undefined;
442
- nullsNotDistinct?: boolean | undefined;
443
- name: string;
444
- type: string;
445
- primaryKey: boolean;
446
- notNull: boolean;
447
- }>>;
448
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
449
- name: import("zod").ZodString;
450
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
451
- isUnique: import("zod").ZodBoolean;
452
- }, "strict", import("zod").ZodTypeAny, {
453
- name: string;
454
- columns: string[];
455
- isUnique: boolean;
456
- }, {
457
- name: string;
458
- columns: string[];
459
- isUnique: boolean;
460
- }>>;
461
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
462
- name: import("zod").ZodString;
463
- tableFrom: import("zod").ZodString;
464
- columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
465
- tableTo: import("zod").ZodString;
466
- columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
467
- onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
468
- onDelete: import("zod").ZodOptional<import("zod").ZodString>;
469
- }, "strict", import("zod").ZodTypeAny, {
470
- onUpdate?: string | undefined;
471
- onDelete?: string | undefined;
472
- name: string;
473
- tableFrom: string;
474
- columnsFrom: string[];
475
- tableTo: string;
476
- columnsTo: string[];
477
- }, {
478
- onUpdate?: string | undefined;
479
- onDelete?: string | undefined;
480
- name: string;
481
- tableFrom: string;
482
- columnsFrom: string[];
483
- tableTo: string;
484
- columnsTo: string[];
485
- }>>;
486
- }, "strict", import("zod").ZodTypeAny, {
487
- name: string;
488
- columns: Record<string, {
489
- isUnique?: any;
490
- default?: any;
491
- uniqueName?: string | undefined;
492
- nullsNotDistinct?: boolean | undefined;
493
- name: string;
494
- type: string;
495
- primaryKey: boolean;
496
- notNull: boolean;
497
- }>;
498
- indexes: Record<string, {
499
- name: string;
500
- columns: string[];
501
- isUnique: boolean;
502
- }>;
503
- foreignKeys: Record<string, {
504
- onUpdate?: string | undefined;
505
- onDelete?: string | undefined;
506
- name: string;
507
- tableFrom: string;
508
- columnsFrom: string[];
509
- tableTo: string;
510
- columnsTo: string[];
511
- }>;
512
- }, {
513
- name: string;
514
- columns: Record<string, {
515
- isUnique?: any;
516
- default?: any;
517
- uniqueName?: string | undefined;
518
- nullsNotDistinct?: boolean | undefined;
519
- name: string;
520
- type: string;
521
- primaryKey: boolean;
522
- notNull: boolean;
523
- }>;
524
- indexes: Record<string, {
525
- name: string;
526
- columns: string[];
527
- isUnique: boolean;
528
- }>;
529
- foreignKeys: Record<string, {
530
- onUpdate?: string | undefined;
531
- onDelete?: string | undefined;
532
- name: string;
533
- tableFrom: string;
534
- columnsFrom: string[];
535
- tableTo: string;
536
- columnsTo: string[];
537
- }>;
538
- }>;
539
- declare const compositePK: import("zod").ZodObject<{
540
- name: import("zod").ZodString;
541
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
542
- }, "strict", import("zod").ZodTypeAny, {
543
- name: string;
544
- columns: string[];
545
- }, {
546
- name: string;
547
- columns: string[];
548
- }>;
549
- declare const uniqueConstraint: import("zod").ZodObject<{
550
- name: import("zod").ZodString;
551
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
552
- nullsNotDistinct: import("zod").ZodBoolean;
553
- }, "strict", import("zod").ZodTypeAny, {
554
- name: string;
555
- columns: string[];
556
- nullsNotDistinct: boolean;
557
- }, {
558
- name: string;
559
- columns: string[];
560
- nullsNotDistinct: boolean;
561
- }>;
562
- declare const tableV4: import("zod").ZodObject<{
563
- name: import("zod").ZodString;
564
- schema: import("zod").ZodString;
565
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
566
- name: import("zod").ZodString;
567
- type: import("zod").ZodString;
568
- primaryKey: import("zod").ZodBoolean;
569
- notNull: import("zod").ZodBoolean;
570
- default: import("zod").ZodOptional<import("zod").ZodAny>;
571
- isUnique: import("zod").ZodOptional<import("zod").ZodAny>;
572
- uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
573
- nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
574
- }, "strict", import("zod").ZodTypeAny, {
575
- isUnique?: any;
576
- default?: any;
577
- uniqueName?: string | undefined;
578
- nullsNotDistinct?: boolean | undefined;
579
- name: string;
580
- type: string;
581
- primaryKey: boolean;
582
- notNull: boolean;
583
- }, {
584
- isUnique?: any;
585
- default?: any;
586
- uniqueName?: string | undefined;
587
- nullsNotDistinct?: boolean | undefined;
588
- name: string;
589
- type: string;
590
- primaryKey: boolean;
591
- notNull: boolean;
592
- }>>;
593
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
594
- name: import("zod").ZodString;
595
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
596
- isUnique: import("zod").ZodBoolean;
597
- }, "strict", import("zod").ZodTypeAny, {
598
- name: string;
599
- columns: string[];
600
- isUnique: boolean;
601
- }, {
602
- name: string;
603
- columns: string[];
604
- isUnique: boolean;
605
- }>>;
606
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
607
- name: import("zod").ZodString;
608
- tableFrom: import("zod").ZodString;
609
- columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
610
- tableTo: import("zod").ZodString;
611
- columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
612
- onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
613
- onDelete: import("zod").ZodOptional<import("zod").ZodString>;
614
- }, "strict", import("zod").ZodTypeAny, {
615
- onUpdate?: string | undefined;
616
- onDelete?: string | undefined;
617
- name: string;
618
- tableFrom: string;
619
- columnsFrom: string[];
620
- tableTo: string;
621
- columnsTo: string[];
622
- }, {
623
- onUpdate?: string | undefined;
624
- onDelete?: string | undefined;
625
- name: string;
626
- tableFrom: string;
627
- columnsFrom: string[];
628
- tableTo: string;
629
- columnsTo: string[];
630
- }>>;
631
- }, "strict", import("zod").ZodTypeAny, {
632
- name: string;
633
- columns: Record<string, {
634
- isUnique?: any;
635
- default?: any;
636
- uniqueName?: string | undefined;
637
- nullsNotDistinct?: boolean | undefined;
638
- name: string;
639
- type: string;
640
- primaryKey: boolean;
641
- notNull: boolean;
642
- }>;
643
- indexes: Record<string, {
644
- name: string;
645
- columns: string[];
646
- isUnique: boolean;
647
- }>;
648
- foreignKeys: Record<string, {
649
- onUpdate?: string | undefined;
650
- onDelete?: string | undefined;
651
- name: string;
652
- tableFrom: string;
653
- columnsFrom: string[];
654
- tableTo: string;
655
- columnsTo: string[];
656
- }>;
657
- schema: string;
658
- }, {
659
- name: string;
660
- columns: Record<string, {
661
- isUnique?: any;
662
- default?: any;
663
- uniqueName?: string | undefined;
664
- nullsNotDistinct?: boolean | undefined;
665
- name: string;
666
- type: string;
667
- primaryKey: boolean;
668
- notNull: boolean;
669
- }>;
670
- indexes: Record<string, {
671
- name: string;
672
- columns: string[];
673
- isUnique: boolean;
674
- }>;
675
- foreignKeys: Record<string, {
676
- onUpdate?: string | undefined;
677
- onDelete?: string | undefined;
678
- name: string;
679
- tableFrom: string;
680
- columnsFrom: string[];
681
- tableTo: string;
682
- columnsTo: string[];
683
- }>;
684
- schema: string;
685
- }>;
686
- declare const table: import("zod").ZodObject<{
687
- name: import("zod").ZodString;
688
- schema: import("zod").ZodString;
689
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
690
- name: import("zod").ZodString;
691
- type: import("zod").ZodString;
692
- primaryKey: import("zod").ZodBoolean;
693
- notNull: import("zod").ZodBoolean;
694
- default: import("zod").ZodOptional<import("zod").ZodAny>;
695
- isUnique: import("zod").ZodOptional<import("zod").ZodAny>;
696
- uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
697
- nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
698
- }, "strict", import("zod").ZodTypeAny, {
699
- isUnique?: any;
700
- default?: any;
701
- uniqueName?: string | undefined;
702
- nullsNotDistinct?: boolean | undefined;
703
- name: string;
704
- type: string;
705
- primaryKey: boolean;
706
- notNull: boolean;
707
- }, {
708
- isUnique?: any;
709
- default?: any;
710
- uniqueName?: string | undefined;
711
- nullsNotDistinct?: boolean | undefined;
712
- name: string;
713
- type: string;
714
- primaryKey: boolean;
715
- notNull: boolean;
716
- }>>;
717
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
718
- name: import("zod").ZodString;
719
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
720
- isUnique: import("zod").ZodBoolean;
721
- }, "strict", import("zod").ZodTypeAny, {
722
- name: string;
723
- columns: string[];
724
- isUnique: boolean;
725
- }, {
726
- name: string;
727
- columns: string[];
728
- isUnique: boolean;
729
- }>>;
730
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
731
- name: import("zod").ZodString;
732
- tableFrom: import("zod").ZodString;
733
- columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
734
- tableTo: import("zod").ZodString;
735
- columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
736
- onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
737
- onDelete: import("zod").ZodOptional<import("zod").ZodString>;
738
- }, "strict", import("zod").ZodTypeAny, {
739
- onUpdate?: string | undefined;
740
- onDelete?: string | undefined;
741
- name: string;
742
- tableFrom: string;
743
- columnsFrom: string[];
744
- tableTo: string;
745
- columnsTo: string[];
746
- }, {
747
- onUpdate?: string | undefined;
748
- onDelete?: string | undefined;
749
- name: string;
750
- tableFrom: string;
751
- columnsFrom: string[];
752
- tableTo: string;
753
- columnsTo: string[];
754
- }>>;
755
- compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
756
- name: import("zod").ZodString;
757
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
758
- }, "strict", import("zod").ZodTypeAny, {
759
- name: string;
760
- columns: string[];
761
- }, {
762
- name: string;
763
- columns: string[];
764
- }>>;
765
- uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
766
- name: import("zod").ZodString;
767
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
768
- nullsNotDistinct: import("zod").ZodBoolean;
769
- }, "strict", import("zod").ZodTypeAny, {
770
- name: string;
771
- columns: string[];
772
- nullsNotDistinct: boolean;
773
- }, {
774
- name: string;
775
- columns: string[];
776
- nullsNotDistinct: boolean;
777
- }>>>;
778
- }, "strict", import("zod").ZodTypeAny, {
779
- name: string;
780
- columns: Record<string, {
781
- isUnique?: any;
782
- default?: any;
783
- uniqueName?: string | undefined;
784
- nullsNotDistinct?: boolean | undefined;
785
- name: string;
786
- type: string;
787
- primaryKey: boolean;
788
- notNull: boolean;
789
- }>;
790
- indexes: Record<string, {
791
- name: string;
792
- columns: string[];
793
- isUnique: boolean;
794
- }>;
795
- foreignKeys: Record<string, {
796
- onUpdate?: string | undefined;
797
- onDelete?: string | undefined;
798
- name: string;
799
- tableFrom: string;
800
- columnsFrom: string[];
801
- tableTo: string;
802
- columnsTo: string[];
803
- }>;
804
- schema: string;
805
- compositePrimaryKeys: Record<string, {
806
- name: string;
807
- columns: string[];
808
- }>;
809
- uniqueConstraints: Record<string, {
810
- name: string;
811
- columns: string[];
812
- nullsNotDistinct: boolean;
813
- }>;
814
- }, {
815
- uniqueConstraints?: Record<string, {
816
- name: string;
817
- columns: string[];
818
- nullsNotDistinct: boolean;
819
- }> | undefined;
820
- name: string;
821
- columns: Record<string, {
822
- isUnique?: any;
823
- default?: any;
824
- uniqueName?: string | undefined;
825
- nullsNotDistinct?: boolean | undefined;
826
- name: string;
827
- type: string;
828
- primaryKey: boolean;
829
- notNull: boolean;
830
- }>;
831
- indexes: Record<string, {
832
- name: string;
833
- columns: string[];
834
- isUnique: boolean;
835
- }>;
836
- foreignKeys: Record<string, {
837
- onUpdate?: string | undefined;
838
- onDelete?: string | undefined;
839
- name: string;
840
- tableFrom: string;
841
- columnsFrom: string[];
842
- tableTo: string;
843
- columnsTo: string[];
844
- }>;
845
- schema: string;
846
- compositePrimaryKeys: Record<string, {
847
- name: string;
848
- columns: string[];
849
- }>;
850
- }>;
851
- export declare const pgSchemaInternalV3: import("zod").ZodObject<{
852
- version: import("zod").ZodLiteral<"3">;
853
- dialect: import("zod").ZodLiteral<"pg">;
854
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
855
- name: import("zod").ZodString;
856
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
857
- name: import("zod").ZodString;
858
- type: import("zod").ZodString;
859
- primaryKey: import("zod").ZodBoolean;
860
- notNull: import("zod").ZodBoolean;
861
- default: import("zod").ZodOptional<import("zod").ZodAny>;
862
- isUnique: import("zod").ZodOptional<import("zod").ZodAny>;
863
- uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
864
- nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
865
- }, "strict", import("zod").ZodTypeAny, {
866
- isUnique?: any;
867
- default?: any;
868
- uniqueName?: string | undefined;
869
- nullsNotDistinct?: boolean | undefined;
870
- name: string;
871
- type: string;
872
- primaryKey: boolean;
873
- notNull: boolean;
874
- }, {
875
- isUnique?: any;
876
- default?: any;
877
- uniqueName?: string | undefined;
878
- nullsNotDistinct?: boolean | undefined;
879
- name: string;
880
- type: string;
881
- primaryKey: boolean;
882
- notNull: boolean;
883
- }>>;
884
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
885
- name: import("zod").ZodString;
886
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
887
- isUnique: import("zod").ZodBoolean;
888
- }, "strict", import("zod").ZodTypeAny, {
889
- name: string;
890
- columns: string[];
891
- isUnique: boolean;
892
- }, {
893
- name: string;
894
- columns: string[];
895
- isUnique: boolean;
896
- }>>;
897
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
898
- name: import("zod").ZodString;
899
- tableFrom: import("zod").ZodString;
900
- columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
901
- tableTo: import("zod").ZodString;
902
- columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
903
- onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
904
- onDelete: import("zod").ZodOptional<import("zod").ZodString>;
905
- }, "strict", import("zod").ZodTypeAny, {
906
- onUpdate?: string | undefined;
907
- onDelete?: string | undefined;
908
- name: string;
909
- tableFrom: string;
910
- columnsFrom: string[];
911
- tableTo: string;
912
- columnsTo: string[];
913
- }, {
914
- onUpdate?: string | undefined;
915
- onDelete?: string | undefined;
916
- name: string;
917
- tableFrom: string;
918
- columnsFrom: string[];
919
- tableTo: string;
920
- columnsTo: string[];
921
- }>>;
922
- }, "strict", import("zod").ZodTypeAny, {
923
- name: string;
924
- columns: Record<string, {
925
- isUnique?: any;
926
- default?: any;
927
- uniqueName?: string | undefined;
928
- nullsNotDistinct?: boolean | undefined;
929
- name: string;
930
- type: string;
931
- primaryKey: boolean;
932
- notNull: boolean;
933
- }>;
934
- indexes: Record<string, {
935
- name: string;
936
- columns: string[];
937
- isUnique: boolean;
938
- }>;
939
- foreignKeys: Record<string, {
940
- onUpdate?: string | undefined;
941
- onDelete?: string | undefined;
942
- name: string;
943
- tableFrom: string;
944
- columnsFrom: string[];
945
- tableTo: string;
946
- columnsTo: string[];
947
- }>;
948
- }, {
949
- name: string;
950
- columns: Record<string, {
951
- isUnique?: any;
952
- default?: any;
953
- uniqueName?: string | undefined;
954
- nullsNotDistinct?: boolean | undefined;
955
- name: string;
956
- type: string;
957
- primaryKey: boolean;
958
- notNull: boolean;
959
- }>;
960
- indexes: Record<string, {
961
- name: string;
962
- columns: string[];
963
- isUnique: boolean;
964
- }>;
965
- foreignKeys: Record<string, {
966
- onUpdate?: string | undefined;
967
- onDelete?: string | undefined;
968
- name: string;
969
- tableFrom: string;
970
- columnsFrom: string[];
971
- tableTo: string;
972
- columnsTo: string[];
973
- }>;
974
- }>>;
975
- enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
976
- name: import("zod").ZodString;
977
- values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
978
- }, "strict", import("zod").ZodTypeAny, {
979
- name: string;
980
- values: Record<string, string>;
981
- }, {
982
- name: string;
983
- values: Record<string, string>;
984
- }>>;
985
- }, "strict", import("zod").ZodTypeAny, {
986
- version: "3";
987
- dialect: "pg";
988
- tables: Record<string, {
989
- name: string;
990
- columns: Record<string, {
991
- isUnique?: any;
992
- default?: any;
993
- uniqueName?: string | undefined;
994
- nullsNotDistinct?: boolean | undefined;
995
- name: string;
996
- type: string;
997
- primaryKey: boolean;
998
- notNull: boolean;
999
- }>;
1000
- indexes: Record<string, {
1001
- name: string;
1002
- columns: string[];
1003
- isUnique: boolean;
1004
- }>;
1005
- foreignKeys: Record<string, {
1006
- onUpdate?: string | undefined;
1007
- onDelete?: string | undefined;
1008
- name: string;
1009
- tableFrom: string;
1010
- columnsFrom: string[];
1011
- tableTo: string;
1012
- columnsTo: string[];
1013
- }>;
1014
- }>;
1015
- enums: Record<string, {
1016
- name: string;
1017
- values: Record<string, string>;
1018
- }>;
1019
- }, {
1020
- version: "3";
1021
- dialect: "pg";
1022
- tables: Record<string, {
1023
- name: string;
1024
- columns: Record<string, {
1025
- isUnique?: any;
1026
- default?: any;
1027
- uniqueName?: string | undefined;
1028
- nullsNotDistinct?: boolean | undefined;
1029
- name: string;
1030
- type: string;
1031
- primaryKey: boolean;
1032
- notNull: boolean;
1033
- }>;
1034
- indexes: Record<string, {
1035
- name: string;
1036
- columns: string[];
1037
- isUnique: boolean;
1038
- }>;
1039
- foreignKeys: Record<string, {
1040
- onUpdate?: string | undefined;
1041
- onDelete?: string | undefined;
1042
- name: string;
1043
- tableFrom: string;
1044
- columnsFrom: string[];
1045
- tableTo: string;
1046
- columnsTo: string[];
1047
- }>;
1048
- }>;
1049
- enums: Record<string, {
1050
- name: string;
1051
- values: Record<string, string>;
1052
- }>;
1053
- }>;
1054
- export declare const pgSchemaInternalV4: import("zod").ZodObject<{
1055
- version: import("zod").ZodLiteral<"4">;
1056
- dialect: import("zod").ZodLiteral<"pg">;
1057
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1058
- name: import("zod").ZodString;
1059
- schema: import("zod").ZodString;
1060
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1061
- name: import("zod").ZodString;
1062
- type: import("zod").ZodString;
1063
- primaryKey: import("zod").ZodBoolean;
1064
- notNull: import("zod").ZodBoolean;
1065
- default: import("zod").ZodOptional<import("zod").ZodAny>;
1066
- isUnique: import("zod").ZodOptional<import("zod").ZodAny>;
1067
- uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
1068
- nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
1069
- }, "strict", import("zod").ZodTypeAny, {
1070
- isUnique?: any;
1071
- default?: any;
1072
- uniqueName?: string | undefined;
1073
- nullsNotDistinct?: boolean | undefined;
1074
- name: string;
1075
- type: string;
1076
- primaryKey: boolean;
1077
- notNull: boolean;
1078
- }, {
1079
- isUnique?: any;
1080
- default?: any;
1081
- uniqueName?: string | undefined;
1082
- nullsNotDistinct?: boolean | undefined;
1083
- name: string;
1084
- type: string;
1085
- primaryKey: boolean;
1086
- notNull: boolean;
1087
- }>>;
1088
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1089
- name: import("zod").ZodString;
1090
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1091
- isUnique: import("zod").ZodBoolean;
1092
- }, "strict", import("zod").ZodTypeAny, {
1093
- name: string;
1094
- columns: string[];
1095
- isUnique: boolean;
1096
- }, {
1097
- name: string;
1098
- columns: string[];
1099
- isUnique: boolean;
1100
- }>>;
1101
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1102
- name: import("zod").ZodString;
1103
- tableFrom: import("zod").ZodString;
1104
- columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
1105
- tableTo: import("zod").ZodString;
1106
- columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
1107
- onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
1108
- onDelete: import("zod").ZodOptional<import("zod").ZodString>;
1109
- }, "strict", import("zod").ZodTypeAny, {
1110
- onUpdate?: string | undefined;
1111
- onDelete?: string | undefined;
1112
- name: string;
1113
- tableFrom: string;
1114
- columnsFrom: string[];
1115
- tableTo: string;
1116
- columnsTo: string[];
1117
- }, {
1118
- onUpdate?: string | undefined;
1119
- onDelete?: string | undefined;
1120
- name: string;
1121
- tableFrom: string;
1122
- columnsFrom: string[];
1123
- tableTo: string;
1124
- columnsTo: string[];
1125
- }>>;
1126
- }, "strict", import("zod").ZodTypeAny, {
1127
- name: string;
1128
- columns: Record<string, {
1129
- isUnique?: any;
1130
- default?: any;
1131
- uniqueName?: string | undefined;
1132
- nullsNotDistinct?: boolean | undefined;
1133
- name: string;
1134
- type: string;
1135
- primaryKey: boolean;
1136
- notNull: boolean;
1137
- }>;
1138
- indexes: Record<string, {
1139
- name: string;
1140
- columns: string[];
1141
- isUnique: boolean;
1142
- }>;
1143
- foreignKeys: Record<string, {
1144
- onUpdate?: string | undefined;
1145
- onDelete?: string | undefined;
1146
- name: string;
1147
- tableFrom: string;
1148
- columnsFrom: string[];
1149
- tableTo: string;
1150
- columnsTo: string[];
1151
- }>;
1152
- schema: string;
1153
- }, {
1154
- name: string;
1155
- columns: Record<string, {
1156
- isUnique?: any;
1157
- default?: any;
1158
- uniqueName?: string | undefined;
1159
- nullsNotDistinct?: boolean | undefined;
1160
- name: string;
1161
- type: string;
1162
- primaryKey: boolean;
1163
- notNull: boolean;
1164
- }>;
1165
- indexes: Record<string, {
1166
- name: string;
1167
- columns: string[];
1168
- isUnique: boolean;
1169
- }>;
1170
- foreignKeys: Record<string, {
1171
- onUpdate?: string | undefined;
1172
- onDelete?: string | undefined;
1173
- name: string;
1174
- tableFrom: string;
1175
- columnsFrom: string[];
1176
- tableTo: string;
1177
- columnsTo: string[];
1178
- }>;
1179
- schema: string;
1180
- }>>;
1181
- enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1182
- name: import("zod").ZodString;
1183
- values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1184
- }, "strict", import("zod").ZodTypeAny, {
1185
- name: string;
1186
- values: Record<string, string>;
1187
- }, {
1188
- name: string;
1189
- values: Record<string, string>;
1190
- }>>;
1191
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1192
- }, "strict", import("zod").ZodTypeAny, {
1193
- version: "4";
1194
- dialect: "pg";
1195
- tables: Record<string, {
1196
- name: string;
1197
- columns: Record<string, {
1198
- isUnique?: any;
1199
- default?: any;
1200
- uniqueName?: string | undefined;
1201
- nullsNotDistinct?: boolean | undefined;
1202
- name: string;
1203
- type: string;
1204
- primaryKey: boolean;
1205
- notNull: boolean;
1206
- }>;
1207
- indexes: Record<string, {
1208
- name: string;
1209
- columns: string[];
1210
- isUnique: boolean;
1211
- }>;
1212
- foreignKeys: Record<string, {
1213
- onUpdate?: string | undefined;
1214
- onDelete?: string | undefined;
1215
- name: string;
1216
- tableFrom: string;
1217
- columnsFrom: string[];
1218
- tableTo: string;
1219
- columnsTo: string[];
1220
- }>;
1221
- schema: string;
1222
- }>;
1223
- schemas: Record<string, string>;
1224
- enums: Record<string, {
1225
- name: string;
1226
- values: Record<string, string>;
1227
- }>;
1228
- }, {
1229
- version: "4";
1230
- dialect: "pg";
1231
- tables: Record<string, {
1232
- name: string;
1233
- columns: Record<string, {
1234
- isUnique?: any;
1235
- default?: any;
1236
- uniqueName?: string | undefined;
1237
- nullsNotDistinct?: boolean | undefined;
1238
- name: string;
1239
- type: string;
1240
- primaryKey: boolean;
1241
- notNull: boolean;
1242
- }>;
1243
- indexes: Record<string, {
1244
- name: string;
1245
- columns: string[];
1246
- isUnique: boolean;
1247
- }>;
1248
- foreignKeys: Record<string, {
1249
- onUpdate?: string | undefined;
1250
- onDelete?: string | undefined;
1251
- name: string;
1252
- tableFrom: string;
1253
- columnsFrom: string[];
1254
- tableTo: string;
1255
- columnsTo: string[];
1256
- }>;
1257
- schema: string;
1258
- }>;
1259
- schemas: Record<string, string>;
1260
- enums: Record<string, {
1261
- name: string;
1262
- values: Record<string, string>;
1263
- }>;
1264
- }>;
1265
- export declare const pgSchemaExternal: import("zod").ZodObject<{
1266
- version: import("zod").ZodLiteral<"5">;
1267
- dialect: import("zod").ZodLiteral<"pg">;
1268
- tables: import("zod").ZodArray<import("zod").ZodObject<{
1269
- name: import("zod").ZodString;
1270
- schema: import("zod").ZodString;
1271
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1272
- name: import("zod").ZodString;
1273
- type: import("zod").ZodString;
1274
- primaryKey: import("zod").ZodBoolean;
1275
- notNull: import("zod").ZodBoolean;
1276
- default: import("zod").ZodOptional<import("zod").ZodAny>;
1277
- isUnique: import("zod").ZodOptional<import("zod").ZodAny>;
1278
- uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
1279
- nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
1280
- }, "strict", import("zod").ZodTypeAny, {
1281
- isUnique?: any;
1282
- default?: any;
1283
- uniqueName?: string | undefined;
1284
- nullsNotDistinct?: boolean | undefined;
1285
- name: string;
1286
- type: string;
1287
- primaryKey: boolean;
1288
- notNull: boolean;
1289
- }, {
1290
- isUnique?: any;
1291
- default?: any;
1292
- uniqueName?: string | undefined;
1293
- nullsNotDistinct?: boolean | undefined;
1294
- name: string;
1295
- type: string;
1296
- primaryKey: boolean;
1297
- notNull: boolean;
1298
- }>>;
1299
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1300
- name: import("zod").ZodString;
1301
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1302
- isUnique: import("zod").ZodBoolean;
1303
- }, "strict", import("zod").ZodTypeAny, {
1304
- name: string;
1305
- columns: string[];
1306
- isUnique: boolean;
1307
- }, {
1308
- name: string;
1309
- columns: string[];
1310
- isUnique: boolean;
1311
- }>>;
1312
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1313
- name: import("zod").ZodString;
1314
- tableFrom: import("zod").ZodString;
1315
- columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
1316
- tableTo: import("zod").ZodString;
1317
- columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
1318
- onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
1319
- onDelete: import("zod").ZodOptional<import("zod").ZodString>;
1320
- }, "strict", import("zod").ZodTypeAny, {
1321
- onUpdate?: string | undefined;
1322
- onDelete?: string | undefined;
1323
- name: string;
1324
- tableFrom: string;
1325
- columnsFrom: string[];
1326
- tableTo: string;
1327
- columnsTo: string[];
1328
- }, {
1329
- onUpdate?: string | undefined;
1330
- onDelete?: string | undefined;
1331
- name: string;
1332
- tableFrom: string;
1333
- columnsFrom: string[];
1334
- tableTo: string;
1335
- columnsTo: string[];
1336
- }>>;
1337
- compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1338
- name: import("zod").ZodString;
1339
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1340
- }, "strict", import("zod").ZodTypeAny, {
1341
- name: string;
1342
- columns: string[];
1343
- }, {
1344
- name: string;
1345
- columns: string[];
1346
- }>>;
1347
- uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1348
- name: import("zod").ZodString;
1349
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1350
- nullsNotDistinct: import("zod").ZodBoolean;
1351
- }, "strict", import("zod").ZodTypeAny, {
1352
- name: string;
1353
- columns: string[];
1354
- nullsNotDistinct: boolean;
1355
- }, {
1356
- name: string;
1357
- columns: string[];
1358
- nullsNotDistinct: boolean;
1359
- }>>>;
1360
- }, "strict", import("zod").ZodTypeAny, {
1361
- name: string;
1362
- columns: Record<string, {
1363
- isUnique?: any;
1364
- default?: any;
1365
- uniqueName?: string | undefined;
1366
- nullsNotDistinct?: boolean | undefined;
1367
- name: string;
1368
- type: string;
1369
- primaryKey: boolean;
1370
- notNull: boolean;
1371
- }>;
1372
- indexes: Record<string, {
1373
- name: string;
1374
- columns: string[];
1375
- isUnique: boolean;
1376
- }>;
1377
- foreignKeys: Record<string, {
1378
- onUpdate?: string | undefined;
1379
- onDelete?: string | undefined;
1380
- name: string;
1381
- tableFrom: string;
1382
- columnsFrom: string[];
1383
- tableTo: string;
1384
- columnsTo: string[];
1385
- }>;
1386
- schema: string;
1387
- compositePrimaryKeys: Record<string, {
1388
- name: string;
1389
- columns: string[];
1390
- }>;
1391
- uniqueConstraints: Record<string, {
1392
- name: string;
1393
- columns: string[];
1394
- nullsNotDistinct: boolean;
1395
- }>;
1396
- }, {
1397
- uniqueConstraints?: Record<string, {
1398
- name: string;
1399
- columns: string[];
1400
- nullsNotDistinct: boolean;
1401
- }> | undefined;
1402
- name: string;
1403
- columns: Record<string, {
1404
- isUnique?: any;
1405
- default?: any;
1406
- uniqueName?: string | undefined;
1407
- nullsNotDistinct?: boolean | undefined;
1408
- name: string;
1409
- type: string;
1410
- primaryKey: boolean;
1411
- notNull: boolean;
1412
- }>;
1413
- indexes: Record<string, {
1414
- name: string;
1415
- columns: string[];
1416
- isUnique: boolean;
1417
- }>;
1418
- foreignKeys: Record<string, {
1419
- onUpdate?: string | undefined;
1420
- onDelete?: string | undefined;
1421
- name: string;
1422
- tableFrom: string;
1423
- columnsFrom: string[];
1424
- tableTo: string;
1425
- columnsTo: string[];
1426
- }>;
1427
- schema: string;
1428
- compositePrimaryKeys: Record<string, {
1429
- name: string;
1430
- columns: string[];
1431
- }>;
1432
- }>, "many">;
1433
- enums: import("zod").ZodArray<import("zod").ZodObject<{
1434
- name: import("zod").ZodString;
1435
- values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1436
- }, "strict", import("zod").ZodTypeAny, {
1437
- name: string;
1438
- values: Record<string, string>;
1439
- }, {
1440
- name: string;
1441
- values: Record<string, string>;
1442
- }>, "many">;
1443
- schemas: import("zod").ZodArray<import("zod").ZodObject<{
1444
- name: import("zod").ZodString;
1445
- }, "strip", import("zod").ZodTypeAny, {
1446
- name: string;
1447
- }, {
1448
- name: string;
1449
- }>, "many">;
1450
- _meta: import("zod").ZodObject<{
1451
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1452
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1453
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1454
- }, "strip", import("zod").ZodTypeAny, {
1455
- columns: Record<string, string>;
1456
- tables: Record<string, string>;
1457
- schemas: Record<string, string>;
1458
- }, {
1459
- columns: Record<string, string>;
1460
- tables: Record<string, string>;
1461
- schemas: Record<string, string>;
1462
- }>;
1463
- }, "strict", import("zod").ZodTypeAny, {
1464
- version: "5";
1465
- dialect: "pg";
1466
- tables: {
1467
- name: string;
1468
- columns: Record<string, {
1469
- isUnique?: any;
1470
- default?: any;
1471
- uniqueName?: string | undefined;
1472
- nullsNotDistinct?: boolean | undefined;
1473
- name: string;
1474
- type: string;
1475
- primaryKey: boolean;
1476
- notNull: boolean;
1477
- }>;
1478
- indexes: Record<string, {
1479
- name: string;
1480
- columns: string[];
1481
- isUnique: boolean;
1482
- }>;
1483
- foreignKeys: Record<string, {
1484
- onUpdate?: string | undefined;
1485
- onDelete?: string | undefined;
1486
- name: string;
1487
- tableFrom: string;
1488
- columnsFrom: string[];
1489
- tableTo: string;
1490
- columnsTo: string[];
1491
- }>;
1492
- schema: string;
1493
- compositePrimaryKeys: Record<string, {
1494
- name: string;
1495
- columns: string[];
1496
- }>;
1497
- uniqueConstraints: Record<string, {
1498
- name: string;
1499
- columns: string[];
1500
- nullsNotDistinct: boolean;
1501
- }>;
1502
- }[];
1503
- schemas: {
1504
- name: string;
1505
- }[];
1506
- _meta: {
1507
- columns: Record<string, string>;
1508
- tables: Record<string, string>;
1509
- schemas: Record<string, string>;
1510
- };
1511
- enums: {
1512
- name: string;
1513
- values: Record<string, string>;
1514
- }[];
1515
- }, {
1516
- version: "5";
1517
- dialect: "pg";
1518
- tables: {
1519
- uniqueConstraints?: Record<string, {
1520
- name: string;
1521
- columns: string[];
1522
- nullsNotDistinct: boolean;
1523
- }> | undefined;
1524
- name: string;
1525
- columns: Record<string, {
1526
- isUnique?: any;
1527
- default?: any;
1528
- uniqueName?: string | undefined;
1529
- nullsNotDistinct?: boolean | undefined;
1530
- name: string;
1531
- type: string;
1532
- primaryKey: boolean;
1533
- notNull: boolean;
1534
- }>;
1535
- indexes: Record<string, {
1536
- name: string;
1537
- columns: string[];
1538
- isUnique: boolean;
1539
- }>;
1540
- foreignKeys: Record<string, {
1541
- onUpdate?: string | undefined;
1542
- onDelete?: string | undefined;
1543
- name: string;
1544
- tableFrom: string;
1545
- columnsFrom: string[];
1546
- tableTo: string;
1547
- columnsTo: string[];
1548
- }>;
1549
- schema: string;
1550
- compositePrimaryKeys: Record<string, {
1551
- name: string;
1552
- columns: string[];
1553
- }>;
1554
- }[];
1555
- schemas: {
1556
- name: string;
1557
- }[];
1558
- _meta: {
1559
- columns: Record<string, string>;
1560
- tables: Record<string, string>;
1561
- schemas: Record<string, string>;
1562
- };
1563
- enums: {
1564
- name: string;
1565
- values: Record<string, string>;
1566
- }[];
1567
- }>;
1568
- export declare const pgSchemaInternal: import("zod").ZodObject<{
1569
- version: import("zod").ZodLiteral<"5">;
1570
- dialect: import("zod").ZodLiteral<"pg">;
1571
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1572
- name: import("zod").ZodString;
1573
- schema: import("zod").ZodString;
1574
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1575
- name: import("zod").ZodString;
1576
- type: import("zod").ZodString;
1577
- primaryKey: import("zod").ZodBoolean;
1578
- notNull: import("zod").ZodBoolean;
1579
- default: import("zod").ZodOptional<import("zod").ZodAny>;
1580
- isUnique: import("zod").ZodOptional<import("zod").ZodAny>;
1581
- uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
1582
- nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
1583
- }, "strict", import("zod").ZodTypeAny, {
1584
- isUnique?: any;
1585
- default?: any;
1586
- uniqueName?: string | undefined;
1587
- nullsNotDistinct?: boolean | undefined;
1588
- name: string;
1589
- type: string;
1590
- primaryKey: boolean;
1591
- notNull: boolean;
1592
- }, {
1593
- isUnique?: any;
1594
- default?: any;
1595
- uniqueName?: string | undefined;
1596
- nullsNotDistinct?: boolean | undefined;
1597
- name: string;
1598
- type: string;
1599
- primaryKey: boolean;
1600
- notNull: boolean;
1601
- }>>;
1602
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1603
- name: import("zod").ZodString;
1604
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1605
- isUnique: import("zod").ZodBoolean;
1606
- }, "strict", import("zod").ZodTypeAny, {
1607
- name: string;
1608
- columns: string[];
1609
- isUnique: boolean;
1610
- }, {
1611
- name: string;
1612
- columns: string[];
1613
- isUnique: boolean;
1614
- }>>;
1615
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1616
- name: import("zod").ZodString;
1617
- tableFrom: import("zod").ZodString;
1618
- columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
1619
- tableTo: import("zod").ZodString;
1620
- columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
1621
- onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
1622
- onDelete: import("zod").ZodOptional<import("zod").ZodString>;
1623
- }, "strict", import("zod").ZodTypeAny, {
1624
- onUpdate?: string | undefined;
1625
- onDelete?: string | undefined;
1626
- name: string;
1627
- tableFrom: string;
1628
- columnsFrom: string[];
1629
- tableTo: string;
1630
- columnsTo: string[];
1631
- }, {
1632
- onUpdate?: string | undefined;
1633
- onDelete?: string | undefined;
1634
- name: string;
1635
- tableFrom: string;
1636
- columnsFrom: string[];
1637
- tableTo: string;
1638
- columnsTo: string[];
1639
- }>>;
1640
- compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1641
- name: import("zod").ZodString;
1642
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1643
- }, "strict", import("zod").ZodTypeAny, {
1644
- name: string;
1645
- columns: string[];
1646
- }, {
1647
- name: string;
1648
- columns: string[];
1649
- }>>;
1650
- uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1651
- name: import("zod").ZodString;
1652
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1653
- nullsNotDistinct: import("zod").ZodBoolean;
1654
- }, "strict", import("zod").ZodTypeAny, {
1655
- name: string;
1656
- columns: string[];
1657
- nullsNotDistinct: boolean;
1658
- }, {
1659
- name: string;
1660
- columns: string[];
1661
- nullsNotDistinct: boolean;
1662
- }>>>;
1663
- }, "strict", import("zod").ZodTypeAny, {
1664
- name: string;
1665
- columns: Record<string, {
1666
- isUnique?: any;
1667
- default?: any;
1668
- uniqueName?: string | undefined;
1669
- nullsNotDistinct?: boolean | undefined;
1670
- name: string;
1671
- type: string;
1672
- primaryKey: boolean;
1673
- notNull: boolean;
1674
- }>;
1675
- indexes: Record<string, {
1676
- name: string;
1677
- columns: string[];
1678
- isUnique: boolean;
1679
- }>;
1680
- foreignKeys: Record<string, {
1681
- onUpdate?: string | undefined;
1682
- onDelete?: string | undefined;
1683
- name: string;
1684
- tableFrom: string;
1685
- columnsFrom: string[];
1686
- tableTo: string;
1687
- columnsTo: string[];
1688
- }>;
1689
- schema: string;
1690
- compositePrimaryKeys: Record<string, {
1691
- name: string;
1692
- columns: string[];
1693
- }>;
1694
- uniqueConstraints: Record<string, {
1695
- name: string;
1696
- columns: string[];
1697
- nullsNotDistinct: boolean;
1698
- }>;
1699
- }, {
1700
- uniqueConstraints?: Record<string, {
1701
- name: string;
1702
- columns: string[];
1703
- nullsNotDistinct: boolean;
1704
- }> | undefined;
1705
- name: string;
1706
- columns: Record<string, {
1707
- isUnique?: any;
1708
- default?: any;
1709
- uniqueName?: string | undefined;
1710
- nullsNotDistinct?: boolean | undefined;
1711
- name: string;
1712
- type: string;
1713
- primaryKey: boolean;
1714
- notNull: boolean;
1715
- }>;
1716
- indexes: Record<string, {
1717
- name: string;
1718
- columns: string[];
1719
- isUnique: boolean;
1720
- }>;
1721
- foreignKeys: Record<string, {
1722
- onUpdate?: string | undefined;
1723
- onDelete?: string | undefined;
1724
- name: string;
1725
- tableFrom: string;
1726
- columnsFrom: string[];
1727
- tableTo: string;
1728
- columnsTo: string[];
1729
- }>;
1730
- schema: string;
1731
- compositePrimaryKeys: Record<string, {
1732
- name: string;
1733
- columns: string[];
1734
- }>;
1735
- }>>;
1736
- enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1737
- name: import("zod").ZodString;
1738
- values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1739
- }, "strict", import("zod").ZodTypeAny, {
1740
- name: string;
1741
- values: Record<string, string>;
1742
- }, {
1743
- name: string;
1744
- values: Record<string, string>;
1745
- }>>;
1746
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1747
- _meta: import("zod").ZodObject<{
1748
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1749
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1750
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1751
- }, "strip", import("zod").ZodTypeAny, {
1752
- columns: Record<string, string>;
1753
- tables: Record<string, string>;
1754
- schemas: Record<string, string>;
1755
- }, {
1756
- columns: Record<string, string>;
1757
- tables: Record<string, string>;
1758
- schemas: Record<string, string>;
1759
- }>;
1760
- }, "strict", import("zod").ZodTypeAny, {
1761
- version: "5";
1762
- dialect: "pg";
1763
- tables: Record<string, {
1764
- name: string;
1765
- columns: Record<string, {
1766
- isUnique?: any;
1767
- default?: any;
1768
- uniqueName?: string | undefined;
1769
- nullsNotDistinct?: boolean | undefined;
1770
- name: string;
1771
- type: string;
1772
- primaryKey: boolean;
1773
- notNull: boolean;
1774
- }>;
1775
- indexes: Record<string, {
1776
- name: string;
1777
- columns: string[];
1778
- isUnique: boolean;
1779
- }>;
1780
- foreignKeys: Record<string, {
1781
- onUpdate?: string | undefined;
1782
- onDelete?: string | undefined;
1783
- name: string;
1784
- tableFrom: string;
1785
- columnsFrom: string[];
1786
- tableTo: string;
1787
- columnsTo: string[];
1788
- }>;
1789
- schema: string;
1790
- compositePrimaryKeys: Record<string, {
1791
- name: string;
1792
- columns: string[];
1793
- }>;
1794
- uniqueConstraints: Record<string, {
1795
- name: string;
1796
- columns: string[];
1797
- nullsNotDistinct: boolean;
1798
- }>;
1799
- }>;
1800
- schemas: Record<string, string>;
1801
- _meta: {
1802
- columns: Record<string, string>;
1803
- tables: Record<string, string>;
1804
- schemas: Record<string, string>;
1805
- };
1806
- enums: Record<string, {
1807
- name: string;
1808
- values: Record<string, string>;
1809
- }>;
1810
- }, {
1811
- version: "5";
1812
- dialect: "pg";
1813
- tables: Record<string, {
1814
- uniqueConstraints?: Record<string, {
1815
- name: string;
1816
- columns: string[];
1817
- nullsNotDistinct: boolean;
1818
- }> | undefined;
1819
- name: string;
1820
- columns: Record<string, {
1821
- isUnique?: any;
1822
- default?: any;
1823
- uniqueName?: string | undefined;
1824
- nullsNotDistinct?: boolean | undefined;
1825
- name: string;
1826
- type: string;
1827
- primaryKey: boolean;
1828
- notNull: boolean;
1829
- }>;
1830
- indexes: Record<string, {
1831
- name: string;
1832
- columns: string[];
1833
- isUnique: boolean;
1834
- }>;
1835
- foreignKeys: Record<string, {
1836
- onUpdate?: string | undefined;
1837
- onDelete?: string | undefined;
1838
- name: string;
1839
- tableFrom: string;
1840
- columnsFrom: string[];
1841
- tableTo: string;
1842
- columnsTo: string[];
1843
- }>;
1844
- schema: string;
1845
- compositePrimaryKeys: Record<string, {
1846
- name: string;
1847
- columns: string[];
1848
- }>;
1849
- }>;
1850
- schemas: Record<string, string>;
1851
- _meta: {
1852
- columns: Record<string, string>;
1853
- tables: Record<string, string>;
1854
- schemas: Record<string, string>;
1855
- };
1856
- enums: Record<string, {
1857
- name: string;
1858
- values: Record<string, string>;
1859
- }>;
1860
- }>;
1861
- export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
1862
- version: import("zod").ZodLiteral<"4">;
1863
- dialect: import("zod").ZodEnum<["pg"]>;
1864
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1865
- name: import("zod").ZodString;
1866
- schema: import("zod").ZodString;
1867
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1868
- name: import("zod").ZodString;
1869
- type: import("zod").ZodString;
1870
- primaryKey: import("zod").ZodBoolean;
1871
- notNull: import("zod").ZodBoolean;
1872
- default: import("zod").ZodOptional<import("zod").ZodAny>;
1873
- isUnique: import("zod").ZodOptional<import("zod").ZodAny>;
1874
- uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
1875
- nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
1876
- }, "strict", import("zod").ZodTypeAny, {
1877
- isUnique?: any;
1878
- default?: any;
1879
- uniqueName?: string | undefined;
1880
- nullsNotDistinct?: boolean | undefined;
1881
- name: string;
1882
- type: string;
1883
- primaryKey: boolean;
1884
- notNull: boolean;
1885
- }, {
1886
- isUnique?: any;
1887
- default?: any;
1888
- uniqueName?: string | undefined;
1889
- nullsNotDistinct?: boolean | undefined;
1890
- name: string;
1891
- type: string;
1892
- primaryKey: boolean;
1893
- notNull: boolean;
1894
- }>>;
1895
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1896
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1897
- }, "strict", import("zod").ZodTypeAny, {
1898
- name: string;
1899
- columns: Record<string, {
1900
- isUnique?: any;
1901
- default?: any;
1902
- uniqueName?: string | undefined;
1903
- nullsNotDistinct?: boolean | undefined;
1904
- name: string;
1905
- type: string;
1906
- primaryKey: boolean;
1907
- notNull: boolean;
1908
- }>;
1909
- indexes: Record<string, string>;
1910
- foreignKeys: Record<string, string>;
1911
- schema: string;
1912
- }, {
1913
- name: string;
1914
- columns: Record<string, {
1915
- isUnique?: any;
1916
- default?: any;
1917
- uniqueName?: string | undefined;
1918
- nullsNotDistinct?: boolean | undefined;
1919
- name: string;
1920
- type: string;
1921
- primaryKey: boolean;
1922
- notNull: boolean;
1923
- }>;
1924
- indexes: Record<string, string>;
1925
- foreignKeys: Record<string, string>;
1926
- schema: string;
1927
- }>>;
1928
- enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1929
- name: import("zod").ZodString;
1930
- values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1931
- }, "strict", import("zod").ZodTypeAny, {
1932
- name: string;
1933
- values: Record<string, string>;
1934
- }, {
1935
- name: string;
1936
- values: Record<string, string>;
1937
- }>>;
1938
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1939
- }, "strict", import("zod").ZodTypeAny, {
1940
- version: "4";
1941
- dialect: "pg";
1942
- tables: Record<string, {
1943
- name: string;
1944
- columns: Record<string, {
1945
- isUnique?: any;
1946
- default?: any;
1947
- uniqueName?: string | undefined;
1948
- nullsNotDistinct?: boolean | undefined;
1949
- name: string;
1950
- type: string;
1951
- primaryKey: boolean;
1952
- notNull: boolean;
1953
- }>;
1954
- indexes: Record<string, string>;
1955
- foreignKeys: Record<string, string>;
1956
- schema: string;
1957
- }>;
1958
- schemas: Record<string, string>;
1959
- enums: Record<string, {
1960
- name: string;
1961
- values: Record<string, string>;
1962
- }>;
1963
- }, {
1964
- version: "4";
1965
- dialect: "pg";
1966
- tables: Record<string, {
1967
- name: string;
1968
- columns: Record<string, {
1969
- isUnique?: any;
1970
- default?: any;
1971
- uniqueName?: string | undefined;
1972
- nullsNotDistinct?: boolean | undefined;
1973
- name: string;
1974
- type: string;
1975
- primaryKey: boolean;
1976
- notNull: boolean;
1977
- }>;
1978
- indexes: Record<string, string>;
1979
- foreignKeys: Record<string, string>;
1980
- schema: string;
1981
- }>;
1982
- schemas: Record<string, string>;
1983
- enums: Record<string, {
1984
- name: string;
1985
- values: Record<string, string>;
1986
- }>;
1987
- }>;
1988
- export declare const pgSchemaSquashed: import("zod").ZodObject<{
1989
- version: import("zod").ZodLiteral<"5">;
1990
- dialect: import("zod").ZodEnum<["pg"]>;
1991
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1992
- name: import("zod").ZodString;
1993
- schema: import("zod").ZodString;
1994
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1995
- name: import("zod").ZodString;
1996
- type: import("zod").ZodString;
1997
- primaryKey: import("zod").ZodBoolean;
1998
- notNull: import("zod").ZodBoolean;
1999
- default: import("zod").ZodOptional<import("zod").ZodAny>;
2000
- isUnique: import("zod").ZodOptional<import("zod").ZodAny>;
2001
- uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
2002
- nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
2003
- }, "strict", import("zod").ZodTypeAny, {
2004
- isUnique?: any;
2005
- default?: any;
2006
- uniqueName?: string | undefined;
2007
- nullsNotDistinct?: boolean | undefined;
2008
- name: string;
2009
- type: string;
2010
- primaryKey: boolean;
2011
- notNull: boolean;
2012
- }, {
2013
- isUnique?: any;
2014
- default?: any;
2015
- uniqueName?: string | undefined;
2016
- nullsNotDistinct?: boolean | undefined;
2017
- name: string;
2018
- type: string;
2019
- primaryKey: boolean;
2020
- notNull: boolean;
2021
- }>>;
2022
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2023
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2024
- compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2025
- uniqueConstraints: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2026
- }, "strict", import("zod").ZodTypeAny, {
2027
- name: string;
2028
- columns: Record<string, {
2029
- isUnique?: any;
2030
- default?: any;
2031
- uniqueName?: string | undefined;
2032
- nullsNotDistinct?: boolean | undefined;
2033
- name: string;
2034
- type: string;
2035
- primaryKey: boolean;
2036
- notNull: boolean;
2037
- }>;
2038
- indexes: Record<string, string>;
2039
- foreignKeys: Record<string, string>;
2040
- schema: string;
2041
- compositePrimaryKeys: Record<string, string>;
2042
- uniqueConstraints: Record<string, string>;
2043
- }, {
2044
- name: string;
2045
- columns: Record<string, {
2046
- isUnique?: any;
2047
- default?: any;
2048
- uniqueName?: string | undefined;
2049
- nullsNotDistinct?: boolean | undefined;
2050
- name: string;
2051
- type: string;
2052
- primaryKey: boolean;
2053
- notNull: boolean;
2054
- }>;
2055
- indexes: Record<string, string>;
2056
- foreignKeys: Record<string, string>;
2057
- schema: string;
2058
- compositePrimaryKeys: Record<string, string>;
2059
- uniqueConstraints: Record<string, string>;
2060
- }>>;
2061
- enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2062
- name: import("zod").ZodString;
2063
- values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2064
- }, "strict", import("zod").ZodTypeAny, {
2065
- name: string;
2066
- values: Record<string, string>;
2067
- }, {
2068
- name: string;
2069
- values: Record<string, string>;
2070
- }>>;
2071
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2072
- }, "strict", import("zod").ZodTypeAny, {
2073
- version: "5";
2074
- dialect: "pg";
2075
- tables: Record<string, {
2076
- name: string;
2077
- columns: Record<string, {
2078
- isUnique?: any;
2079
- default?: any;
2080
- uniqueName?: string | undefined;
2081
- nullsNotDistinct?: boolean | undefined;
2082
- name: string;
2083
- type: string;
2084
- primaryKey: boolean;
2085
- notNull: boolean;
2086
- }>;
2087
- indexes: Record<string, string>;
2088
- foreignKeys: Record<string, string>;
2089
- schema: string;
2090
- compositePrimaryKeys: Record<string, string>;
2091
- uniqueConstraints: Record<string, string>;
2092
- }>;
2093
- schemas: Record<string, string>;
2094
- enums: Record<string, {
2095
- name: string;
2096
- values: Record<string, string>;
2097
- }>;
2098
- }, {
2099
- version: "5";
2100
- dialect: "pg";
2101
- tables: Record<string, {
2102
- name: string;
2103
- columns: Record<string, {
2104
- isUnique?: any;
2105
- default?: any;
2106
- uniqueName?: string | undefined;
2107
- nullsNotDistinct?: boolean | undefined;
2108
- name: string;
2109
- type: string;
2110
- primaryKey: boolean;
2111
- notNull: boolean;
2112
- }>;
2113
- indexes: Record<string, string>;
2114
- foreignKeys: Record<string, string>;
2115
- schema: string;
2116
- compositePrimaryKeys: Record<string, string>;
2117
- uniqueConstraints: Record<string, string>;
2118
- }>;
2119
- schemas: Record<string, string>;
2120
- enums: Record<string, {
2121
- name: string;
2122
- values: Record<string, string>;
2123
- }>;
2124
- }>;
2125
- export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendShape<{
2126
- version: import("zod").ZodLiteral<"3">;
2127
- dialect: import("zod").ZodLiteral<"pg">;
2128
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2129
- name: import("zod").ZodString;
2130
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2131
- name: import("zod").ZodString;
2132
- type: import("zod").ZodString;
2133
- primaryKey: import("zod").ZodBoolean;
2134
- notNull: import("zod").ZodBoolean;
2135
- default: import("zod").ZodOptional<import("zod").ZodAny>;
2136
- isUnique: import("zod").ZodOptional<import("zod").ZodAny>;
2137
- uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
2138
- nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
2139
- }, "strict", import("zod").ZodTypeAny, {
2140
- isUnique?: any;
2141
- default?: any;
2142
- uniqueName?: string | undefined;
2143
- nullsNotDistinct?: boolean | undefined;
2144
- name: string;
2145
- type: string;
2146
- primaryKey: boolean;
2147
- notNull: boolean;
2148
- }, {
2149
- isUnique?: any;
2150
- default?: any;
2151
- uniqueName?: string | undefined;
2152
- nullsNotDistinct?: boolean | undefined;
2153
- name: string;
2154
- type: string;
2155
- primaryKey: boolean;
2156
- notNull: boolean;
2157
- }>>;
2158
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2159
- name: import("zod").ZodString;
2160
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2161
- isUnique: import("zod").ZodBoolean;
2162
- }, "strict", import("zod").ZodTypeAny, {
2163
- name: string;
2164
- columns: string[];
2165
- isUnique: boolean;
2166
- }, {
2167
- name: string;
2168
- columns: string[];
2169
- isUnique: boolean;
2170
- }>>;
2171
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2172
- name: import("zod").ZodString;
2173
- tableFrom: import("zod").ZodString;
2174
- columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
2175
- tableTo: import("zod").ZodString;
2176
- columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
2177
- onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2178
- onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2179
- }, "strict", import("zod").ZodTypeAny, {
2180
- onUpdate?: string | undefined;
2181
- onDelete?: string | undefined;
2182
- name: string;
2183
- tableFrom: string;
2184
- columnsFrom: string[];
2185
- tableTo: string;
2186
- columnsTo: string[];
2187
- }, {
2188
- onUpdate?: string | undefined;
2189
- onDelete?: string | undefined;
2190
- name: string;
2191
- tableFrom: string;
2192
- columnsFrom: string[];
2193
- tableTo: string;
2194
- columnsTo: string[];
2195
- }>>;
2196
- }, "strict", import("zod").ZodTypeAny, {
2197
- name: string;
2198
- columns: Record<string, {
2199
- isUnique?: any;
2200
- default?: any;
2201
- uniqueName?: string | undefined;
2202
- nullsNotDistinct?: boolean | undefined;
2203
- name: string;
2204
- type: string;
2205
- primaryKey: boolean;
2206
- notNull: boolean;
2207
- }>;
2208
- indexes: Record<string, {
2209
- name: string;
2210
- columns: string[];
2211
- isUnique: boolean;
2212
- }>;
2213
- foreignKeys: Record<string, {
2214
- onUpdate?: string | undefined;
2215
- onDelete?: string | undefined;
2216
- name: string;
2217
- tableFrom: string;
2218
- columnsFrom: string[];
2219
- tableTo: string;
2220
- columnsTo: string[];
2221
- }>;
2222
- }, {
2223
- name: string;
2224
- columns: Record<string, {
2225
- isUnique?: any;
2226
- default?: any;
2227
- uniqueName?: string | undefined;
2228
- nullsNotDistinct?: boolean | undefined;
2229
- name: string;
2230
- type: string;
2231
- primaryKey: boolean;
2232
- notNull: boolean;
2233
- }>;
2234
- indexes: Record<string, {
2235
- name: string;
2236
- columns: string[];
2237
- isUnique: boolean;
2238
- }>;
2239
- foreignKeys: Record<string, {
2240
- onUpdate?: string | undefined;
2241
- onDelete?: string | undefined;
2242
- name: string;
2243
- tableFrom: string;
2244
- columnsFrom: string[];
2245
- tableTo: string;
2246
- columnsTo: string[];
2247
- }>;
2248
- }>>;
2249
- enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2250
- name: import("zod").ZodString;
2251
- values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2252
- }, "strict", import("zod").ZodTypeAny, {
2253
- name: string;
2254
- values: Record<string, string>;
2255
- }, {
2256
- name: string;
2257
- values: Record<string, string>;
2258
- }>>;
2259
- }, {
2260
- id: import("zod").ZodString;
2261
- prevId: import("zod").ZodString;
2262
- }>, "strip", import("zod").ZodTypeAny, {
2263
- id: string;
2264
- prevId: string;
2265
- version: "3";
2266
- dialect: "pg";
2267
- tables: Record<string, {
2268
- name: string;
2269
- columns: Record<string, {
2270
- isUnique?: any;
2271
- default?: any;
2272
- uniqueName?: string | undefined;
2273
- nullsNotDistinct?: boolean | undefined;
2274
- name: string;
2275
- type: string;
2276
- primaryKey: boolean;
2277
- notNull: boolean;
2278
- }>;
2279
- indexes: Record<string, {
2280
- name: string;
2281
- columns: string[];
2282
- isUnique: boolean;
2283
- }>;
2284
- foreignKeys: Record<string, {
2285
- onUpdate?: string | undefined;
2286
- onDelete?: string | undefined;
2287
- name: string;
2288
- tableFrom: string;
2289
- columnsFrom: string[];
2290
- tableTo: string;
2291
- columnsTo: string[];
2292
- }>;
2293
- }>;
2294
- enums: Record<string, {
2295
- name: string;
2296
- values: Record<string, string>;
2297
- }>;
2298
- }, {
2299
- id: string;
2300
- prevId: string;
2301
- version: "3";
2302
- dialect: "pg";
2303
- tables: Record<string, {
2304
- name: string;
2305
- columns: Record<string, {
2306
- isUnique?: any;
2307
- default?: any;
2308
- uniqueName?: string | undefined;
2309
- nullsNotDistinct?: boolean | undefined;
2310
- name: string;
2311
- type: string;
2312
- primaryKey: boolean;
2313
- notNull: boolean;
2314
- }>;
2315
- indexes: Record<string, {
2316
- name: string;
2317
- columns: string[];
2318
- isUnique: boolean;
2319
- }>;
2320
- foreignKeys: Record<string, {
2321
- onUpdate?: string | undefined;
2322
- onDelete?: string | undefined;
2323
- name: string;
2324
- tableFrom: string;
2325
- columnsFrom: string[];
2326
- tableTo: string;
2327
- columnsTo: string[];
2328
- }>;
2329
- }>;
2330
- enums: Record<string, {
2331
- name: string;
2332
- values: Record<string, string>;
2333
- }>;
2334
- }>;
2335
- export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendShape<{
2336
- version: import("zod").ZodLiteral<"4">;
2337
- dialect: import("zod").ZodLiteral<"pg">;
2338
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2339
- name: import("zod").ZodString;
2340
- schema: import("zod").ZodString;
2341
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2342
- name: import("zod").ZodString;
2343
- type: import("zod").ZodString;
2344
- primaryKey: import("zod").ZodBoolean;
2345
- notNull: import("zod").ZodBoolean;
2346
- default: import("zod").ZodOptional<import("zod").ZodAny>;
2347
- isUnique: import("zod").ZodOptional<import("zod").ZodAny>;
2348
- uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
2349
- nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
2350
- }, "strict", import("zod").ZodTypeAny, {
2351
- isUnique?: any;
2352
- default?: any;
2353
- uniqueName?: string | undefined;
2354
- nullsNotDistinct?: boolean | undefined;
2355
- name: string;
2356
- type: string;
2357
- primaryKey: boolean;
2358
- notNull: boolean;
2359
- }, {
2360
- isUnique?: any;
2361
- default?: any;
2362
- uniqueName?: string | undefined;
2363
- nullsNotDistinct?: boolean | undefined;
2364
- name: string;
2365
- type: string;
2366
- primaryKey: boolean;
2367
- notNull: boolean;
2368
- }>>;
2369
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2370
- name: import("zod").ZodString;
2371
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2372
- isUnique: import("zod").ZodBoolean;
2373
- }, "strict", import("zod").ZodTypeAny, {
2374
- name: string;
2375
- columns: string[];
2376
- isUnique: boolean;
2377
- }, {
2378
- name: string;
2379
- columns: string[];
2380
- isUnique: boolean;
2381
- }>>;
2382
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2383
- name: import("zod").ZodString;
2384
- tableFrom: import("zod").ZodString;
2385
- columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
2386
- tableTo: import("zod").ZodString;
2387
- columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
2388
- onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2389
- onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2390
- }, "strict", import("zod").ZodTypeAny, {
2391
- onUpdate?: string | undefined;
2392
- onDelete?: string | undefined;
2393
- name: string;
2394
- tableFrom: string;
2395
- columnsFrom: string[];
2396
- tableTo: string;
2397
- columnsTo: string[];
2398
- }, {
2399
- onUpdate?: string | undefined;
2400
- onDelete?: string | undefined;
2401
- name: string;
2402
- tableFrom: string;
2403
- columnsFrom: string[];
2404
- tableTo: string;
2405
- columnsTo: string[];
2406
- }>>;
2407
- }, "strict", import("zod").ZodTypeAny, {
2408
- name: string;
2409
- columns: Record<string, {
2410
- isUnique?: any;
2411
- default?: any;
2412
- uniqueName?: string | undefined;
2413
- nullsNotDistinct?: boolean | undefined;
2414
- name: string;
2415
- type: string;
2416
- primaryKey: boolean;
2417
- notNull: boolean;
2418
- }>;
2419
- indexes: Record<string, {
2420
- name: string;
2421
- columns: string[];
2422
- isUnique: boolean;
2423
- }>;
2424
- foreignKeys: Record<string, {
2425
- onUpdate?: string | undefined;
2426
- onDelete?: string | undefined;
2427
- name: string;
2428
- tableFrom: string;
2429
- columnsFrom: string[];
2430
- tableTo: string;
2431
- columnsTo: string[];
2432
- }>;
2433
- schema: string;
2434
- }, {
2435
- name: string;
2436
- columns: Record<string, {
2437
- isUnique?: any;
2438
- default?: any;
2439
- uniqueName?: string | undefined;
2440
- nullsNotDistinct?: boolean | undefined;
2441
- name: string;
2442
- type: string;
2443
- primaryKey: boolean;
2444
- notNull: boolean;
2445
- }>;
2446
- indexes: Record<string, {
2447
- name: string;
2448
- columns: string[];
2449
- isUnique: boolean;
2450
- }>;
2451
- foreignKeys: Record<string, {
2452
- onUpdate?: string | undefined;
2453
- onDelete?: string | undefined;
2454
- name: string;
2455
- tableFrom: string;
2456
- columnsFrom: string[];
2457
- tableTo: string;
2458
- columnsTo: string[];
2459
- }>;
2460
- schema: string;
2461
- }>>;
2462
- enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2463
- name: import("zod").ZodString;
2464
- values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2465
- }, "strict", import("zod").ZodTypeAny, {
2466
- name: string;
2467
- values: Record<string, string>;
2468
- }, {
2469
- name: string;
2470
- values: Record<string, string>;
2471
- }>>;
2472
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2473
- }, {
2474
- id: import("zod").ZodString;
2475
- prevId: import("zod").ZodString;
2476
- }>, "strip", import("zod").ZodTypeAny, {
2477
- id: string;
2478
- prevId: string;
2479
- version: "4";
2480
- dialect: "pg";
2481
- tables: Record<string, {
2482
- name: string;
2483
- columns: Record<string, {
2484
- isUnique?: any;
2485
- default?: any;
2486
- uniqueName?: string | undefined;
2487
- nullsNotDistinct?: boolean | undefined;
2488
- name: string;
2489
- type: string;
2490
- primaryKey: boolean;
2491
- notNull: boolean;
2492
- }>;
2493
- indexes: Record<string, {
2494
- name: string;
2495
- columns: string[];
2496
- isUnique: boolean;
2497
- }>;
2498
- foreignKeys: Record<string, {
2499
- onUpdate?: string | undefined;
2500
- onDelete?: string | undefined;
2501
- name: string;
2502
- tableFrom: string;
2503
- columnsFrom: string[];
2504
- tableTo: string;
2505
- columnsTo: string[];
2506
- }>;
2507
- schema: string;
2508
- }>;
2509
- schemas: Record<string, string>;
2510
- enums: Record<string, {
2511
- name: string;
2512
- values: Record<string, string>;
2513
- }>;
2514
- }, {
2515
- id: string;
2516
- prevId: string;
2517
- version: "4";
2518
- dialect: "pg";
2519
- tables: Record<string, {
2520
- name: string;
2521
- columns: Record<string, {
2522
- isUnique?: any;
2523
- default?: any;
2524
- uniqueName?: string | undefined;
2525
- nullsNotDistinct?: boolean | undefined;
2526
- name: string;
2527
- type: string;
2528
- primaryKey: boolean;
2529
- notNull: boolean;
2530
- }>;
2531
- indexes: Record<string, {
2532
- name: string;
2533
- columns: string[];
2534
- isUnique: boolean;
2535
- }>;
2536
- foreignKeys: Record<string, {
2537
- onUpdate?: string | undefined;
2538
- onDelete?: string | undefined;
2539
- name: string;
2540
- tableFrom: string;
2541
- columnsFrom: string[];
2542
- tableTo: string;
2543
- columnsTo: string[];
2544
- }>;
2545
- schema: string;
2546
- }>;
2547
- schemas: Record<string, string>;
2548
- enums: Record<string, {
2549
- name: string;
2550
- values: Record<string, string>;
2551
- }>;
2552
- }>;
2553
- export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape<{
2554
- version: import("zod").ZodLiteral<"5">;
2555
- dialect: import("zod").ZodLiteral<"pg">;
2556
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2557
- name: import("zod").ZodString;
2558
- schema: import("zod").ZodString;
2559
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2560
- name: import("zod").ZodString;
2561
- type: import("zod").ZodString;
2562
- primaryKey: import("zod").ZodBoolean;
2563
- notNull: import("zod").ZodBoolean;
2564
- default: import("zod").ZodOptional<import("zod").ZodAny>;
2565
- isUnique: import("zod").ZodOptional<import("zod").ZodAny>;
2566
- uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
2567
- nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
2568
- }, "strict", import("zod").ZodTypeAny, {
2569
- isUnique?: any;
2570
- default?: any;
2571
- uniqueName?: string | undefined;
2572
- nullsNotDistinct?: boolean | undefined;
2573
- name: string;
2574
- type: string;
2575
- primaryKey: boolean;
2576
- notNull: boolean;
2577
- }, {
2578
- isUnique?: any;
2579
- default?: any;
2580
- uniqueName?: string | undefined;
2581
- nullsNotDistinct?: boolean | undefined;
2582
- name: string;
2583
- type: string;
2584
- primaryKey: boolean;
2585
- notNull: boolean;
2586
- }>>;
2587
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2588
- name: import("zod").ZodString;
2589
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2590
- isUnique: import("zod").ZodBoolean;
2591
- }, "strict", import("zod").ZodTypeAny, {
2592
- name: string;
2593
- columns: string[];
2594
- isUnique: boolean;
2595
- }, {
2596
- name: string;
2597
- columns: string[];
2598
- isUnique: boolean;
2599
- }>>;
2600
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2601
- name: import("zod").ZodString;
2602
- tableFrom: import("zod").ZodString;
2603
- columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
2604
- tableTo: import("zod").ZodString;
2605
- columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
2606
- onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2607
- onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2608
- }, "strict", import("zod").ZodTypeAny, {
2609
- onUpdate?: string | undefined;
2610
- onDelete?: string | undefined;
2611
- name: string;
2612
- tableFrom: string;
2613
- columnsFrom: string[];
2614
- tableTo: string;
2615
- columnsTo: string[];
2616
- }, {
2617
- onUpdate?: string | undefined;
2618
- onDelete?: string | undefined;
2619
- name: string;
2620
- tableFrom: string;
2621
- columnsFrom: string[];
2622
- tableTo: string;
2623
- columnsTo: string[];
2624
- }>>;
2625
- compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2626
- name: import("zod").ZodString;
2627
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2628
- }, "strict", import("zod").ZodTypeAny, {
2629
- name: string;
2630
- columns: string[];
2631
- }, {
2632
- name: string;
2633
- columns: string[];
2634
- }>>;
2635
- uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2636
- name: import("zod").ZodString;
2637
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2638
- nullsNotDistinct: import("zod").ZodBoolean;
2639
- }, "strict", import("zod").ZodTypeAny, {
2640
- name: string;
2641
- columns: string[];
2642
- nullsNotDistinct: boolean;
2643
- }, {
2644
- name: string;
2645
- columns: string[];
2646
- nullsNotDistinct: boolean;
2647
- }>>>;
2648
- }, "strict", import("zod").ZodTypeAny, {
2649
- name: string;
2650
- columns: Record<string, {
2651
- isUnique?: any;
2652
- default?: any;
2653
- uniqueName?: string | undefined;
2654
- nullsNotDistinct?: boolean | undefined;
2655
- name: string;
2656
- type: string;
2657
- primaryKey: boolean;
2658
- notNull: boolean;
2659
- }>;
2660
- indexes: Record<string, {
2661
- name: string;
2662
- columns: string[];
2663
- isUnique: boolean;
2664
- }>;
2665
- foreignKeys: Record<string, {
2666
- onUpdate?: string | undefined;
2667
- onDelete?: string | undefined;
2668
- name: string;
2669
- tableFrom: string;
2670
- columnsFrom: string[];
2671
- tableTo: string;
2672
- columnsTo: string[];
2673
- }>;
2674
- schema: string;
2675
- compositePrimaryKeys: Record<string, {
2676
- name: string;
2677
- columns: string[];
2678
- }>;
2679
- uniqueConstraints: Record<string, {
2680
- name: string;
2681
- columns: string[];
2682
- nullsNotDistinct: boolean;
2683
- }>;
2684
- }, {
2685
- uniqueConstraints?: Record<string, {
2686
- name: string;
2687
- columns: string[];
2688
- nullsNotDistinct: boolean;
2689
- }> | undefined;
2690
- name: string;
2691
- columns: Record<string, {
2692
- isUnique?: any;
2693
- default?: any;
2694
- uniqueName?: string | undefined;
2695
- nullsNotDistinct?: boolean | undefined;
2696
- name: string;
2697
- type: string;
2698
- primaryKey: boolean;
2699
- notNull: boolean;
2700
- }>;
2701
- indexes: Record<string, {
2702
- name: string;
2703
- columns: string[];
2704
- isUnique: boolean;
2705
- }>;
2706
- foreignKeys: Record<string, {
2707
- onUpdate?: string | undefined;
2708
- onDelete?: string | undefined;
2709
- name: string;
2710
- tableFrom: string;
2711
- columnsFrom: string[];
2712
- tableTo: string;
2713
- columnsTo: string[];
2714
- }>;
2715
- schema: string;
2716
- compositePrimaryKeys: Record<string, {
2717
- name: string;
2718
- columns: string[];
2719
- }>;
2720
- }>>;
2721
- enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2722
- name: import("zod").ZodString;
2723
- values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2724
- }, "strict", import("zod").ZodTypeAny, {
2725
- name: string;
2726
- values: Record<string, string>;
2727
- }, {
2728
- name: string;
2729
- values: Record<string, string>;
2730
- }>>;
2731
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2732
- _meta: import("zod").ZodObject<{
2733
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2734
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2735
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2736
- }, "strip", import("zod").ZodTypeAny, {
2737
- columns: Record<string, string>;
2738
- tables: Record<string, string>;
2739
- schemas: Record<string, string>;
2740
- }, {
2741
- columns: Record<string, string>;
2742
- tables: Record<string, string>;
2743
- schemas: Record<string, string>;
2744
- }>;
2745
- }, {
2746
- id: import("zod").ZodString;
2747
- prevId: import("zod").ZodString;
2748
- }>, "strip", import("zod").ZodTypeAny, {
2749
- id: string;
2750
- prevId: string;
2751
- version: "5";
2752
- dialect: "pg";
2753
- tables: Record<string, {
2754
- name: string;
2755
- columns: Record<string, {
2756
- isUnique?: any;
2757
- default?: any;
2758
- uniqueName?: string | undefined;
2759
- nullsNotDistinct?: boolean | undefined;
2760
- name: string;
2761
- type: string;
2762
- primaryKey: boolean;
2763
- notNull: boolean;
2764
- }>;
2765
- indexes: Record<string, {
2766
- name: string;
2767
- columns: string[];
2768
- isUnique: boolean;
2769
- }>;
2770
- foreignKeys: Record<string, {
2771
- onUpdate?: string | undefined;
2772
- onDelete?: string | undefined;
2773
- name: string;
2774
- tableFrom: string;
2775
- columnsFrom: string[];
2776
- tableTo: string;
2777
- columnsTo: string[];
2778
- }>;
2779
- schema: string;
2780
- compositePrimaryKeys: Record<string, {
2781
- name: string;
2782
- columns: string[];
2783
- }>;
2784
- uniqueConstraints: Record<string, {
2785
- name: string;
2786
- columns: string[];
2787
- nullsNotDistinct: boolean;
2788
- }>;
2789
- }>;
2790
- schemas: Record<string, string>;
2791
- _meta: {
2792
- columns: Record<string, string>;
2793
- tables: Record<string, string>;
2794
- schemas: Record<string, string>;
2795
- };
2796
- enums: Record<string, {
2797
- name: string;
2798
- values: Record<string, string>;
2799
- }>;
2800
- }, {
2801
- id: string;
2802
- prevId: string;
2803
- version: "5";
2804
- dialect: "pg";
2805
- tables: Record<string, {
2806
- uniqueConstraints?: Record<string, {
2807
- name: string;
2808
- columns: string[];
2809
- nullsNotDistinct: boolean;
2810
- }> | undefined;
2811
- name: string;
2812
- columns: Record<string, {
2813
- isUnique?: any;
2814
- default?: any;
2815
- uniqueName?: string | undefined;
2816
- nullsNotDistinct?: boolean | undefined;
2817
- name: string;
2818
- type: string;
2819
- primaryKey: boolean;
2820
- notNull: boolean;
2821
- }>;
2822
- indexes: Record<string, {
2823
- name: string;
2824
- columns: string[];
2825
- isUnique: boolean;
2826
- }>;
2827
- foreignKeys: Record<string, {
2828
- onUpdate?: string | undefined;
2829
- onDelete?: string | undefined;
2830
- name: string;
2831
- tableFrom: string;
2832
- columnsFrom: string[];
2833
- tableTo: string;
2834
- columnsTo: string[];
2835
- }>;
2836
- schema: string;
2837
- compositePrimaryKeys: Record<string, {
2838
- name: string;
2839
- columns: string[];
2840
- }>;
2841
- }>;
2842
- schemas: Record<string, string>;
2843
- _meta: {
2844
- columns: Record<string, string>;
2845
- tables: Record<string, string>;
2846
- schemas: Record<string, string>;
2847
- };
2848
- enums: Record<string, {
2849
- name: string;
2850
- values: Record<string, string>;
2851
- }>;
2852
- }>;
2853
- export type Enum = TypeOf<typeof enumSchema>;
2854
- export type Column = TypeOf<typeof column>;
2855
- export type TableV3 = TypeOf<typeof tableV3>;
2856
- export type TableV4 = TypeOf<typeof tableV4>;
2857
- export type Table = TypeOf<typeof table>;
2858
- export type PgSchema = TypeOf<typeof pgSchema>;
2859
- export type PgSchemaInternal = TypeOf<typeof pgSchemaInternal>;
2860
- export type PgSchemaExternal = TypeOf<typeof pgSchemaExternal>;
2861
- export type PgSchemaSquashed = TypeOf<typeof pgSchemaSquashed>;
2862
- export type PgSchemaSquashedV4 = TypeOf<typeof pgSchemaSquashedV4>;
2863
- export type Index = TypeOf<typeof index>;
2864
- export type ForeignKey = TypeOf<typeof fk>;
2865
- export type PrimaryKey = TypeOf<typeof compositePK>;
2866
- export type UniqueConstraint = TypeOf<typeof uniqueConstraint>;
2867
- export type PgSchemaV1 = TypeOf<typeof pgSchemaV1>;
2868
- export type PgSchemaV2 = TypeOf<typeof pgSchemaV2>;
2869
- export type PgSchemaV3 = TypeOf<typeof pgSchemaV3>;
2870
- export type PgSchemaV4 = TypeOf<typeof pgSchemaV4>;
2871
- export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import("zod").ZodObject<{
2872
- version: import("zod").ZodLiteral<"1">;
2873
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2874
- name: import("zod").ZodString;
2875
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2876
- name: import("zod").ZodString;
2877
- type: import("zod").ZodString;
2878
- primaryKey: import("zod").ZodBoolean;
2879
- notNull: import("zod").ZodBoolean;
2880
- default: import("zod").ZodOptional<import("zod").ZodAny>;
2881
- references: import("zod").ZodOptional<import("zod").ZodObject<{
2882
- foreignKeyName: import("zod").ZodString;
2883
- table: import("zod").ZodString;
2884
- column: import("zod").ZodString;
2885
- onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2886
- onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2887
- }, "strict", import("zod").ZodTypeAny, {
2888
- onUpdate?: string | undefined;
2889
- onDelete?: string | undefined;
2890
- column: string;
2891
- foreignKeyName: string;
2892
- table: string;
2893
- }, {
2894
- onUpdate?: string | undefined;
2895
- onDelete?: string | undefined;
2896
- column: string;
2897
- foreignKeyName: string;
2898
- table: string;
2899
- }>>;
2900
- }, "strict", import("zod").ZodTypeAny, {
2901
- default?: any;
2902
- references?: {
2903
- onUpdate?: string | undefined;
2904
- onDelete?: string | undefined;
2905
- column: string;
2906
- foreignKeyName: string;
2907
- table: string;
2908
- } | undefined;
2909
- name: string;
2910
- type: string;
2911
- primaryKey: boolean;
2912
- notNull: boolean;
2913
- }, {
2914
- default?: any;
2915
- references?: {
2916
- onUpdate?: string | undefined;
2917
- onDelete?: string | undefined;
2918
- column: string;
2919
- foreignKeyName: string;
2920
- table: string;
2921
- } | undefined;
2922
- name: string;
2923
- type: string;
2924
- primaryKey: boolean;
2925
- notNull: boolean;
2926
- }>>;
2927
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2928
- name: import("zod").ZodString;
2929
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2930
- name: import("zod").ZodString;
2931
- }, "strip", import("zod").ZodTypeAny, {
2932
- name: string;
2933
- }, {
2934
- name: string;
2935
- }>>;
2936
- isUnique: import("zod").ZodBoolean;
2937
- }, "strict", import("zod").ZodTypeAny, {
2938
- name: string;
2939
- columns: Record<string, {
2940
- name: string;
2941
- }>;
2942
- isUnique: boolean;
2943
- }, {
2944
- name: string;
2945
- columns: Record<string, {
2946
- name: string;
2947
- }>;
2948
- isUnique: boolean;
2949
- }>>;
2950
- }, "strict", import("zod").ZodTypeAny, {
2951
- name: string;
2952
- columns: Record<string, {
2953
- default?: any;
2954
- references?: {
2955
- onUpdate?: string | undefined;
2956
- onDelete?: string | undefined;
2957
- column: string;
2958
- foreignKeyName: string;
2959
- table: string;
2960
- } | undefined;
2961
- name: string;
2962
- type: string;
2963
- primaryKey: boolean;
2964
- notNull: boolean;
2965
- }>;
2966
- indexes: Record<string, {
2967
- name: string;
2968
- columns: Record<string, {
2969
- name: string;
2970
- }>;
2971
- isUnique: boolean;
2972
- }>;
2973
- }, {
2974
- name: string;
2975
- columns: Record<string, {
2976
- default?: any;
2977
- references?: {
2978
- onUpdate?: string | undefined;
2979
- onDelete?: string | undefined;
2980
- column: string;
2981
- foreignKeyName: string;
2982
- table: string;
2983
- } | undefined;
2984
- name: string;
2985
- type: string;
2986
- primaryKey: boolean;
2987
- notNull: boolean;
2988
- }>;
2989
- indexes: Record<string, {
2990
- name: string;
2991
- columns: Record<string, {
2992
- name: string;
2993
- }>;
2994
- isUnique: boolean;
2995
- }>;
2996
- }>>;
2997
- enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2998
- name: import("zod").ZodString;
2999
- values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3000
- }, "strict", import("zod").ZodTypeAny, {
3001
- name: string;
3002
- values: Record<string, string>;
3003
- }, {
3004
- name: string;
3005
- values: Record<string, string>;
3006
- }>>;
3007
- }, "strict", import("zod").ZodTypeAny, {
3008
- version: "1";
3009
- tables: Record<string, {
3010
- name: string;
3011
- columns: Record<string, {
3012
- default?: any;
3013
- references?: {
3014
- onUpdate?: string | undefined;
3015
- onDelete?: string | undefined;
3016
- column: string;
3017
- foreignKeyName: string;
3018
- table: string;
3019
- } | undefined;
3020
- name: string;
3021
- type: string;
3022
- primaryKey: boolean;
3023
- notNull: boolean;
3024
- }>;
3025
- indexes: Record<string, {
3026
- name: string;
3027
- columns: Record<string, {
3028
- name: string;
3029
- }>;
3030
- isUnique: boolean;
3031
- }>;
3032
- }>;
3033
- enums: Record<string, {
3034
- name: string;
3035
- values: Record<string, string>;
3036
- }>;
3037
- }, {
3038
- version: "1";
3039
- tables: Record<string, {
3040
- name: string;
3041
- columns: Record<string, {
3042
- default?: any;
3043
- references?: {
3044
- onUpdate?: string | undefined;
3045
- onDelete?: string | undefined;
3046
- column: string;
3047
- foreignKeyName: string;
3048
- table: string;
3049
- } | undefined;
3050
- name: string;
3051
- type: string;
3052
- primaryKey: boolean;
3053
- notNull: boolean;
3054
- }>;
3055
- indexes: Record<string, {
3056
- name: string;
3057
- columns: Record<string, {
3058
- name: string;
3059
- }>;
3060
- isUnique: boolean;
3061
- }>;
3062
- }>;
3063
- enums: Record<string, {
3064
- name: string;
3065
- values: Record<string, string>;
3066
- }>;
3067
- }>, import("zod").ZodObject<{
3068
- version: import("zod").ZodLiteral<"2">;
3069
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3070
- name: import("zod").ZodString;
3071
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3072
- name: import("zod").ZodString;
3073
- type: import("zod").ZodString;
3074
- primaryKey: import("zod").ZodBoolean;
3075
- notNull: import("zod").ZodBoolean;
3076
- default: import("zod").ZodOptional<import("zod").ZodAny>;
3077
- references: import("zod").ZodOptional<import("zod").ZodString>;
3078
- }, "strict", import("zod").ZodTypeAny, {
3079
- default?: any;
3080
- references?: string | undefined;
3081
- name: string;
3082
- type: string;
3083
- primaryKey: boolean;
3084
- notNull: boolean;
3085
- }, {
3086
- default?: any;
3087
- references?: string | undefined;
3088
- name: string;
3089
- type: string;
3090
- primaryKey: boolean;
3091
- notNull: boolean;
3092
- }>>;
3093
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3094
- name: import("zod").ZodString;
3095
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3096
- name: import("zod").ZodString;
3097
- }, "strip", import("zod").ZodTypeAny, {
3098
- name: string;
3099
- }, {
3100
- name: string;
3101
- }>>;
3102
- isUnique: import("zod").ZodBoolean;
3103
- }, "strict", import("zod").ZodTypeAny, {
3104
- name: string;
3105
- columns: Record<string, {
3106
- name: string;
3107
- }>;
3108
- isUnique: boolean;
3109
- }, {
3110
- name: string;
3111
- columns: Record<string, {
3112
- name: string;
3113
- }>;
3114
- isUnique: boolean;
3115
- }>>;
3116
- }, "strict", import("zod").ZodTypeAny, {
3117
- name: string;
3118
- columns: Record<string, {
3119
- default?: any;
3120
- references?: string | undefined;
3121
- name: string;
3122
- type: string;
3123
- primaryKey: boolean;
3124
- notNull: boolean;
3125
- }>;
3126
- indexes: Record<string, {
3127
- name: string;
3128
- columns: Record<string, {
3129
- name: string;
3130
- }>;
3131
- isUnique: boolean;
3132
- }>;
3133
- }, {
3134
- name: string;
3135
- columns: Record<string, {
3136
- default?: any;
3137
- references?: string | undefined;
3138
- name: string;
3139
- type: string;
3140
- primaryKey: boolean;
3141
- notNull: boolean;
3142
- }>;
3143
- indexes: Record<string, {
3144
- name: string;
3145
- columns: Record<string, {
3146
- name: string;
3147
- }>;
3148
- isUnique: boolean;
3149
- }>;
3150
- }>>;
3151
- enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3152
- name: import("zod").ZodString;
3153
- values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3154
- }, "strict", import("zod").ZodTypeAny, {
3155
- name: string;
3156
- values: Record<string, string>;
3157
- }, {
3158
- name: string;
3159
- values: Record<string, string>;
3160
- }>>;
3161
- }, "strict", import("zod").ZodTypeAny, {
3162
- version: "2";
3163
- tables: Record<string, {
3164
- name: string;
3165
- columns: Record<string, {
3166
- default?: any;
3167
- references?: string | undefined;
3168
- name: string;
3169
- type: string;
3170
- primaryKey: boolean;
3171
- notNull: boolean;
3172
- }>;
3173
- indexes: Record<string, {
3174
- name: string;
3175
- columns: Record<string, {
3176
- name: string;
3177
- }>;
3178
- isUnique: boolean;
3179
- }>;
3180
- }>;
3181
- enums: Record<string, {
3182
- name: string;
3183
- values: Record<string, string>;
3184
- }>;
3185
- }, {
3186
- version: "2";
3187
- tables: Record<string, {
3188
- name: string;
3189
- columns: Record<string, {
3190
- default?: any;
3191
- references?: string | undefined;
3192
- name: string;
3193
- type: string;
3194
- primaryKey: boolean;
3195
- notNull: boolean;
3196
- }>;
3197
- indexes: Record<string, {
3198
- name: string;
3199
- columns: Record<string, {
3200
- name: string;
3201
- }>;
3202
- isUnique: boolean;
3203
- }>;
3204
- }>;
3205
- enums: Record<string, {
3206
- name: string;
3207
- values: Record<string, string>;
3208
- }>;
3209
- }>, import("zod").ZodObject<import("zod").extendShape<{
3210
- version: import("zod").ZodLiteral<"3">;
3211
- dialect: import("zod").ZodLiteral<"pg">;
3212
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3213
- name: import("zod").ZodString;
3214
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3215
- name: import("zod").ZodString;
3216
- type: import("zod").ZodString;
3217
- primaryKey: import("zod").ZodBoolean;
3218
- notNull: import("zod").ZodBoolean;
3219
- default: import("zod").ZodOptional<import("zod").ZodAny>;
3220
- isUnique: import("zod").ZodOptional<import("zod").ZodAny>;
3221
- uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
3222
- nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
3223
- }, "strict", import("zod").ZodTypeAny, {
3224
- isUnique?: any;
3225
- default?: any;
3226
- uniqueName?: string | undefined;
3227
- nullsNotDistinct?: boolean | undefined;
3228
- name: string;
3229
- type: string;
3230
- primaryKey: boolean;
3231
- notNull: boolean;
3232
- }, {
3233
- isUnique?: any;
3234
- default?: any;
3235
- uniqueName?: string | undefined;
3236
- nullsNotDistinct?: boolean | undefined;
3237
- name: string;
3238
- type: string;
3239
- primaryKey: boolean;
3240
- notNull: boolean;
3241
- }>>;
3242
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3243
- name: import("zod").ZodString;
3244
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
3245
- isUnique: import("zod").ZodBoolean;
3246
- }, "strict", import("zod").ZodTypeAny, {
3247
- name: string;
3248
- columns: string[];
3249
- isUnique: boolean;
3250
- }, {
3251
- name: string;
3252
- columns: string[];
3253
- isUnique: boolean;
3254
- }>>;
3255
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3256
- name: import("zod").ZodString;
3257
- tableFrom: import("zod").ZodString;
3258
- columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
3259
- tableTo: import("zod").ZodString;
3260
- columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
3261
- onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
3262
- onDelete: import("zod").ZodOptional<import("zod").ZodString>;
3263
- }, "strict", import("zod").ZodTypeAny, {
3264
- onUpdate?: string | undefined;
3265
- onDelete?: string | undefined;
3266
- name: string;
3267
- tableFrom: string;
3268
- columnsFrom: string[];
3269
- tableTo: string;
3270
- columnsTo: string[];
3271
- }, {
3272
- onUpdate?: string | undefined;
3273
- onDelete?: string | undefined;
3274
- name: string;
3275
- tableFrom: string;
3276
- columnsFrom: string[];
3277
- tableTo: string;
3278
- columnsTo: string[];
3279
- }>>;
3280
- }, "strict", import("zod").ZodTypeAny, {
3281
- name: string;
3282
- columns: Record<string, {
3283
- isUnique?: any;
3284
- default?: any;
3285
- uniqueName?: string | undefined;
3286
- nullsNotDistinct?: boolean | undefined;
3287
- name: string;
3288
- type: string;
3289
- primaryKey: boolean;
3290
- notNull: boolean;
3291
- }>;
3292
- indexes: Record<string, {
3293
- name: string;
3294
- columns: string[];
3295
- isUnique: boolean;
3296
- }>;
3297
- foreignKeys: Record<string, {
3298
- onUpdate?: string | undefined;
3299
- onDelete?: string | undefined;
3300
- name: string;
3301
- tableFrom: string;
3302
- columnsFrom: string[];
3303
- tableTo: string;
3304
- columnsTo: string[];
3305
- }>;
3306
- }, {
3307
- name: string;
3308
- columns: Record<string, {
3309
- isUnique?: any;
3310
- default?: any;
3311
- uniqueName?: string | undefined;
3312
- nullsNotDistinct?: boolean | undefined;
3313
- name: string;
3314
- type: string;
3315
- primaryKey: boolean;
3316
- notNull: boolean;
3317
- }>;
3318
- indexes: Record<string, {
3319
- name: string;
3320
- columns: string[];
3321
- isUnique: boolean;
3322
- }>;
3323
- foreignKeys: Record<string, {
3324
- onUpdate?: string | undefined;
3325
- onDelete?: string | undefined;
3326
- name: string;
3327
- tableFrom: string;
3328
- columnsFrom: string[];
3329
- tableTo: string;
3330
- columnsTo: string[];
3331
- }>;
3332
- }>>;
3333
- enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3334
- name: import("zod").ZodString;
3335
- values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3336
- }, "strict", import("zod").ZodTypeAny, {
3337
- name: string;
3338
- values: Record<string, string>;
3339
- }, {
3340
- name: string;
3341
- values: Record<string, string>;
3342
- }>>;
3343
- }, {
3344
- id: import("zod").ZodString;
3345
- prevId: import("zod").ZodString;
3346
- }>, "strip", import("zod").ZodTypeAny, {
3347
- id: string;
3348
- prevId: string;
3349
- version: "3";
3350
- dialect: "pg";
3351
- tables: Record<string, {
3352
- name: string;
3353
- columns: Record<string, {
3354
- isUnique?: any;
3355
- default?: any;
3356
- uniqueName?: string | undefined;
3357
- nullsNotDistinct?: boolean | undefined;
3358
- name: string;
3359
- type: string;
3360
- primaryKey: boolean;
3361
- notNull: boolean;
3362
- }>;
3363
- indexes: Record<string, {
3364
- name: string;
3365
- columns: string[];
3366
- isUnique: boolean;
3367
- }>;
3368
- foreignKeys: Record<string, {
3369
- onUpdate?: string | undefined;
3370
- onDelete?: string | undefined;
3371
- name: string;
3372
- tableFrom: string;
3373
- columnsFrom: string[];
3374
- tableTo: string;
3375
- columnsTo: string[];
3376
- }>;
3377
- }>;
3378
- enums: Record<string, {
3379
- name: string;
3380
- values: Record<string, string>;
3381
- }>;
3382
- }, {
3383
- id: string;
3384
- prevId: string;
3385
- version: "3";
3386
- dialect: "pg";
3387
- tables: Record<string, {
3388
- name: string;
3389
- columns: Record<string, {
3390
- isUnique?: any;
3391
- default?: any;
3392
- uniqueName?: string | undefined;
3393
- nullsNotDistinct?: boolean | undefined;
3394
- name: string;
3395
- type: string;
3396
- primaryKey: boolean;
3397
- notNull: boolean;
3398
- }>;
3399
- indexes: Record<string, {
3400
- name: string;
3401
- columns: string[];
3402
- isUnique: boolean;
3403
- }>;
3404
- foreignKeys: Record<string, {
3405
- onUpdate?: string | undefined;
3406
- onDelete?: string | undefined;
3407
- name: string;
3408
- tableFrom: string;
3409
- columnsFrom: string[];
3410
- tableTo: string;
3411
- columnsTo: string[];
3412
- }>;
3413
- }>;
3414
- enums: Record<string, {
3415
- name: string;
3416
- values: Record<string, string>;
3417
- }>;
3418
- }>, import("zod").ZodObject<import("zod").extendShape<{
3419
- version: import("zod").ZodLiteral<"4">;
3420
- dialect: import("zod").ZodLiteral<"pg">;
3421
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3422
- name: import("zod").ZodString;
3423
- schema: import("zod").ZodString;
3424
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3425
- name: import("zod").ZodString;
3426
- type: import("zod").ZodString;
3427
- primaryKey: import("zod").ZodBoolean;
3428
- notNull: import("zod").ZodBoolean;
3429
- default: import("zod").ZodOptional<import("zod").ZodAny>;
3430
- isUnique: import("zod").ZodOptional<import("zod").ZodAny>;
3431
- uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
3432
- nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
3433
- }, "strict", import("zod").ZodTypeAny, {
3434
- isUnique?: any;
3435
- default?: any;
3436
- uniqueName?: string | undefined;
3437
- nullsNotDistinct?: boolean | undefined;
3438
- name: string;
3439
- type: string;
3440
- primaryKey: boolean;
3441
- notNull: boolean;
3442
- }, {
3443
- isUnique?: any;
3444
- default?: any;
3445
- uniqueName?: string | undefined;
3446
- nullsNotDistinct?: boolean | undefined;
3447
- name: string;
3448
- type: string;
3449
- primaryKey: boolean;
3450
- notNull: boolean;
3451
- }>>;
3452
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3453
- name: import("zod").ZodString;
3454
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
3455
- isUnique: import("zod").ZodBoolean;
3456
- }, "strict", import("zod").ZodTypeAny, {
3457
- name: string;
3458
- columns: string[];
3459
- isUnique: boolean;
3460
- }, {
3461
- name: string;
3462
- columns: string[];
3463
- isUnique: boolean;
3464
- }>>;
3465
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3466
- name: import("zod").ZodString;
3467
- tableFrom: import("zod").ZodString;
3468
- columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
3469
- tableTo: import("zod").ZodString;
3470
- columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
3471
- onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
3472
- onDelete: import("zod").ZodOptional<import("zod").ZodString>;
3473
- }, "strict", import("zod").ZodTypeAny, {
3474
- onUpdate?: string | undefined;
3475
- onDelete?: string | undefined;
3476
- name: string;
3477
- tableFrom: string;
3478
- columnsFrom: string[];
3479
- tableTo: string;
3480
- columnsTo: string[];
3481
- }, {
3482
- onUpdate?: string | undefined;
3483
- onDelete?: string | undefined;
3484
- name: string;
3485
- tableFrom: string;
3486
- columnsFrom: string[];
3487
- tableTo: string;
3488
- columnsTo: string[];
3489
- }>>;
3490
- }, "strict", import("zod").ZodTypeAny, {
3491
- name: string;
3492
- columns: Record<string, {
3493
- isUnique?: any;
3494
- default?: any;
3495
- uniqueName?: string | undefined;
3496
- nullsNotDistinct?: boolean | undefined;
3497
- name: string;
3498
- type: string;
3499
- primaryKey: boolean;
3500
- notNull: boolean;
3501
- }>;
3502
- indexes: Record<string, {
3503
- name: string;
3504
- columns: string[];
3505
- isUnique: boolean;
3506
- }>;
3507
- foreignKeys: Record<string, {
3508
- onUpdate?: string | undefined;
3509
- onDelete?: string | undefined;
3510
- name: string;
3511
- tableFrom: string;
3512
- columnsFrom: string[];
3513
- tableTo: string;
3514
- columnsTo: string[];
3515
- }>;
3516
- schema: string;
3517
- }, {
3518
- name: string;
3519
- columns: Record<string, {
3520
- isUnique?: any;
3521
- default?: any;
3522
- uniqueName?: string | undefined;
3523
- nullsNotDistinct?: boolean | undefined;
3524
- name: string;
3525
- type: string;
3526
- primaryKey: boolean;
3527
- notNull: boolean;
3528
- }>;
3529
- indexes: Record<string, {
3530
- name: string;
3531
- columns: string[];
3532
- isUnique: boolean;
3533
- }>;
3534
- foreignKeys: Record<string, {
3535
- onUpdate?: string | undefined;
3536
- onDelete?: string | undefined;
3537
- name: string;
3538
- tableFrom: string;
3539
- columnsFrom: string[];
3540
- tableTo: string;
3541
- columnsTo: string[];
3542
- }>;
3543
- schema: string;
3544
- }>>;
3545
- enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3546
- name: import("zod").ZodString;
3547
- values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3548
- }, "strict", import("zod").ZodTypeAny, {
3549
- name: string;
3550
- values: Record<string, string>;
3551
- }, {
3552
- name: string;
3553
- values: Record<string, string>;
3554
- }>>;
3555
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3556
- }, {
3557
- id: import("zod").ZodString;
3558
- prevId: import("zod").ZodString;
3559
- }>, "strip", import("zod").ZodTypeAny, {
3560
- id: string;
3561
- prevId: string;
3562
- version: "4";
3563
- dialect: "pg";
3564
- tables: Record<string, {
3565
- name: string;
3566
- columns: Record<string, {
3567
- isUnique?: any;
3568
- default?: any;
3569
- uniqueName?: string | undefined;
3570
- nullsNotDistinct?: boolean | undefined;
3571
- name: string;
3572
- type: string;
3573
- primaryKey: boolean;
3574
- notNull: boolean;
3575
- }>;
3576
- indexes: Record<string, {
3577
- name: string;
3578
- columns: string[];
3579
- isUnique: boolean;
3580
- }>;
3581
- foreignKeys: Record<string, {
3582
- onUpdate?: string | undefined;
3583
- onDelete?: string | undefined;
3584
- name: string;
3585
- tableFrom: string;
3586
- columnsFrom: string[];
3587
- tableTo: string;
3588
- columnsTo: string[];
3589
- }>;
3590
- schema: string;
3591
- }>;
3592
- schemas: Record<string, string>;
3593
- enums: Record<string, {
3594
- name: string;
3595
- values: Record<string, string>;
3596
- }>;
3597
- }, {
3598
- id: string;
3599
- prevId: string;
3600
- version: "4";
3601
- dialect: "pg";
3602
- tables: Record<string, {
3603
- name: string;
3604
- columns: Record<string, {
3605
- isUnique?: any;
3606
- default?: any;
3607
- uniqueName?: string | undefined;
3608
- nullsNotDistinct?: boolean | undefined;
3609
- name: string;
3610
- type: string;
3611
- primaryKey: boolean;
3612
- notNull: boolean;
3613
- }>;
3614
- indexes: Record<string, {
3615
- name: string;
3616
- columns: string[];
3617
- isUnique: boolean;
3618
- }>;
3619
- foreignKeys: Record<string, {
3620
- onUpdate?: string | undefined;
3621
- onDelete?: string | undefined;
3622
- name: string;
3623
- tableFrom: string;
3624
- columnsFrom: string[];
3625
- tableTo: string;
3626
- columnsTo: string[];
3627
- }>;
3628
- schema: string;
3629
- }>;
3630
- schemas: Record<string, string>;
3631
- enums: Record<string, {
3632
- name: string;
3633
- values: Record<string, string>;
3634
- }>;
3635
- }>, import("zod").ZodObject<import("zod").extendShape<{
3636
- version: import("zod").ZodLiteral<"5">;
3637
- dialect: import("zod").ZodLiteral<"pg">;
3638
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3639
- name: import("zod").ZodString;
3640
- schema: import("zod").ZodString;
3641
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3642
- name: import("zod").ZodString;
3643
- type: import("zod").ZodString;
3644
- primaryKey: import("zod").ZodBoolean;
3645
- notNull: import("zod").ZodBoolean;
3646
- default: import("zod").ZodOptional<import("zod").ZodAny>;
3647
- isUnique: import("zod").ZodOptional<import("zod").ZodAny>;
3648
- uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
3649
- nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
3650
- }, "strict", import("zod").ZodTypeAny, {
3651
- isUnique?: any;
3652
- default?: any;
3653
- uniqueName?: string | undefined;
3654
- nullsNotDistinct?: boolean | undefined;
3655
- name: string;
3656
- type: string;
3657
- primaryKey: boolean;
3658
- notNull: boolean;
3659
- }, {
3660
- isUnique?: any;
3661
- default?: any;
3662
- uniqueName?: string | undefined;
3663
- nullsNotDistinct?: boolean | undefined;
3664
- name: string;
3665
- type: string;
3666
- primaryKey: boolean;
3667
- notNull: boolean;
3668
- }>>;
3669
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3670
- name: import("zod").ZodString;
3671
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
3672
- isUnique: import("zod").ZodBoolean;
3673
- }, "strict", import("zod").ZodTypeAny, {
3674
- name: string;
3675
- columns: string[];
3676
- isUnique: boolean;
3677
- }, {
3678
- name: string;
3679
- columns: string[];
3680
- isUnique: boolean;
3681
- }>>;
3682
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3683
- name: import("zod").ZodString;
3684
- tableFrom: import("zod").ZodString;
3685
- columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
3686
- tableTo: import("zod").ZodString;
3687
- columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
3688
- onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
3689
- onDelete: import("zod").ZodOptional<import("zod").ZodString>;
3690
- }, "strict", import("zod").ZodTypeAny, {
3691
- onUpdate?: string | undefined;
3692
- onDelete?: string | undefined;
3693
- name: string;
3694
- tableFrom: string;
3695
- columnsFrom: string[];
3696
- tableTo: string;
3697
- columnsTo: string[];
3698
- }, {
3699
- onUpdate?: string | undefined;
3700
- onDelete?: string | undefined;
3701
- name: string;
3702
- tableFrom: string;
3703
- columnsFrom: string[];
3704
- tableTo: string;
3705
- columnsTo: string[];
3706
- }>>;
3707
- compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3708
- name: import("zod").ZodString;
3709
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
3710
- }, "strict", import("zod").ZodTypeAny, {
3711
- name: string;
3712
- columns: string[];
3713
- }, {
3714
- name: string;
3715
- columns: string[];
3716
- }>>;
3717
- uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3718
- name: import("zod").ZodString;
3719
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
3720
- nullsNotDistinct: import("zod").ZodBoolean;
3721
- }, "strict", import("zod").ZodTypeAny, {
3722
- name: string;
3723
- columns: string[];
3724
- nullsNotDistinct: boolean;
3725
- }, {
3726
- name: string;
3727
- columns: string[];
3728
- nullsNotDistinct: boolean;
3729
- }>>>;
3730
- }, "strict", import("zod").ZodTypeAny, {
3731
- name: string;
3732
- columns: Record<string, {
3733
- isUnique?: any;
3734
- default?: any;
3735
- uniqueName?: string | undefined;
3736
- nullsNotDistinct?: boolean | undefined;
3737
- name: string;
3738
- type: string;
3739
- primaryKey: boolean;
3740
- notNull: boolean;
3741
- }>;
3742
- indexes: Record<string, {
3743
- name: string;
3744
- columns: string[];
3745
- isUnique: boolean;
3746
- }>;
3747
- foreignKeys: Record<string, {
3748
- onUpdate?: string | undefined;
3749
- onDelete?: string | undefined;
3750
- name: string;
3751
- tableFrom: string;
3752
- columnsFrom: string[];
3753
- tableTo: string;
3754
- columnsTo: string[];
3755
- }>;
3756
- schema: string;
3757
- compositePrimaryKeys: Record<string, {
3758
- name: string;
3759
- columns: string[];
3760
- }>;
3761
- uniqueConstraints: Record<string, {
3762
- name: string;
3763
- columns: string[];
3764
- nullsNotDistinct: boolean;
3765
- }>;
3766
- }, {
3767
- uniqueConstraints?: Record<string, {
3768
- name: string;
3769
- columns: string[];
3770
- nullsNotDistinct: boolean;
3771
- }> | undefined;
3772
- name: string;
3773
- columns: Record<string, {
3774
- isUnique?: any;
3775
- default?: any;
3776
- uniqueName?: string | undefined;
3777
- nullsNotDistinct?: boolean | undefined;
3778
- name: string;
3779
- type: string;
3780
- primaryKey: boolean;
3781
- notNull: boolean;
3782
- }>;
3783
- indexes: Record<string, {
3784
- name: string;
3785
- columns: string[];
3786
- isUnique: boolean;
3787
- }>;
3788
- foreignKeys: Record<string, {
3789
- onUpdate?: string | undefined;
3790
- onDelete?: string | undefined;
3791
- name: string;
3792
- tableFrom: string;
3793
- columnsFrom: string[];
3794
- tableTo: string;
3795
- columnsTo: string[];
3796
- }>;
3797
- schema: string;
3798
- compositePrimaryKeys: Record<string, {
3799
- name: string;
3800
- columns: string[];
3801
- }>;
3802
- }>>;
3803
- enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3804
- name: import("zod").ZodString;
3805
- values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3806
- }, "strict", import("zod").ZodTypeAny, {
3807
- name: string;
3808
- values: Record<string, string>;
3809
- }, {
3810
- name: string;
3811
- values: Record<string, string>;
3812
- }>>;
3813
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3814
- _meta: import("zod").ZodObject<{
3815
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3816
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3817
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3818
- }, "strip", import("zod").ZodTypeAny, {
3819
- columns: Record<string, string>;
3820
- tables: Record<string, string>;
3821
- schemas: Record<string, string>;
3822
- }, {
3823
- columns: Record<string, string>;
3824
- tables: Record<string, string>;
3825
- schemas: Record<string, string>;
3826
- }>;
3827
- }, {
3828
- id: import("zod").ZodString;
3829
- prevId: import("zod").ZodString;
3830
- }>, "strip", import("zod").ZodTypeAny, {
3831
- id: string;
3832
- prevId: string;
3833
- version: "5";
3834
- dialect: "pg";
3835
- tables: Record<string, {
3836
- name: string;
3837
- columns: Record<string, {
3838
- isUnique?: any;
3839
- default?: any;
3840
- uniqueName?: string | undefined;
3841
- nullsNotDistinct?: boolean | undefined;
3842
- name: string;
3843
- type: string;
3844
- primaryKey: boolean;
3845
- notNull: boolean;
3846
- }>;
3847
- indexes: Record<string, {
3848
- name: string;
3849
- columns: string[];
3850
- isUnique: boolean;
3851
- }>;
3852
- foreignKeys: Record<string, {
3853
- onUpdate?: string | undefined;
3854
- onDelete?: string | undefined;
3855
- name: string;
3856
- tableFrom: string;
3857
- columnsFrom: string[];
3858
- tableTo: string;
3859
- columnsTo: string[];
3860
- }>;
3861
- schema: string;
3862
- compositePrimaryKeys: Record<string, {
3863
- name: string;
3864
- columns: string[];
3865
- }>;
3866
- uniqueConstraints: Record<string, {
3867
- name: string;
3868
- columns: string[];
3869
- nullsNotDistinct: boolean;
3870
- }>;
3871
- }>;
3872
- schemas: Record<string, string>;
3873
- _meta: {
3874
- columns: Record<string, string>;
3875
- tables: Record<string, string>;
3876
- schemas: Record<string, string>;
3877
- };
3878
- enums: Record<string, {
3879
- name: string;
3880
- values: Record<string, string>;
3881
- }>;
3882
- }, {
3883
- id: string;
3884
- prevId: string;
3885
- version: "5";
3886
- dialect: "pg";
3887
- tables: Record<string, {
3888
- uniqueConstraints?: Record<string, {
3889
- name: string;
3890
- columns: string[];
3891
- nullsNotDistinct: boolean;
3892
- }> | undefined;
3893
- name: string;
3894
- columns: Record<string, {
3895
- isUnique?: any;
3896
- default?: any;
3897
- uniqueName?: string | undefined;
3898
- nullsNotDistinct?: boolean | undefined;
3899
- name: string;
3900
- type: string;
3901
- primaryKey: boolean;
3902
- notNull: boolean;
3903
- }>;
3904
- indexes: Record<string, {
3905
- name: string;
3906
- columns: string[];
3907
- isUnique: boolean;
3908
- }>;
3909
- foreignKeys: Record<string, {
3910
- onUpdate?: string | undefined;
3911
- onDelete?: string | undefined;
3912
- name: string;
3913
- tableFrom: string;
3914
- columnsFrom: string[];
3915
- tableTo: string;
3916
- columnsTo: string[];
3917
- }>;
3918
- schema: string;
3919
- compositePrimaryKeys: Record<string, {
3920
- name: string;
3921
- columns: string[];
3922
- }>;
3923
- }>;
3924
- schemas: Record<string, string>;
3925
- _meta: {
3926
- columns: Record<string, string>;
3927
- tables: Record<string, string>;
3928
- schemas: Record<string, string>;
3929
- };
3930
- enums: Record<string, {
3931
- name: string;
3932
- values: Record<string, string>;
3933
- }>;
3934
- }>]>;
3935
- export declare const PgSquasher: {
3936
- squashIdx: (idx: Index) => string;
3937
- unsquashIdx: (input: string) => Index;
3938
- squashFK: (fk: ForeignKey) => string;
3939
- squashPK: (pk: PrimaryKey) => string;
3940
- unsquashPK: (pk: string) => PrimaryKey;
3941
- squashUnique: (unq: UniqueConstraint) => string;
3942
- unsquashUnique: (unq: string) => UniqueConstraint;
3943
- unsquashFK: (input: string) => ForeignKey;
3944
- };
3945
- export declare const squashPgSchemeV4: (json: PgSchemaV4) => PgSchemaSquashedV4;
3946
- export declare const squashPgScheme: (json: PgSchema) => PgSchemaSquashed;
3947
- export declare const dryPg: {
3948
- id: string;
3949
- prevId: string;
3950
- version: "5";
3951
- dialect: "pg";
3952
- tables: Record<string, {
3953
- name: string;
3954
- columns: Record<string, {
3955
- isUnique?: any;
3956
- default?: any;
3957
- uniqueName?: string | undefined;
3958
- nullsNotDistinct?: boolean | undefined;
3959
- name: string;
3960
- type: string;
3961
- primaryKey: boolean;
3962
- notNull: boolean;
3963
- }>;
3964
- indexes: Record<string, {
3965
- name: string;
3966
- columns: string[];
3967
- isUnique: boolean;
3968
- }>;
3969
- foreignKeys: Record<string, {
3970
- onUpdate?: string | undefined;
3971
- onDelete?: string | undefined;
3972
- name: string;
3973
- tableFrom: string;
3974
- columnsFrom: string[];
3975
- tableTo: string;
3976
- columnsTo: string[];
3977
- }>;
3978
- schema: string;
3979
- compositePrimaryKeys: Record<string, {
3980
- name: string;
3981
- columns: string[];
3982
- }>;
3983
- uniqueConstraints: Record<string, {
3984
- name: string;
3985
- columns: string[];
3986
- nullsNotDistinct: boolean;
3987
- }>;
3988
- }>;
3989
- schemas: Record<string, string>;
3990
- _meta: {
3991
- columns: Record<string, string>;
3992
- tables: Record<string, string>;
3993
- schemas: Record<string, string>;
3994
- };
3995
- enums: Record<string, {
3996
- name: string;
3997
- values: Record<string, string>;
3998
- }>;
3999
- };
4000
- export {};