drizzle-kit 0.20.17-ff96495 → 0.20.18-08d50a4

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