drizzle-kit 0.20.17-84934d2 → 0.20.17-9053b76

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 +24355 -16603
  2. package/index.d.mts +28 -14
  3. package/index.d.ts +28 -14
  4. package/package.json +5 -16
  5. package/payload.d.mts +987 -18
  6. package/payload.d.ts +987 -18
  7. package/payload.js +19796 -16900
  8. package/payload.mjs +19869 -16948
  9. package/utils-studio.js +946 -835
  10. package/utils-studio.mjs +919 -808
  11. package/utils.js +839 -214
  12. package/utils.mjs +814 -189
  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 -41
  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 -3936
  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
- default?: any;
28
- references?: string | undefined;
29
- name: string;
30
- type: string;
31
- primaryKey: boolean;
32
- notNull: boolean;
33
- }, {
34
- default?: any;
35
- references?: string | undefined;
36
- name: string;
37
- type: string;
38
- primaryKey: boolean;
39
- notNull: boolean;
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
- default?: any;
68
- references?: string | undefined;
69
- name: string;
70
- type: string;
71
- primaryKey: boolean;
72
- notNull: boolean;
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
- default?: any;
85
- references?: string | undefined;
86
- name: string;
87
- type: string;
88
- primaryKey: boolean;
89
- notNull: boolean;
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
- default?: any;
114
- references?: string | undefined;
115
- name: string;
116
- type: string;
117
- primaryKey: boolean;
118
- notNull: boolean;
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
- default?: any;
138
- references?: string | undefined;
139
- name: string;
140
- type: string;
141
- primaryKey: boolean;
142
- notNull: boolean;
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
- onUpdate?: string | undefined;
176
- onDelete?: string | undefined;
177
- foreignKeyName: string;
178
- table: string;
179
- column: string;
180
- }, {
181
- onUpdate?: string | undefined;
182
- onDelete?: string | undefined;
183
- foreignKeyName: string;
184
- table: string;
185
- column: string;
186
- }>>;
187
- }, "strict", import("zod").ZodTypeAny, {
188
- default?: any;
189
- references?: {
190
- onUpdate?: string | undefined;
191
- onDelete?: string | undefined;
192
- foreignKeyName: string;
193
- table: string;
194
- column: string;
195
- } | undefined;
196
- name: string;
197
- type: string;
198
- primaryKey: boolean;
199
- notNull: boolean;
200
- }, {
201
- default?: any;
202
- references?: {
203
- onUpdate?: string | undefined;
204
- onDelete?: string | undefined;
205
- foreignKeyName: string;
206
- table: string;
207
- column: string;
208
- } | undefined;
209
- name: string;
210
- type: string;
211
- primaryKey: boolean;
212
- notNull: boolean;
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
- default?: any;
241
- references?: {
242
- onUpdate?: string | undefined;
243
- onDelete?: string | undefined;
244
- foreignKeyName: string;
245
- table: string;
246
- column: string;
247
- } | undefined;
248
- name: string;
249
- type: string;
250
- primaryKey: boolean;
251
- notNull: boolean;
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
- default?: any;
264
- references?: {
265
- onUpdate?: string | undefined;
266
- onDelete?: string | undefined;
267
- foreignKeyName: string;
268
- table: string;
269
- column: string;
270
- } | undefined;
271
- name: string;
272
- type: string;
273
- primaryKey: boolean;
274
- notNull: boolean;
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
- default?: any;
299
- references?: {
300
- onUpdate?: string | undefined;
301
- onDelete?: string | undefined;
302
- foreignKeyName: string;
303
- table: string;
304
- column: string;
305
- } | undefined;
306
- name: string;
307
- type: string;
308
- primaryKey: boolean;
309
- notNull: boolean;
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
- default?: any;
329
- references?: {
330
- onUpdate?: string | undefined;
331
- onDelete?: string | undefined;
332
- foreignKeyName: string;
333
- table: string;
334
- column: string;
335
- } | undefined;
336
- name: string;
337
- type: string;
338
- primaryKey: boolean;
339
- notNull: boolean;
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
- onUpdate?: string | undefined;
379
- onDelete?: string | undefined;
380
- schemaTo?: string | undefined;
381
- name: string;
382
- tableFrom: string;
383
- columnsFrom: string[];
384
- tableTo: string;
385
- columnsTo: string[];
386
- }, {
387
- onUpdate?: string | undefined;
388
- onDelete?: string | undefined;
389
- schemaTo?: string | undefined;
390
- name: string;
391
- tableFrom: string;
392
- columnsFrom: string[];
393
- tableTo: string;
394
- columnsTo: string[];
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
- isUnique?: any;
408
- default?: any;
409
- typeSchema?: string | undefined;
410
- uniqueName?: string | undefined;
411
- nullsNotDistinct?: boolean | undefined;
412
- name: string;
413
- type: string;
414
- primaryKey: boolean;
415
- notNull: boolean;
416
- }, {
417
- isUnique?: any;
418
- default?: any;
419
- typeSchema?: string | undefined;
420
- uniqueName?: string | undefined;
421
- nullsNotDistinct?: boolean | undefined;
422
- name: string;
423
- type: string;
424
- primaryKey: boolean;
425
- notNull: boolean;
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
- isUnique?: any;
441
- default?: any;
442
- typeSchema?: string | undefined;
443
- uniqueName?: string | undefined;
444
- nullsNotDistinct?: boolean | undefined;
445
- name: string;
446
- type: string;
447
- primaryKey: boolean;
448
- notNull: boolean;
449
- }, {
450
- isUnique?: any;
451
- default?: any;
452
- typeSchema?: string | undefined;
453
- uniqueName?: string | undefined;
454
- nullsNotDistinct?: boolean | undefined;
455
- name: string;
456
- type: string;
457
- primaryKey: boolean;
458
- notNull: boolean;
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
- onUpdate?: string | undefined;
484
- onDelete?: string | undefined;
485
- schemaTo?: string | undefined;
486
- name: string;
487
- tableFrom: string;
488
- columnsFrom: string[];
489
- tableTo: string;
490
- columnsTo: string[];
491
- }, {
492
- onUpdate?: string | undefined;
493
- onDelete?: string | undefined;
494
- schemaTo?: string | undefined;
495
- name: string;
496
- tableFrom: string;
497
- columnsFrom: string[];
498
- tableTo: string;
499
- columnsTo: string[];
500
- }>>;
501
- }, "strict", import("zod").ZodTypeAny, {
502
- name: string;
503
- columns: Record<string, {
504
- isUnique?: any;
505
- default?: any;
506
- typeSchema?: string | undefined;
507
- uniqueName?: string | undefined;
508
- nullsNotDistinct?: boolean | undefined;
509
- name: string;
510
- type: string;
511
- primaryKey: boolean;
512
- notNull: boolean;
513
- }>;
514
- indexes: Record<string, {
515
- name: string;
516
- columns: string[];
517
- isUnique: boolean;
518
- }>;
519
- foreignKeys: Record<string, {
520
- onUpdate?: string | undefined;
521
- onDelete?: string | undefined;
522
- schemaTo?: string | undefined;
523
- name: string;
524
- tableFrom: string;
525
- columnsFrom: string[];
526
- tableTo: string;
527
- columnsTo: string[];
528
- }>;
529
- }, {
530
- name: string;
531
- columns: Record<string, {
532
- isUnique?: any;
533
- default?: any;
534
- typeSchema?: string | undefined;
535
- uniqueName?: string | undefined;
536
- nullsNotDistinct?: boolean | undefined;
537
- name: string;
538
- type: string;
539
- primaryKey: boolean;
540
- notNull: boolean;
541
- }>;
542
- indexes: Record<string, {
543
- name: string;
544
- columns: string[];
545
- isUnique: boolean;
546
- }>;
547
- foreignKeys: Record<string, {
548
- onUpdate?: string | undefined;
549
- onDelete?: string | undefined;
550
- schemaTo?: string | undefined;
551
- name: string;
552
- tableFrom: string;
553
- columnsFrom: string[];
554
- tableTo: string;
555
- columnsTo: string[];
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
- isUnique?: any;
596
- default?: any;
597
- typeSchema?: string | undefined;
598
- uniqueName?: string | undefined;
599
- nullsNotDistinct?: boolean | undefined;
600
- name: string;
601
- type: string;
602
- primaryKey: boolean;
603
- notNull: boolean;
604
- }, {
605
- isUnique?: any;
606
- default?: any;
607
- typeSchema?: string | undefined;
608
- uniqueName?: string | undefined;
609
- nullsNotDistinct?: boolean | undefined;
610
- name: string;
611
- type: string;
612
- primaryKey: boolean;
613
- notNull: boolean;
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
- onUpdate?: string | undefined;
639
- onDelete?: string | undefined;
640
- schemaTo?: string | undefined;
641
- name: string;
642
- tableFrom: string;
643
- columnsFrom: string[];
644
- tableTo: string;
645
- columnsTo: string[];
646
- }, {
647
- onUpdate?: string | undefined;
648
- onDelete?: string | undefined;
649
- schemaTo?: string | undefined;
650
- name: string;
651
- tableFrom: string;
652
- columnsFrom: string[];
653
- tableTo: string;
654
- columnsTo: string[];
655
- }>>;
656
- }, "strict", import("zod").ZodTypeAny, {
657
- name: string;
658
- columns: Record<string, {
659
- isUnique?: any;
660
- default?: any;
661
- typeSchema?: string | undefined;
662
- uniqueName?: string | undefined;
663
- nullsNotDistinct?: boolean | undefined;
664
- name: string;
665
- type: string;
666
- primaryKey: boolean;
667
- notNull: boolean;
668
- }>;
669
- indexes: Record<string, {
670
- name: string;
671
- columns: string[];
672
- isUnique: boolean;
673
- }>;
674
- foreignKeys: Record<string, {
675
- onUpdate?: string | undefined;
676
- onDelete?: string | undefined;
677
- schemaTo?: string | undefined;
678
- name: string;
679
- tableFrom: string;
680
- columnsFrom: string[];
681
- tableTo: string;
682
- columnsTo: string[];
683
- }>;
684
- schema: string;
685
- }, {
686
- name: string;
687
- columns: Record<string, {
688
- isUnique?: any;
689
- default?: any;
690
- typeSchema?: string | undefined;
691
- uniqueName?: string | undefined;
692
- nullsNotDistinct?: boolean | undefined;
693
- name: string;
694
- type: string;
695
- primaryKey: boolean;
696
- notNull: boolean;
697
- }>;
698
- indexes: Record<string, {
699
- name: string;
700
- columns: string[];
701
- isUnique: boolean;
702
- }>;
703
- foreignKeys: Record<string, {
704
- onUpdate?: string | undefined;
705
- onDelete?: string | undefined;
706
- schemaTo?: string | undefined;
707
- name: string;
708
- tableFrom: string;
709
- columnsFrom: string[];
710
- tableTo: string;
711
- columnsTo: string[];
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
- isUnique?: any;
730
- default?: any;
731
- typeSchema?: string | undefined;
732
- uniqueName?: string | undefined;
733
- nullsNotDistinct?: boolean | undefined;
734
- name: string;
735
- type: string;
736
- primaryKey: boolean;
737
- notNull: boolean;
738
- }, {
739
- isUnique?: any;
740
- default?: any;
741
- typeSchema?: string | undefined;
742
- uniqueName?: string | undefined;
743
- nullsNotDistinct?: boolean | undefined;
744
- name: string;
745
- type: string;
746
- primaryKey: boolean;
747
- notNull: boolean;
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
- onUpdate?: string | undefined;
773
- onDelete?: string | undefined;
774
- schemaTo?: string | undefined;
775
- name: string;
776
- tableFrom: string;
777
- columnsFrom: string[];
778
- tableTo: string;
779
- columnsTo: string[];
780
- }, {
781
- onUpdate?: string | undefined;
782
- onDelete?: string | undefined;
783
- schemaTo?: string | undefined;
784
- name: string;
785
- tableFrom: string;
786
- columnsFrom: string[];
787
- tableTo: string;
788
- columnsTo: string[];
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
- isUnique?: any;
817
- default?: any;
818
- typeSchema?: string | undefined;
819
- uniqueName?: string | undefined;
820
- nullsNotDistinct?: boolean | undefined;
821
- name: string;
822
- type: string;
823
- primaryKey: boolean;
824
- notNull: boolean;
825
- }>;
826
- indexes: Record<string, {
827
- name: string;
828
- columns: string[];
829
- isUnique: boolean;
830
- }>;
831
- foreignKeys: Record<string, {
832
- onUpdate?: string | undefined;
833
- onDelete?: string | undefined;
834
- schemaTo?: string | undefined;
835
- name: string;
836
- tableFrom: string;
837
- columnsFrom: string[];
838
- tableTo: string;
839
- columnsTo: string[];
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
- uniqueConstraints?: Record<string, {
853
- name: string;
854
- columns: string[];
855
- nullsNotDistinct: boolean;
856
- }> | undefined;
857
- name: string;
858
- columns: Record<string, {
859
- isUnique?: any;
860
- default?: any;
861
- typeSchema?: string | undefined;
862
- uniqueName?: string | undefined;
863
- nullsNotDistinct?: boolean | undefined;
864
- name: string;
865
- type: string;
866
- primaryKey: boolean;
867
- notNull: boolean;
868
- }>;
869
- indexes: Record<string, {
870
- name: string;
871
- columns: string[];
872
- isUnique: boolean;
873
- }>;
874
- foreignKeys: Record<string, {
875
- onUpdate?: string | undefined;
876
- onDelete?: string | undefined;
877
- schemaTo?: string | undefined;
878
- name: string;
879
- tableFrom: string;
880
- columnsFrom: string[];
881
- tableTo: string;
882
- columnsTo: string[];
883
- }>;
884
- schema: string;
885
- compositePrimaryKeys: Record<string, {
886
- name: string;
887
- columns: string[];
888
- }>;
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
- isUnique?: any;
952
- default?: any;
953
- typeSchema?: string | undefined;
954
- uniqueName?: string | undefined;
955
- nullsNotDistinct?: boolean | undefined;
956
- name: string;
957
- type: string;
958
- primaryKey: boolean;
959
- notNull: boolean;
960
- }, {
961
- isUnique?: any;
962
- default?: any;
963
- typeSchema?: string | undefined;
964
- uniqueName?: string | undefined;
965
- nullsNotDistinct?: boolean | undefined;
966
- name: string;
967
- type: string;
968
- primaryKey: boolean;
969
- notNull: boolean;
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
- onUpdate?: string | undefined;
995
- onDelete?: string | undefined;
996
- schemaTo?: string | undefined;
997
- name: string;
998
- tableFrom: string;
999
- columnsFrom: string[];
1000
- tableTo: string;
1001
- columnsTo: string[];
1002
- }, {
1003
- onUpdate?: string | undefined;
1004
- onDelete?: string | undefined;
1005
- schemaTo?: string | undefined;
1006
- name: string;
1007
- tableFrom: string;
1008
- columnsFrom: string[];
1009
- tableTo: string;
1010
- columnsTo: string[];
1011
- }>>;
1012
- }, "strict", import("zod").ZodTypeAny, {
1013
- name: string;
1014
- columns: Record<string, {
1015
- isUnique?: any;
1016
- default?: any;
1017
- typeSchema?: string | undefined;
1018
- uniqueName?: string | undefined;
1019
- nullsNotDistinct?: boolean | undefined;
1020
- name: string;
1021
- type: string;
1022
- primaryKey: boolean;
1023
- notNull: boolean;
1024
- }>;
1025
- indexes: Record<string, {
1026
- name: string;
1027
- columns: string[];
1028
- isUnique: boolean;
1029
- }>;
1030
- foreignKeys: Record<string, {
1031
- onUpdate?: string | undefined;
1032
- onDelete?: string | undefined;
1033
- schemaTo?: string | undefined;
1034
- name: string;
1035
- tableFrom: string;
1036
- columnsFrom: string[];
1037
- tableTo: string;
1038
- columnsTo: string[];
1039
- }>;
1040
- }, {
1041
- name: string;
1042
- columns: Record<string, {
1043
- isUnique?: any;
1044
- default?: any;
1045
- typeSchema?: string | undefined;
1046
- uniqueName?: string | undefined;
1047
- nullsNotDistinct?: boolean | undefined;
1048
- name: string;
1049
- type: string;
1050
- primaryKey: boolean;
1051
- notNull: boolean;
1052
- }>;
1053
- indexes: Record<string, {
1054
- name: string;
1055
- columns: string[];
1056
- isUnique: boolean;
1057
- }>;
1058
- foreignKeys: Record<string, {
1059
- onUpdate?: string | undefined;
1060
- onDelete?: string | undefined;
1061
- schemaTo?: string | undefined;
1062
- name: string;
1063
- tableFrom: string;
1064
- columnsFrom: string[];
1065
- tableTo: string;
1066
- columnsTo: string[];
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
- isUnique?: any;
1084
- default?: any;
1085
- typeSchema?: string | undefined;
1086
- uniqueName?: string | undefined;
1087
- nullsNotDistinct?: boolean | undefined;
1088
- name: string;
1089
- type: string;
1090
- primaryKey: boolean;
1091
- notNull: boolean;
1092
- }>;
1093
- indexes: Record<string, {
1094
- name: string;
1095
- columns: string[];
1096
- isUnique: boolean;
1097
- }>;
1098
- foreignKeys: Record<string, {
1099
- onUpdate?: string | undefined;
1100
- onDelete?: string | undefined;
1101
- schemaTo?: string | undefined;
1102
- name: string;
1103
- tableFrom: string;
1104
- columnsFrom: string[];
1105
- tableTo: string;
1106
- columnsTo: string[];
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
- isUnique?: any;
1120
- default?: any;
1121
- typeSchema?: string | undefined;
1122
- uniqueName?: string | undefined;
1123
- nullsNotDistinct?: boolean | undefined;
1124
- name: string;
1125
- type: string;
1126
- primaryKey: boolean;
1127
- notNull: boolean;
1128
- }>;
1129
- indexes: Record<string, {
1130
- name: string;
1131
- columns: string[];
1132
- isUnique: boolean;
1133
- }>;
1134
- foreignKeys: Record<string, {
1135
- onUpdate?: string | undefined;
1136
- onDelete?: string | undefined;
1137
- schemaTo?: string | undefined;
1138
- name: string;
1139
- tableFrom: string;
1140
- columnsFrom: string[];
1141
- tableTo: string;
1142
- columnsTo: string[];
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
- isUnique?: any;
1170
- default?: any;
1171
- typeSchema?: string | undefined;
1172
- uniqueName?: string | undefined;
1173
- nullsNotDistinct?: boolean | undefined;
1174
- name: string;
1175
- type: string;
1176
- primaryKey: boolean;
1177
- notNull: boolean;
1178
- }, {
1179
- isUnique?: any;
1180
- default?: any;
1181
- typeSchema?: string | undefined;
1182
- uniqueName?: string | undefined;
1183
- nullsNotDistinct?: boolean | undefined;
1184
- name: string;
1185
- type: string;
1186
- primaryKey: boolean;
1187
- notNull: boolean;
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
- onUpdate?: string | undefined;
1213
- onDelete?: string | undefined;
1214
- schemaTo?: string | undefined;
1215
- name: string;
1216
- tableFrom: string;
1217
- columnsFrom: string[];
1218
- tableTo: string;
1219
- columnsTo: string[];
1220
- }, {
1221
- onUpdate?: string | undefined;
1222
- onDelete?: string | undefined;
1223
- schemaTo?: string | undefined;
1224
- name: string;
1225
- tableFrom: string;
1226
- columnsFrom: string[];
1227
- tableTo: string;
1228
- columnsTo: string[];
1229
- }>>;
1230
- }, "strict", import("zod").ZodTypeAny, {
1231
- name: string;
1232
- columns: Record<string, {
1233
- isUnique?: any;
1234
- default?: any;
1235
- typeSchema?: string | undefined;
1236
- uniqueName?: string | undefined;
1237
- nullsNotDistinct?: boolean | undefined;
1238
- name: string;
1239
- type: string;
1240
- primaryKey: boolean;
1241
- notNull: boolean;
1242
- }>;
1243
- indexes: Record<string, {
1244
- name: string;
1245
- columns: string[];
1246
- isUnique: boolean;
1247
- }>;
1248
- foreignKeys: Record<string, {
1249
- onUpdate?: string | undefined;
1250
- onDelete?: string | undefined;
1251
- schemaTo?: string | undefined;
1252
- name: string;
1253
- tableFrom: string;
1254
- columnsFrom: string[];
1255
- tableTo: string;
1256
- columnsTo: string[];
1257
- }>;
1258
- schema: string;
1259
- }, {
1260
- name: string;
1261
- columns: Record<string, {
1262
- isUnique?: any;
1263
- default?: any;
1264
- typeSchema?: string | undefined;
1265
- uniqueName?: string | undefined;
1266
- nullsNotDistinct?: boolean | undefined;
1267
- name: string;
1268
- type: string;
1269
- primaryKey: boolean;
1270
- notNull: boolean;
1271
- }>;
1272
- indexes: Record<string, {
1273
- name: string;
1274
- columns: string[];
1275
- isUnique: boolean;
1276
- }>;
1277
- foreignKeys: Record<string, {
1278
- onUpdate?: string | undefined;
1279
- onDelete?: string | undefined;
1280
- schemaTo?: string | undefined;
1281
- name: string;
1282
- tableFrom: string;
1283
- columnsFrom: string[];
1284
- tableTo: string;
1285
- columnsTo: string[];
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
- isUnique?: any;
1305
- default?: any;
1306
- typeSchema?: string | undefined;
1307
- uniqueName?: string | undefined;
1308
- nullsNotDistinct?: boolean | undefined;
1309
- name: string;
1310
- type: string;
1311
- primaryKey: boolean;
1312
- notNull: boolean;
1313
- }>;
1314
- indexes: Record<string, {
1315
- name: string;
1316
- columns: string[];
1317
- isUnique: boolean;
1318
- }>;
1319
- foreignKeys: Record<string, {
1320
- onUpdate?: string | undefined;
1321
- onDelete?: string | undefined;
1322
- schemaTo?: string | undefined;
1323
- name: string;
1324
- tableFrom: string;
1325
- columnsFrom: string[];
1326
- tableTo: string;
1327
- columnsTo: string[];
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
- isUnique?: any;
1343
- default?: any;
1344
- typeSchema?: string | undefined;
1345
- uniqueName?: string | undefined;
1346
- nullsNotDistinct?: boolean | undefined;
1347
- name: string;
1348
- type: string;
1349
- primaryKey: boolean;
1350
- notNull: boolean;
1351
- }>;
1352
- indexes: Record<string, {
1353
- name: string;
1354
- columns: string[];
1355
- isUnique: boolean;
1356
- }>;
1357
- foreignKeys: Record<string, {
1358
- onUpdate?: string | undefined;
1359
- onDelete?: string | undefined;
1360
- schemaTo?: string | undefined;
1361
- name: string;
1362
- tableFrom: string;
1363
- columnsFrom: string[];
1364
- tableTo: string;
1365
- columnsTo: string[];
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
- isUnique?: any;
1395
- default?: any;
1396
- typeSchema?: string | undefined;
1397
- uniqueName?: string | undefined;
1398
- nullsNotDistinct?: boolean | undefined;
1399
- name: string;
1400
- type: string;
1401
- primaryKey: boolean;
1402
- notNull: boolean;
1403
- }, {
1404
- isUnique?: any;
1405
- default?: any;
1406
- typeSchema?: string | undefined;
1407
- uniqueName?: string | undefined;
1408
- nullsNotDistinct?: boolean | undefined;
1409
- name: string;
1410
- type: string;
1411
- primaryKey: boolean;
1412
- notNull: boolean;
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
- onUpdate?: string | undefined;
1438
- onDelete?: string | undefined;
1439
- schemaTo?: string | undefined;
1440
- name: string;
1441
- tableFrom: string;
1442
- columnsFrom: string[];
1443
- tableTo: string;
1444
- columnsTo: string[];
1445
- }, {
1446
- onUpdate?: string | undefined;
1447
- onDelete?: string | undefined;
1448
- schemaTo?: string | undefined;
1449
- name: string;
1450
- tableFrom: string;
1451
- columnsFrom: string[];
1452
- tableTo: string;
1453
- columnsTo: string[];
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
- isUnique?: any;
1482
- default?: any;
1483
- typeSchema?: string | undefined;
1484
- uniqueName?: string | undefined;
1485
- nullsNotDistinct?: boolean | undefined;
1486
- name: string;
1487
- type: string;
1488
- primaryKey: boolean;
1489
- notNull: boolean;
1490
- }>;
1491
- indexes: Record<string, {
1492
- name: string;
1493
- columns: string[];
1494
- isUnique: boolean;
1495
- }>;
1496
- foreignKeys: Record<string, {
1497
- onUpdate?: string | undefined;
1498
- onDelete?: string | undefined;
1499
- schemaTo?: string | undefined;
1500
- name: string;
1501
- tableFrom: string;
1502
- columnsFrom: string[];
1503
- tableTo: string;
1504
- columnsTo: string[];
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
- uniqueConstraints?: Record<string, {
1518
- name: string;
1519
- columns: string[];
1520
- nullsNotDistinct: boolean;
1521
- }> | undefined;
1522
- name: string;
1523
- columns: Record<string, {
1524
- isUnique?: any;
1525
- default?: any;
1526
- typeSchema?: string | undefined;
1527
- uniqueName?: string | undefined;
1528
- nullsNotDistinct?: boolean | undefined;
1529
- name: string;
1530
- type: string;
1531
- primaryKey: boolean;
1532
- notNull: boolean;
1533
- }>;
1534
- indexes: Record<string, {
1535
- name: string;
1536
- columns: string[];
1537
- isUnique: boolean;
1538
- }>;
1539
- foreignKeys: Record<string, {
1540
- onUpdate?: string | undefined;
1541
- onDelete?: string | undefined;
1542
- schemaTo?: string | undefined;
1543
- name: string;
1544
- tableFrom: string;
1545
- columnsFrom: string[];
1546
- tableTo: string;
1547
- columnsTo: string[];
1548
- }>;
1549
- schema: string;
1550
- compositePrimaryKeys: Record<string, {
1551
- name: string;
1552
- columns: string[];
1553
- }>;
1554
- }>>;
1555
- 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
- internal?: {
1626
- tables: Record<string, {
1627
- columns: Record<string, {
1628
- isArray?: boolean | undefined;
1629
- dimensions?: number | undefined;
1630
- rawType?: string | undefined;
1631
- } | undefined>;
1632
- } | undefined>;
1633
- } | undefined;
1634
- tables: Record<string, {
1635
- name: string;
1636
- columns: Record<string, {
1637
- isUnique?: any;
1638
- default?: any;
1639
- typeSchema?: string | undefined;
1640
- uniqueName?: string | undefined;
1641
- nullsNotDistinct?: boolean | undefined;
1642
- name: string;
1643
- type: string;
1644
- primaryKey: boolean;
1645
- notNull: boolean;
1646
- }>;
1647
- indexes: Record<string, {
1648
- name: string;
1649
- columns: string[];
1650
- isUnique: boolean;
1651
- }>;
1652
- foreignKeys: Record<string, {
1653
- onUpdate?: string | undefined;
1654
- onDelete?: string | undefined;
1655
- schemaTo?: string | undefined;
1656
- name: string;
1657
- tableFrom: string;
1658
- columnsFrom: string[];
1659
- tableTo: string;
1660
- columnsTo: string[];
1661
- }>;
1662
- schema: string;
1663
- compositePrimaryKeys: Record<string, {
1664
- name: string;
1665
- columns: string[];
1666
- }>;
1667
- uniqueConstraints: Record<string, {
1668
- name: string;
1669
- columns: string[];
1670
- nullsNotDistinct: boolean;
1671
- }>;
1672
- }>;
1673
- version: "5";
1674
- dialect: "pg";
1675
- schemas: Record<string, string>;
1676
- _meta: {
1677
- columns: Record<string, string>;
1678
- tables: Record<string, string>;
1679
- schemas: Record<string, string>;
1680
- };
1681
- enums: Record<string, {
1682
- name: string;
1683
- values: Record<string, string>;
1684
- }>;
1685
- }, {
1686
- internal?: {
1687
- tables: Record<string, {
1688
- columns: Record<string, {
1689
- isArray?: boolean | undefined;
1690
- dimensions?: number | undefined;
1691
- rawType?: string | undefined;
1692
- } | undefined>;
1693
- } | undefined>;
1694
- } | undefined;
1695
- tables: Record<string, {
1696
- uniqueConstraints?: Record<string, {
1697
- name: string;
1698
- columns: string[];
1699
- nullsNotDistinct: boolean;
1700
- }> | undefined;
1701
- name: string;
1702
- columns: Record<string, {
1703
- isUnique?: any;
1704
- default?: any;
1705
- typeSchema?: string | undefined;
1706
- uniqueName?: string | undefined;
1707
- nullsNotDistinct?: boolean | undefined;
1708
- name: string;
1709
- type: string;
1710
- primaryKey: boolean;
1711
- notNull: boolean;
1712
- }>;
1713
- indexes: Record<string, {
1714
- name: string;
1715
- columns: string[];
1716
- isUnique: boolean;
1717
- }>;
1718
- foreignKeys: Record<string, {
1719
- onUpdate?: string | undefined;
1720
- onDelete?: string | undefined;
1721
- schemaTo?: string | undefined;
1722
- name: string;
1723
- tableFrom: string;
1724
- columnsFrom: string[];
1725
- tableTo: string;
1726
- columnsTo: string[];
1727
- }>;
1728
- schema: string;
1729
- compositePrimaryKeys: Record<string, {
1730
- name: string;
1731
- columns: string[];
1732
- }>;
1733
- }>;
1734
- version: "5";
1735
- dialect: "pg";
1736
- schemas: Record<string, string>;
1737
- _meta: {
1738
- columns: Record<string, string>;
1739
- tables: Record<string, string>;
1740
- schemas: Record<string, string>;
1741
- };
1742
- enums: Record<string, {
1743
- name: string;
1744
- values: Record<string, string>;
1745
- }>;
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
- isUnique?: any;
1765
- default?: any;
1766
- typeSchema?: string | undefined;
1767
- uniqueName?: string | undefined;
1768
- nullsNotDistinct?: boolean | undefined;
1769
- name: string;
1770
- type: string;
1771
- primaryKey: boolean;
1772
- notNull: boolean;
1773
- }, {
1774
- isUnique?: any;
1775
- default?: any;
1776
- typeSchema?: string | undefined;
1777
- uniqueName?: string | undefined;
1778
- nullsNotDistinct?: boolean | undefined;
1779
- name: string;
1780
- type: string;
1781
- primaryKey: boolean;
1782
- notNull: boolean;
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
- onUpdate?: string | undefined;
1808
- onDelete?: string | undefined;
1809
- schemaTo?: string | undefined;
1810
- name: string;
1811
- tableFrom: string;
1812
- columnsFrom: string[];
1813
- tableTo: string;
1814
- columnsTo: string[];
1815
- }, {
1816
- onUpdate?: string | undefined;
1817
- onDelete?: string | undefined;
1818
- schemaTo?: string | undefined;
1819
- name: string;
1820
- tableFrom: string;
1821
- columnsFrom: string[];
1822
- tableTo: string;
1823
- columnsTo: string[];
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
- isUnique?: any;
1852
- default?: any;
1853
- typeSchema?: string | undefined;
1854
- uniqueName?: string | undefined;
1855
- nullsNotDistinct?: boolean | undefined;
1856
- name: string;
1857
- type: string;
1858
- primaryKey: boolean;
1859
- notNull: boolean;
1860
- }>;
1861
- indexes: Record<string, {
1862
- name: string;
1863
- columns: string[];
1864
- isUnique: boolean;
1865
- }>;
1866
- foreignKeys: Record<string, {
1867
- onUpdate?: string | undefined;
1868
- onDelete?: string | undefined;
1869
- schemaTo?: string | undefined;
1870
- name: string;
1871
- tableFrom: string;
1872
- columnsFrom: string[];
1873
- tableTo: string;
1874
- columnsTo: string[];
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
- uniqueConstraints?: Record<string, {
1888
- name: string;
1889
- columns: string[];
1890
- nullsNotDistinct: boolean;
1891
- }> | undefined;
1892
- name: string;
1893
- columns: Record<string, {
1894
- isUnique?: any;
1895
- default?: any;
1896
- typeSchema?: string | undefined;
1897
- uniqueName?: string | undefined;
1898
- nullsNotDistinct?: boolean | undefined;
1899
- name: string;
1900
- type: string;
1901
- primaryKey: boolean;
1902
- notNull: boolean;
1903
- }>;
1904
- indexes: Record<string, {
1905
- name: string;
1906
- columns: string[];
1907
- isUnique: boolean;
1908
- }>;
1909
- foreignKeys: Record<string, {
1910
- onUpdate?: string | undefined;
1911
- onDelete?: string | undefined;
1912
- schemaTo?: string | undefined;
1913
- name: string;
1914
- tableFrom: string;
1915
- columnsFrom: string[];
1916
- tableTo: string;
1917
- columnsTo: string[];
1918
- }>;
1919
- schema: string;
1920
- compositePrimaryKeys: Record<string, {
1921
- name: string;
1922
- columns: string[];
1923
- }>;
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
- isUnique?: any;
1960
- default?: any;
1961
- typeSchema?: string | undefined;
1962
- uniqueName?: string | undefined;
1963
- nullsNotDistinct?: boolean | undefined;
1964
- name: string;
1965
- type: string;
1966
- primaryKey: boolean;
1967
- notNull: boolean;
1968
- }>;
1969
- indexes: Record<string, {
1970
- name: string;
1971
- columns: string[];
1972
- isUnique: boolean;
1973
- }>;
1974
- foreignKeys: Record<string, {
1975
- onUpdate?: string | undefined;
1976
- onDelete?: string | undefined;
1977
- schemaTo?: string | undefined;
1978
- name: string;
1979
- tableFrom: string;
1980
- columnsFrom: string[];
1981
- tableTo: string;
1982
- columnsTo: string[];
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
- uniqueConstraints?: Record<string, {
2012
- name: string;
2013
- columns: string[];
2014
- nullsNotDistinct: boolean;
2015
- }> | undefined;
2016
- name: string;
2017
- columns: Record<string, {
2018
- isUnique?: any;
2019
- default?: any;
2020
- typeSchema?: string | undefined;
2021
- uniqueName?: string | undefined;
2022
- nullsNotDistinct?: boolean | undefined;
2023
- name: string;
2024
- type: string;
2025
- primaryKey: boolean;
2026
- notNull: boolean;
2027
- }>;
2028
- indexes: Record<string, {
2029
- name: string;
2030
- columns: string[];
2031
- isUnique: boolean;
2032
- }>;
2033
- foreignKeys: Record<string, {
2034
- onUpdate?: string | undefined;
2035
- onDelete?: string | undefined;
2036
- schemaTo?: string | undefined;
2037
- name: string;
2038
- tableFrom: string;
2039
- columnsFrom: string[];
2040
- tableTo: string;
2041
- columnsTo: string[];
2042
- }>;
2043
- schema: string;
2044
- compositePrimaryKeys: Record<string, {
2045
- name: string;
2046
- columns: string[];
2047
- }>;
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<"postgresql">;
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
- isUnique?: any;
2082
- default?: any;
2083
- typeSchema?: string | undefined;
2084
- uniqueName?: string | undefined;
2085
- nullsNotDistinct?: boolean | undefined;
2086
- name: string;
2087
- type: string;
2088
- primaryKey: boolean;
2089
- notNull: boolean;
2090
- }, {
2091
- isUnique?: any;
2092
- default?: any;
2093
- typeSchema?: string | undefined;
2094
- uniqueName?: string | undefined;
2095
- nullsNotDistinct?: boolean | undefined;
2096
- name: string;
2097
- type: string;
2098
- primaryKey: boolean;
2099
- notNull: boolean;
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
- onUpdate?: string | undefined;
2125
- onDelete?: string | undefined;
2126
- schemaTo?: string | undefined;
2127
- name: string;
2128
- tableFrom: string;
2129
- columnsFrom: string[];
2130
- tableTo: string;
2131
- columnsTo: string[];
2132
- }, {
2133
- onUpdate?: string | undefined;
2134
- onDelete?: string | undefined;
2135
- schemaTo?: string | undefined;
2136
- name: string;
2137
- tableFrom: string;
2138
- columnsFrom: string[];
2139
- tableTo: string;
2140
- columnsTo: string[];
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
- isUnique?: any;
2169
- default?: any;
2170
- typeSchema?: string | undefined;
2171
- uniqueName?: string | undefined;
2172
- nullsNotDistinct?: boolean | undefined;
2173
- name: string;
2174
- type: string;
2175
- primaryKey: boolean;
2176
- notNull: boolean;
2177
- }>;
2178
- indexes: Record<string, {
2179
- name: string;
2180
- columns: string[];
2181
- isUnique: boolean;
2182
- }>;
2183
- foreignKeys: Record<string, {
2184
- onUpdate?: string | undefined;
2185
- onDelete?: string | undefined;
2186
- schemaTo?: string | undefined;
2187
- name: string;
2188
- tableFrom: string;
2189
- columnsFrom: string[];
2190
- tableTo: string;
2191
- columnsTo: string[];
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
- uniqueConstraints?: Record<string, {
2205
- name: string;
2206
- columns: string[];
2207
- nullsNotDistinct: boolean;
2208
- }> | undefined;
2209
- name: string;
2210
- columns: Record<string, {
2211
- isUnique?: any;
2212
- default?: any;
2213
- typeSchema?: string | undefined;
2214
- uniqueName?: string | undefined;
2215
- nullsNotDistinct?: boolean | undefined;
2216
- name: string;
2217
- type: string;
2218
- primaryKey: boolean;
2219
- notNull: boolean;
2220
- }>;
2221
- indexes: Record<string, {
2222
- name: string;
2223
- columns: string[];
2224
- isUnique: boolean;
2225
- }>;
2226
- foreignKeys: Record<string, {
2227
- onUpdate?: string | undefined;
2228
- onDelete?: string | undefined;
2229
- schemaTo?: string | undefined;
2230
- name: string;
2231
- tableFrom: string;
2232
- columnsFrom: string[];
2233
- tableTo: string;
2234
- columnsTo: string[];
2235
- }>;
2236
- schema: string;
2237
- compositePrimaryKeys: Record<string, {
2238
- name: string;
2239
- columns: string[];
2240
- }>;
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
- internal?: {
2316
- tables: Record<string, {
2317
- columns: Record<string, {
2318
- isArray?: boolean | undefined;
2319
- dimensions?: number | undefined;
2320
- rawType?: string | undefined;
2321
- } | undefined>;
2322
- } | undefined>;
2323
- } | undefined;
2324
- tables: Record<string, {
2325
- name: string;
2326
- columns: Record<string, {
2327
- isUnique?: any;
2328
- default?: any;
2329
- typeSchema?: string | undefined;
2330
- uniqueName?: string | undefined;
2331
- nullsNotDistinct?: boolean | undefined;
2332
- name: string;
2333
- type: string;
2334
- primaryKey: boolean;
2335
- notNull: boolean;
2336
- }>;
2337
- indexes: Record<string, {
2338
- name: string;
2339
- columns: string[];
2340
- isUnique: boolean;
2341
- }>;
2342
- foreignKeys: Record<string, {
2343
- onUpdate?: string | undefined;
2344
- onDelete?: string | undefined;
2345
- schemaTo?: string | undefined;
2346
- name: string;
2347
- tableFrom: string;
2348
- columnsFrom: string[];
2349
- tableTo: string;
2350
- columnsTo: string[];
2351
- }>;
2352
- schema: string;
2353
- compositePrimaryKeys: Record<string, {
2354
- name: string;
2355
- columns: string[];
2356
- }>;
2357
- uniqueConstraints: Record<string, {
2358
- name: string;
2359
- columns: string[];
2360
- nullsNotDistinct: boolean;
2361
- }>;
2362
- }>;
2363
- version: "6";
2364
- dialect: "postgresql";
2365
- schemas: Record<string, string>;
2366
- _meta: {
2367
- columns: Record<string, string>;
2368
- tables: Record<string, string>;
2369
- schemas: Record<string, string>;
2370
- };
2371
- enums: Record<string, {
2372
- name: string;
2373
- values: string[];
2374
- schema: string;
2375
- }>;
2376
- }, {
2377
- internal?: {
2378
- tables: Record<string, {
2379
- columns: Record<string, {
2380
- isArray?: boolean | undefined;
2381
- dimensions?: number | undefined;
2382
- rawType?: string | undefined;
2383
- } | undefined>;
2384
- } | undefined>;
2385
- } | undefined;
2386
- tables: Record<string, {
2387
- uniqueConstraints?: Record<string, {
2388
- name: string;
2389
- columns: string[];
2390
- nullsNotDistinct: boolean;
2391
- }> | undefined;
2392
- name: string;
2393
- columns: Record<string, {
2394
- isUnique?: any;
2395
- default?: any;
2396
- typeSchema?: string | undefined;
2397
- uniqueName?: string | undefined;
2398
- nullsNotDistinct?: boolean | undefined;
2399
- name: string;
2400
- type: string;
2401
- primaryKey: boolean;
2402
- notNull: boolean;
2403
- }>;
2404
- indexes: Record<string, {
2405
- name: string;
2406
- columns: string[];
2407
- isUnique: boolean;
2408
- }>;
2409
- foreignKeys: Record<string, {
2410
- onUpdate?: string | undefined;
2411
- onDelete?: string | undefined;
2412
- schemaTo?: string | undefined;
2413
- name: string;
2414
- tableFrom: string;
2415
- columnsFrom: string[];
2416
- tableTo: string;
2417
- columnsTo: string[];
2418
- }>;
2419
- schema: string;
2420
- compositePrimaryKeys: Record<string, {
2421
- name: string;
2422
- columns: string[];
2423
- }>;
2424
- }>;
2425
- version: "6";
2426
- dialect: "postgresql";
2427
- schemas: Record<string, string>;
2428
- _meta: {
2429
- columns: Record<string, string>;
2430
- tables: Record<string, string>;
2431
- schemas: Record<string, string>;
2432
- };
2433
- enums: Record<string, {
2434
- name: string;
2435
- values: string[];
2436
- schema: string;
2437
- }>;
2438
- }>;
2439
- export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
2440
- version: import("zod").ZodLiteral<"4">;
2441
- dialect: import("zod").ZodLiteral<"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
- isUnique?: any;
2457
- default?: any;
2458
- typeSchema?: string | undefined;
2459
- uniqueName?: string | undefined;
2460
- nullsNotDistinct?: boolean | undefined;
2461
- name: string;
2462
- type: string;
2463
- primaryKey: boolean;
2464
- notNull: boolean;
2465
- }, {
2466
- isUnique?: any;
2467
- default?: any;
2468
- typeSchema?: string | undefined;
2469
- uniqueName?: string | undefined;
2470
- nullsNotDistinct?: boolean | undefined;
2471
- name: string;
2472
- type: string;
2473
- primaryKey: boolean;
2474
- notNull: boolean;
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
- isUnique?: any;
2482
- default?: any;
2483
- typeSchema?: string | undefined;
2484
- uniqueName?: string | undefined;
2485
- nullsNotDistinct?: boolean | undefined;
2486
- name: string;
2487
- type: string;
2488
- primaryKey: boolean;
2489
- notNull: boolean;
2490
- }>;
2491
- indexes: Record<string, string>;
2492
- foreignKeys: Record<string, string>;
2493
- schema: string;
2494
- }, {
2495
- name: string;
2496
- columns: Record<string, {
2497
- isUnique?: any;
2498
- default?: any;
2499
- typeSchema?: string | undefined;
2500
- uniqueName?: string | undefined;
2501
- nullsNotDistinct?: boolean | undefined;
2502
- name: string;
2503
- type: string;
2504
- primaryKey: boolean;
2505
- notNull: boolean;
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
- isUnique?: any;
2527
- default?: any;
2528
- typeSchema?: string | undefined;
2529
- uniqueName?: string | undefined;
2530
- nullsNotDistinct?: boolean | undefined;
2531
- name: string;
2532
- type: string;
2533
- primaryKey: boolean;
2534
- notNull: boolean;
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
- isUnique?: any;
2552
- default?: any;
2553
- typeSchema?: string | undefined;
2554
- uniqueName?: string | undefined;
2555
- nullsNotDistinct?: boolean | undefined;
2556
- name: string;
2557
- type: string;
2558
- primaryKey: boolean;
2559
- notNull: boolean;
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").ZodLiteral<"postgresql">;
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
- isUnique?: any;
2591
- default?: any;
2592
- typeSchema?: string | undefined;
2593
- uniqueName?: string | undefined;
2594
- nullsNotDistinct?: boolean | undefined;
2595
- name: string;
2596
- type: string;
2597
- primaryKey: boolean;
2598
- notNull: boolean;
2599
- }, {
2600
- isUnique?: any;
2601
- default?: any;
2602
- typeSchema?: string | undefined;
2603
- uniqueName?: string | undefined;
2604
- nullsNotDistinct?: boolean | undefined;
2605
- name: string;
2606
- type: string;
2607
- primaryKey: boolean;
2608
- notNull: boolean;
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
- isUnique?: any;
2618
- default?: any;
2619
- typeSchema?: string | undefined;
2620
- uniqueName?: string | undefined;
2621
- nullsNotDistinct?: boolean | undefined;
2622
- name: string;
2623
- type: string;
2624
- primaryKey: boolean;
2625
- notNull: boolean;
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
- isUnique?: any;
2636
- default?: any;
2637
- typeSchema?: string | undefined;
2638
- uniqueName?: string | undefined;
2639
- nullsNotDistinct?: boolean | undefined;
2640
- name: string;
2641
- type: string;
2642
- primaryKey: boolean;
2643
- notNull: boolean;
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
- isUnique?: any;
2670
- default?: any;
2671
- typeSchema?: string | undefined;
2672
- uniqueName?: string | undefined;
2673
- nullsNotDistinct?: boolean | undefined;
2674
- name: string;
2675
- type: string;
2676
- primaryKey: boolean;
2677
- notNull: boolean;
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: "postgresql";
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
- isUnique?: any;
2698
- default?: any;
2699
- typeSchema?: string | undefined;
2700
- uniqueName?: string | undefined;
2701
- nullsNotDistinct?: boolean | undefined;
2702
- name: string;
2703
- type: string;
2704
- primaryKey: boolean;
2705
- notNull: boolean;
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: "postgresql";
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").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
- isUnique?: any;
2739
- default?: any;
2740
- typeSchema?: string | undefined;
2741
- uniqueName?: string | undefined;
2742
- nullsNotDistinct?: boolean | undefined;
2743
- name: string;
2744
- type: string;
2745
- primaryKey: boolean;
2746
- notNull: boolean;
2747
- }, {
2748
- isUnique?: any;
2749
- default?: any;
2750
- typeSchema?: string | undefined;
2751
- uniqueName?: string | undefined;
2752
- nullsNotDistinct?: boolean | undefined;
2753
- name: string;
2754
- type: string;
2755
- primaryKey: boolean;
2756
- notNull: boolean;
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
- onUpdate?: string | undefined;
2782
- onDelete?: string | undefined;
2783
- schemaTo?: string | undefined;
2784
- name: string;
2785
- tableFrom: string;
2786
- columnsFrom: string[];
2787
- tableTo: string;
2788
- columnsTo: string[];
2789
- }, {
2790
- onUpdate?: string | undefined;
2791
- onDelete?: string | undefined;
2792
- schemaTo?: string | undefined;
2793
- name: string;
2794
- tableFrom: string;
2795
- columnsFrom: string[];
2796
- tableTo: string;
2797
- columnsTo: string[];
2798
- }>>;
2799
- }, "strict", import("zod").ZodTypeAny, {
2800
- name: string;
2801
- columns: Record<string, {
2802
- isUnique?: any;
2803
- default?: any;
2804
- typeSchema?: string | undefined;
2805
- uniqueName?: string | undefined;
2806
- nullsNotDistinct?: boolean | undefined;
2807
- name: string;
2808
- type: string;
2809
- primaryKey: boolean;
2810
- notNull: boolean;
2811
- }>;
2812
- indexes: Record<string, {
2813
- name: string;
2814
- columns: string[];
2815
- isUnique: boolean;
2816
- }>;
2817
- foreignKeys: Record<string, {
2818
- onUpdate?: string | undefined;
2819
- onDelete?: string | undefined;
2820
- schemaTo?: string | undefined;
2821
- name: string;
2822
- tableFrom: string;
2823
- columnsFrom: string[];
2824
- tableTo: string;
2825
- columnsTo: string[];
2826
- }>;
2827
- }, {
2828
- name: string;
2829
- columns: Record<string, {
2830
- isUnique?: any;
2831
- default?: any;
2832
- typeSchema?: string | undefined;
2833
- uniqueName?: string | undefined;
2834
- nullsNotDistinct?: boolean | undefined;
2835
- name: string;
2836
- type: string;
2837
- primaryKey: boolean;
2838
- notNull: boolean;
2839
- }>;
2840
- indexes: Record<string, {
2841
- name: string;
2842
- columns: string[];
2843
- isUnique: boolean;
2844
- }>;
2845
- foreignKeys: Record<string, {
2846
- onUpdate?: string | undefined;
2847
- onDelete?: string | undefined;
2848
- schemaTo?: string | undefined;
2849
- name: string;
2850
- tableFrom: string;
2851
- columnsFrom: string[];
2852
- tableTo: string;
2853
- columnsTo: string[];
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
- isUnique?: any;
2874
- default?: any;
2875
- typeSchema?: string | undefined;
2876
- uniqueName?: string | undefined;
2877
- nullsNotDistinct?: boolean | undefined;
2878
- name: string;
2879
- type: string;
2880
- primaryKey: boolean;
2881
- notNull: boolean;
2882
- }>;
2883
- indexes: Record<string, {
2884
- name: string;
2885
- columns: string[];
2886
- isUnique: boolean;
2887
- }>;
2888
- foreignKeys: Record<string, {
2889
- onUpdate?: string | undefined;
2890
- onDelete?: string | undefined;
2891
- schemaTo?: string | undefined;
2892
- name: string;
2893
- tableFrom: string;
2894
- columnsFrom: string[];
2895
- tableTo: string;
2896
- columnsTo: string[];
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
- isUnique?: any;
2912
- default?: any;
2913
- typeSchema?: string | undefined;
2914
- uniqueName?: string | undefined;
2915
- nullsNotDistinct?: boolean | undefined;
2916
- name: string;
2917
- type: string;
2918
- primaryKey: boolean;
2919
- notNull: boolean;
2920
- }>;
2921
- indexes: Record<string, {
2922
- name: string;
2923
- columns: string[];
2924
- isUnique: boolean;
2925
- }>;
2926
- foreignKeys: Record<string, {
2927
- onUpdate?: string | undefined;
2928
- onDelete?: string | undefined;
2929
- schemaTo?: string | undefined;
2930
- name: string;
2931
- tableFrom: string;
2932
- columnsFrom: string[];
2933
- tableTo: string;
2934
- columnsTo: string[];
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").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
- isUnique?: any;
2964
- default?: any;
2965
- typeSchema?: string | undefined;
2966
- uniqueName?: string | undefined;
2967
- nullsNotDistinct?: boolean | undefined;
2968
- name: string;
2969
- type: string;
2970
- primaryKey: boolean;
2971
- notNull: boolean;
2972
- }, {
2973
- isUnique?: any;
2974
- default?: any;
2975
- typeSchema?: string | undefined;
2976
- uniqueName?: string | undefined;
2977
- nullsNotDistinct?: boolean | undefined;
2978
- name: string;
2979
- type: string;
2980
- primaryKey: boolean;
2981
- notNull: boolean;
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
- onUpdate?: string | undefined;
3007
- onDelete?: string | undefined;
3008
- schemaTo?: string | undefined;
3009
- name: string;
3010
- tableFrom: string;
3011
- columnsFrom: string[];
3012
- tableTo: string;
3013
- columnsTo: string[];
3014
- }, {
3015
- onUpdate?: string | undefined;
3016
- onDelete?: string | undefined;
3017
- schemaTo?: string | undefined;
3018
- name: string;
3019
- tableFrom: string;
3020
- columnsFrom: string[];
3021
- tableTo: string;
3022
- columnsTo: string[];
3023
- }>>;
3024
- }, "strict", import("zod").ZodTypeAny, {
3025
- name: string;
3026
- columns: Record<string, {
3027
- isUnique?: any;
3028
- default?: any;
3029
- typeSchema?: string | undefined;
3030
- uniqueName?: string | undefined;
3031
- nullsNotDistinct?: boolean | undefined;
3032
- name: string;
3033
- type: string;
3034
- primaryKey: boolean;
3035
- notNull: boolean;
3036
- }>;
3037
- indexes: Record<string, {
3038
- name: string;
3039
- columns: string[];
3040
- isUnique: boolean;
3041
- }>;
3042
- foreignKeys: Record<string, {
3043
- onUpdate?: string | undefined;
3044
- onDelete?: string | undefined;
3045
- schemaTo?: string | undefined;
3046
- name: string;
3047
- tableFrom: string;
3048
- columnsFrom: string[];
3049
- tableTo: string;
3050
- columnsTo: string[];
3051
- }>;
3052
- schema: string;
3053
- }, {
3054
- name: string;
3055
- columns: Record<string, {
3056
- isUnique?: any;
3057
- default?: any;
3058
- typeSchema?: string | undefined;
3059
- uniqueName?: string | undefined;
3060
- nullsNotDistinct?: boolean | undefined;
3061
- name: string;
3062
- type: string;
3063
- primaryKey: boolean;
3064
- notNull: boolean;
3065
- }>;
3066
- indexes: Record<string, {
3067
- name: string;
3068
- columns: string[];
3069
- isUnique: boolean;
3070
- }>;
3071
- foreignKeys: Record<string, {
3072
- onUpdate?: string | undefined;
3073
- onDelete?: string | undefined;
3074
- schemaTo?: string | undefined;
3075
- name: string;
3076
- tableFrom: string;
3077
- columnsFrom: string[];
3078
- tableTo: string;
3079
- columnsTo: string[];
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
- isUnique?: any;
3102
- default?: any;
3103
- typeSchema?: string | undefined;
3104
- uniqueName?: string | undefined;
3105
- nullsNotDistinct?: boolean | undefined;
3106
- name: string;
3107
- type: string;
3108
- primaryKey: boolean;
3109
- notNull: boolean;
3110
- }>;
3111
- indexes: Record<string, {
3112
- name: string;
3113
- columns: string[];
3114
- isUnique: boolean;
3115
- }>;
3116
- foreignKeys: Record<string, {
3117
- onUpdate?: string | undefined;
3118
- onDelete?: string | undefined;
3119
- schemaTo?: string | undefined;
3120
- name: string;
3121
- tableFrom: string;
3122
- columnsFrom: string[];
3123
- tableTo: string;
3124
- columnsTo: string[];
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
- isUnique?: any;
3142
- default?: any;
3143
- typeSchema?: string | undefined;
3144
- uniqueName?: string | undefined;
3145
- nullsNotDistinct?: boolean | undefined;
3146
- name: string;
3147
- type: string;
3148
- primaryKey: boolean;
3149
- notNull: boolean;
3150
- }>;
3151
- indexes: Record<string, {
3152
- name: string;
3153
- columns: string[];
3154
- isUnique: boolean;
3155
- }>;
3156
- foreignKeys: Record<string, {
3157
- onUpdate?: string | undefined;
3158
- onDelete?: string | undefined;
3159
- schemaTo?: string | undefined;
3160
- name: string;
3161
- tableFrom: string;
3162
- columnsFrom: string[];
3163
- tableTo: string;
3164
- columnsTo: string[];
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").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
- isUnique?: any;
3196
- default?: any;
3197
- typeSchema?: string | undefined;
3198
- uniqueName?: string | undefined;
3199
- nullsNotDistinct?: boolean | undefined;
3200
- name: string;
3201
- type: string;
3202
- primaryKey: boolean;
3203
- notNull: boolean;
3204
- }, {
3205
- isUnique?: any;
3206
- default?: any;
3207
- typeSchema?: string | undefined;
3208
- uniqueName?: string | undefined;
3209
- nullsNotDistinct?: boolean | undefined;
3210
- name: string;
3211
- type: string;
3212
- primaryKey: boolean;
3213
- notNull: boolean;
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
- onUpdate?: string | undefined;
3239
- onDelete?: string | undefined;
3240
- schemaTo?: string | undefined;
3241
- name: string;
3242
- tableFrom: string;
3243
- columnsFrom: string[];
3244
- tableTo: string;
3245
- columnsTo: string[];
3246
- }, {
3247
- onUpdate?: string | undefined;
3248
- onDelete?: string | undefined;
3249
- schemaTo?: string | undefined;
3250
- name: string;
3251
- tableFrom: string;
3252
- columnsFrom: string[];
3253
- tableTo: string;
3254
- columnsTo: string[];
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
- isUnique?: any;
3283
- default?: any;
3284
- typeSchema?: string | undefined;
3285
- uniqueName?: string | undefined;
3286
- nullsNotDistinct?: boolean | undefined;
3287
- name: string;
3288
- type: string;
3289
- primaryKey: boolean;
3290
- notNull: boolean;
3291
- }>;
3292
- indexes: Record<string, {
3293
- name: string;
3294
- columns: string[];
3295
- isUnique: boolean;
3296
- }>;
3297
- foreignKeys: Record<string, {
3298
- onUpdate?: string | undefined;
3299
- onDelete?: string | undefined;
3300
- schemaTo?: string | undefined;
3301
- name: string;
3302
- tableFrom: string;
3303
- columnsFrom: string[];
3304
- tableTo: string;
3305
- columnsTo: string[];
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
- uniqueConstraints?: Record<string, {
3319
- name: string;
3320
- columns: string[];
3321
- nullsNotDistinct: boolean;
3322
- }> | undefined;
3323
- name: string;
3324
- columns: Record<string, {
3325
- isUnique?: any;
3326
- default?: any;
3327
- typeSchema?: string | undefined;
3328
- uniqueName?: string | undefined;
3329
- nullsNotDistinct?: boolean | undefined;
3330
- name: string;
3331
- type: string;
3332
- primaryKey: boolean;
3333
- notNull: boolean;
3334
- }>;
3335
- indexes: Record<string, {
3336
- name: string;
3337
- columns: string[];
3338
- isUnique: boolean;
3339
- }>;
3340
- foreignKeys: Record<string, {
3341
- onUpdate?: string | undefined;
3342
- onDelete?: string | undefined;
3343
- schemaTo?: string | undefined;
3344
- name: string;
3345
- tableFrom: string;
3346
- columnsFrom: string[];
3347
- tableTo: string;
3348
- columnsTo: string[];
3349
- }>;
3350
- schema: string;
3351
- compositePrimaryKeys: Record<string, {
3352
- name: string;
3353
- columns: string[];
3354
- }>;
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
- internal?: {
3430
- tables: Record<string, {
3431
- columns: Record<string, {
3432
- isArray?: boolean | undefined;
3433
- dimensions?: number | undefined;
3434
- rawType?: string | undefined;
3435
- } | undefined>;
3436
- } | undefined>;
3437
- } | undefined;
3438
- tables: Record<string, {
3439
- name: string;
3440
- columns: Record<string, {
3441
- isUnique?: any;
3442
- default?: any;
3443
- typeSchema?: string | undefined;
3444
- uniqueName?: string | undefined;
3445
- nullsNotDistinct?: boolean | undefined;
3446
- name: string;
3447
- type: string;
3448
- primaryKey: boolean;
3449
- notNull: boolean;
3450
- }>;
3451
- indexes: Record<string, {
3452
- name: string;
3453
- columns: string[];
3454
- isUnique: boolean;
3455
- }>;
3456
- foreignKeys: Record<string, {
3457
- onUpdate?: string | undefined;
3458
- onDelete?: string | undefined;
3459
- schemaTo?: string | undefined;
3460
- name: string;
3461
- tableFrom: string;
3462
- columnsFrom: string[];
3463
- tableTo: string;
3464
- columnsTo: string[];
3465
- }>;
3466
- schema: string;
3467
- compositePrimaryKeys: Record<string, {
3468
- name: string;
3469
- columns: string[];
3470
- }>;
3471
- uniqueConstraints: Record<string, {
3472
- name: string;
3473
- columns: string[];
3474
- nullsNotDistinct: boolean;
3475
- }>;
3476
- }>;
3477
- id: string;
3478
- prevId: string;
3479
- version: "5";
3480
- dialect: "pg";
3481
- schemas: Record<string, string>;
3482
- _meta: {
3483
- columns: Record<string, string>;
3484
- tables: Record<string, string>;
3485
- schemas: Record<string, string>;
3486
- };
3487
- enums: Record<string, {
3488
- name: string;
3489
- values: Record<string, string>;
3490
- }>;
3491
- }, {
3492
- internal?: {
3493
- tables: Record<string, {
3494
- columns: Record<string, {
3495
- isArray?: boolean | undefined;
3496
- dimensions?: number | undefined;
3497
- rawType?: string | undefined;
3498
- } | undefined>;
3499
- } | undefined>;
3500
- } | undefined;
3501
- tables: Record<string, {
3502
- uniqueConstraints?: Record<string, {
3503
- name: string;
3504
- columns: string[];
3505
- nullsNotDistinct: boolean;
3506
- }> | undefined;
3507
- name: string;
3508
- columns: Record<string, {
3509
- isUnique?: any;
3510
- default?: any;
3511
- typeSchema?: string | undefined;
3512
- uniqueName?: string | undefined;
3513
- nullsNotDistinct?: boolean | undefined;
3514
- name: string;
3515
- type: string;
3516
- primaryKey: boolean;
3517
- notNull: boolean;
3518
- }>;
3519
- indexes: Record<string, {
3520
- name: string;
3521
- columns: string[];
3522
- isUnique: boolean;
3523
- }>;
3524
- foreignKeys: Record<string, {
3525
- onUpdate?: string | undefined;
3526
- onDelete?: string | undefined;
3527
- schemaTo?: string | undefined;
3528
- name: string;
3529
- tableFrom: string;
3530
- columnsFrom: string[];
3531
- tableTo: string;
3532
- columnsTo: string[];
3533
- }>;
3534
- schema: string;
3535
- compositePrimaryKeys: Record<string, {
3536
- name: string;
3537
- columns: string[];
3538
- }>;
3539
- }>;
3540
- id: string;
3541
- prevId: string;
3542
- version: "5";
3543
- dialect: "pg";
3544
- schemas: Record<string, string>;
3545
- _meta: {
3546
- columns: Record<string, string>;
3547
- tables: Record<string, string>;
3548
- schemas: Record<string, string>;
3549
- };
3550
- enums: Record<string, {
3551
- name: string;
3552
- values: Record<string, string>;
3553
- }>;
3554
- }>;
3555
- export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape<{
3556
- version: import("zod").ZodLiteral<"6">;
3557
- dialect: import("zod").ZodLiteral<"postgresql">;
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
- isUnique?: any;
3573
- default?: any;
3574
- typeSchema?: string | undefined;
3575
- uniqueName?: string | undefined;
3576
- nullsNotDistinct?: boolean | undefined;
3577
- name: string;
3578
- type: string;
3579
- primaryKey: boolean;
3580
- notNull: boolean;
3581
- }, {
3582
- isUnique?: any;
3583
- default?: any;
3584
- typeSchema?: string | undefined;
3585
- uniqueName?: string | undefined;
3586
- nullsNotDistinct?: boolean | undefined;
3587
- name: string;
3588
- type: string;
3589
- primaryKey: boolean;
3590
- notNull: boolean;
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
- onUpdate?: string | undefined;
3616
- onDelete?: string | undefined;
3617
- schemaTo?: string | undefined;
3618
- name: string;
3619
- tableFrom: string;
3620
- columnsFrom: string[];
3621
- tableTo: string;
3622
- columnsTo: string[];
3623
- }, {
3624
- onUpdate?: string | undefined;
3625
- onDelete?: string | undefined;
3626
- schemaTo?: string | undefined;
3627
- name: string;
3628
- tableFrom: string;
3629
- columnsFrom: string[];
3630
- tableTo: string;
3631
- columnsTo: string[];
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
- isUnique?: any;
3660
- default?: any;
3661
- typeSchema?: string | undefined;
3662
- uniqueName?: string | undefined;
3663
- nullsNotDistinct?: boolean | undefined;
3664
- name: string;
3665
- type: string;
3666
- primaryKey: boolean;
3667
- notNull: boolean;
3668
- }>;
3669
- indexes: Record<string, {
3670
- name: string;
3671
- columns: string[];
3672
- isUnique: boolean;
3673
- }>;
3674
- foreignKeys: Record<string, {
3675
- onUpdate?: string | undefined;
3676
- onDelete?: string | undefined;
3677
- schemaTo?: string | undefined;
3678
- name: string;
3679
- tableFrom: string;
3680
- columnsFrom: string[];
3681
- tableTo: string;
3682
- columnsTo: string[];
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
- uniqueConstraints?: Record<string, {
3696
- name: string;
3697
- columns: string[];
3698
- nullsNotDistinct: boolean;
3699
- }> | undefined;
3700
- name: string;
3701
- columns: Record<string, {
3702
- isUnique?: any;
3703
- default?: any;
3704
- typeSchema?: string | undefined;
3705
- uniqueName?: string | undefined;
3706
- nullsNotDistinct?: boolean | undefined;
3707
- name: string;
3708
- type: string;
3709
- primaryKey: boolean;
3710
- notNull: boolean;
3711
- }>;
3712
- indexes: Record<string, {
3713
- name: string;
3714
- columns: string[];
3715
- isUnique: boolean;
3716
- }>;
3717
- foreignKeys: Record<string, {
3718
- onUpdate?: string | undefined;
3719
- onDelete?: string | undefined;
3720
- schemaTo?: string | undefined;
3721
- name: string;
3722
- tableFrom: string;
3723
- columnsFrom: string[];
3724
- tableTo: string;
3725
- columnsTo: string[];
3726
- }>;
3727
- schema: string;
3728
- compositePrimaryKeys: Record<string, {
3729
- name: string;
3730
- columns: string[];
3731
- }>;
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
- internal?: {
3810
- tables: Record<string, {
3811
- columns: Record<string, {
3812
- isArray?: boolean | undefined;
3813
- dimensions?: number | undefined;
3814
- rawType?: string | undefined;
3815
- } | undefined>;
3816
- } | undefined>;
3817
- } | undefined;
3818
- tables: Record<string, {
3819
- name: string;
3820
- columns: Record<string, {
3821
- isUnique?: any;
3822
- default?: any;
3823
- typeSchema?: string | undefined;
3824
- uniqueName?: string | undefined;
3825
- nullsNotDistinct?: boolean | undefined;
3826
- name: string;
3827
- type: string;
3828
- primaryKey: boolean;
3829
- notNull: boolean;
3830
- }>;
3831
- indexes: Record<string, {
3832
- name: string;
3833
- columns: string[];
3834
- isUnique: boolean;
3835
- }>;
3836
- foreignKeys: Record<string, {
3837
- onUpdate?: string | undefined;
3838
- onDelete?: string | undefined;
3839
- schemaTo?: string | undefined;
3840
- name: string;
3841
- tableFrom: string;
3842
- columnsFrom: string[];
3843
- tableTo: string;
3844
- columnsTo: string[];
3845
- }>;
3846
- schema: string;
3847
- compositePrimaryKeys: Record<string, {
3848
- name: string;
3849
- columns: string[];
3850
- }>;
3851
- uniqueConstraints: Record<string, {
3852
- name: string;
3853
- columns: string[];
3854
- nullsNotDistinct: boolean;
3855
- }>;
3856
- }>;
3857
- id: string;
3858
- prevId: string;
3859
- version: "6";
3860
- dialect: "postgresql";
3861
- schemas: Record<string, string>;
3862
- _meta: {
3863
- columns: Record<string, string>;
3864
- tables: Record<string, string>;
3865
- schemas: Record<string, string>;
3866
- };
3867
- enums: Record<string, {
3868
- name: string;
3869
- values: string[];
3870
- schema: string;
3871
- }>;
3872
- }, {
3873
- internal?: {
3874
- tables: Record<string, {
3875
- columns: Record<string, {
3876
- isArray?: boolean | undefined;
3877
- dimensions?: number | undefined;
3878
- rawType?: string | undefined;
3879
- } | undefined>;
3880
- } | undefined>;
3881
- } | undefined;
3882
- tables: Record<string, {
3883
- uniqueConstraints?: Record<string, {
3884
- name: string;
3885
- columns: string[];
3886
- nullsNotDistinct: boolean;
3887
- }> | undefined;
3888
- name: string;
3889
- columns: Record<string, {
3890
- isUnique?: any;
3891
- default?: any;
3892
- typeSchema?: string | undefined;
3893
- uniqueName?: string | undefined;
3894
- nullsNotDistinct?: boolean | undefined;
3895
- name: string;
3896
- type: string;
3897
- primaryKey: boolean;
3898
- notNull: boolean;
3899
- }>;
3900
- indexes: Record<string, {
3901
- name: string;
3902
- columns: string[];
3903
- isUnique: boolean;
3904
- }>;
3905
- foreignKeys: Record<string, {
3906
- onUpdate?: string | undefined;
3907
- onDelete?: string | undefined;
3908
- schemaTo?: string | undefined;
3909
- name: string;
3910
- tableFrom: string;
3911
- columnsFrom: string[];
3912
- tableTo: string;
3913
- columnsTo: string[];
3914
- }>;
3915
- schema: string;
3916
- compositePrimaryKeys: Record<string, {
3917
- name: string;
3918
- columns: string[];
3919
- }>;
3920
- }>;
3921
- id: string;
3922
- prevId: string;
3923
- version: "6";
3924
- dialect: "postgresql";
3925
- schemas: Record<string, string>;
3926
- _meta: {
3927
- columns: Record<string, string>;
3928
- tables: Record<string, string>;
3929
- schemas: Record<string, string>;
3930
- };
3931
- enums: Record<string, {
3932
- name: string;
3933
- values: string[];
3934
- schema: string;
3935
- }>;
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").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
- isUnique?: any;
3975
- default?: any;
3976
- typeSchema?: string | undefined;
3977
- uniqueName?: string | undefined;
3978
- nullsNotDistinct?: boolean | undefined;
3979
- name: string;
3980
- type: string;
3981
- primaryKey: boolean;
3982
- notNull: boolean;
3983
- }, {
3984
- isUnique?: any;
3985
- default?: any;
3986
- typeSchema?: string | undefined;
3987
- uniqueName?: string | undefined;
3988
- nullsNotDistinct?: boolean | undefined;
3989
- name: string;
3990
- type: string;
3991
- primaryKey: boolean;
3992
- notNull: boolean;
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
- onUpdate?: string | undefined;
4018
- onDelete?: string | undefined;
4019
- schemaTo?: string | undefined;
4020
- name: string;
4021
- tableFrom: string;
4022
- columnsFrom: string[];
4023
- tableTo: string;
4024
- columnsTo: string[];
4025
- }, {
4026
- onUpdate?: string | undefined;
4027
- onDelete?: string | undefined;
4028
- schemaTo?: string | undefined;
4029
- name: string;
4030
- tableFrom: string;
4031
- columnsFrom: string[];
4032
- tableTo: string;
4033
- columnsTo: string[];
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
- isUnique?: any;
4062
- default?: any;
4063
- typeSchema?: string | undefined;
4064
- uniqueName?: string | undefined;
4065
- nullsNotDistinct?: boolean | undefined;
4066
- name: string;
4067
- type: string;
4068
- primaryKey: boolean;
4069
- notNull: boolean;
4070
- }>;
4071
- indexes: Record<string, {
4072
- name: string;
4073
- columns: string[];
4074
- isUnique: boolean;
4075
- }>;
4076
- foreignKeys: Record<string, {
4077
- onUpdate?: string | undefined;
4078
- onDelete?: string | undefined;
4079
- schemaTo?: string | undefined;
4080
- name: string;
4081
- tableFrom: string;
4082
- columnsFrom: string[];
4083
- tableTo: string;
4084
- columnsTo: string[];
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
- uniqueConstraints?: Record<string, {
4098
- name: string;
4099
- columns: string[];
4100
- nullsNotDistinct: boolean;
4101
- }> | undefined;
4102
- name: string;
4103
- columns: Record<string, {
4104
- isUnique?: any;
4105
- default?: any;
4106
- typeSchema?: string | undefined;
4107
- uniqueName?: string | undefined;
4108
- nullsNotDistinct?: boolean | undefined;
4109
- name: string;
4110
- type: string;
4111
- primaryKey: boolean;
4112
- notNull: boolean;
4113
- }>;
4114
- indexes: Record<string, {
4115
- name: string;
4116
- columns: string[];
4117
- isUnique: boolean;
4118
- }>;
4119
- foreignKeys: Record<string, {
4120
- onUpdate?: string | undefined;
4121
- onDelete?: string | undefined;
4122
- schemaTo?: string | undefined;
4123
- name: string;
4124
- tableFrom: string;
4125
- columnsFrom: string[];
4126
- tableTo: string;
4127
- columnsTo: string[];
4128
- }>;
4129
- schema: string;
4130
- compositePrimaryKeys: Record<string, {
4131
- name: string;
4132
- columns: string[];
4133
- }>;
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
- internal?: {
4209
- tables: Record<string, {
4210
- columns: Record<string, {
4211
- isArray?: boolean | undefined;
4212
- dimensions?: number | undefined;
4213
- rawType?: string | undefined;
4214
- } | undefined>;
4215
- } | undefined>;
4216
- } | undefined;
4217
- tables: Record<string, {
4218
- name: string;
4219
- columns: Record<string, {
4220
- isUnique?: any;
4221
- default?: any;
4222
- typeSchema?: string | undefined;
4223
- uniqueName?: string | undefined;
4224
- nullsNotDistinct?: boolean | undefined;
4225
- name: string;
4226
- type: string;
4227
- primaryKey: boolean;
4228
- notNull: boolean;
4229
- }>;
4230
- indexes: Record<string, {
4231
- name: string;
4232
- columns: string[];
4233
- isUnique: boolean;
4234
- }>;
4235
- foreignKeys: Record<string, {
4236
- onUpdate?: string | undefined;
4237
- onDelete?: string | undefined;
4238
- schemaTo?: string | undefined;
4239
- name: string;
4240
- tableFrom: string;
4241
- columnsFrom: string[];
4242
- tableTo: string;
4243
- columnsTo: string[];
4244
- }>;
4245
- schema: string;
4246
- compositePrimaryKeys: Record<string, {
4247
- name: string;
4248
- columns: string[];
4249
- }>;
4250
- uniqueConstraints: Record<string, {
4251
- name: string;
4252
- columns: string[];
4253
- nullsNotDistinct: boolean;
4254
- }>;
4255
- }>;
4256
- id: string;
4257
- prevId: string;
4258
- version: "5";
4259
- dialect: "pg";
4260
- schemas: Record<string, string>;
4261
- _meta: {
4262
- columns: Record<string, string>;
4263
- tables: Record<string, string>;
4264
- schemas: Record<string, string>;
4265
- };
4266
- enums: Record<string, {
4267
- name: string;
4268
- values: Record<string, string>;
4269
- }>;
4270
- }, {
4271
- internal?: {
4272
- tables: Record<string, {
4273
- columns: Record<string, {
4274
- isArray?: boolean | undefined;
4275
- dimensions?: number | undefined;
4276
- rawType?: string | undefined;
4277
- } | undefined>;
4278
- } | undefined>;
4279
- } | undefined;
4280
- tables: Record<string, {
4281
- uniqueConstraints?: Record<string, {
4282
- name: string;
4283
- columns: string[];
4284
- nullsNotDistinct: boolean;
4285
- }> | undefined;
4286
- name: string;
4287
- columns: Record<string, {
4288
- isUnique?: any;
4289
- default?: any;
4290
- typeSchema?: string | undefined;
4291
- uniqueName?: string | undefined;
4292
- nullsNotDistinct?: boolean | undefined;
4293
- name: string;
4294
- type: string;
4295
- primaryKey: boolean;
4296
- notNull: boolean;
4297
- }>;
4298
- indexes: Record<string, {
4299
- name: string;
4300
- columns: string[];
4301
- isUnique: boolean;
4302
- }>;
4303
- foreignKeys: Record<string, {
4304
- onUpdate?: string | undefined;
4305
- onDelete?: string | undefined;
4306
- schemaTo?: string | undefined;
4307
- name: string;
4308
- tableFrom: string;
4309
- columnsFrom: string[];
4310
- tableTo: string;
4311
- columnsTo: string[];
4312
- }>;
4313
- schema: string;
4314
- compositePrimaryKeys: Record<string, {
4315
- name: string;
4316
- columns: string[];
4317
- }>;
4318
- }>;
4319
- id: string;
4320
- prevId: string;
4321
- version: "5";
4322
- dialect: "pg";
4323
- schemas: Record<string, string>;
4324
- _meta: {
4325
- columns: Record<string, string>;
4326
- tables: Record<string, string>;
4327
- schemas: Record<string, string>;
4328
- };
4329
- enums: Record<string, {
4330
- name: string;
4331
- values: Record<string, string>;
4332
- }>;
4333
- }>, import("zod").ZodObject<import("zod").extendShape<{
4334
- version: import("zod").ZodLiteral<"6">;
4335
- dialect: import("zod").ZodLiteral<"postgresql">;
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
- isUnique?: any;
4351
- default?: any;
4352
- typeSchema?: string | undefined;
4353
- uniqueName?: string | undefined;
4354
- nullsNotDistinct?: boolean | undefined;
4355
- name: string;
4356
- type: string;
4357
- primaryKey: boolean;
4358
- notNull: boolean;
4359
- }, {
4360
- isUnique?: any;
4361
- default?: any;
4362
- typeSchema?: string | undefined;
4363
- uniqueName?: string | undefined;
4364
- nullsNotDistinct?: boolean | undefined;
4365
- name: string;
4366
- type: string;
4367
- primaryKey: boolean;
4368
- notNull: boolean;
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
- onUpdate?: string | undefined;
4394
- onDelete?: string | undefined;
4395
- schemaTo?: string | undefined;
4396
- name: string;
4397
- tableFrom: string;
4398
- columnsFrom: string[];
4399
- tableTo: string;
4400
- columnsTo: string[];
4401
- }, {
4402
- onUpdate?: string | undefined;
4403
- onDelete?: string | undefined;
4404
- schemaTo?: string | undefined;
4405
- name: string;
4406
- tableFrom: string;
4407
- columnsFrom: string[];
4408
- tableTo: string;
4409
- columnsTo: string[];
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
- isUnique?: any;
4438
- default?: any;
4439
- typeSchema?: string | undefined;
4440
- uniqueName?: string | undefined;
4441
- nullsNotDistinct?: boolean | undefined;
4442
- name: string;
4443
- type: string;
4444
- primaryKey: boolean;
4445
- notNull: boolean;
4446
- }>;
4447
- indexes: Record<string, {
4448
- name: string;
4449
- columns: string[];
4450
- isUnique: boolean;
4451
- }>;
4452
- foreignKeys: Record<string, {
4453
- onUpdate?: string | undefined;
4454
- onDelete?: string | undefined;
4455
- schemaTo?: string | undefined;
4456
- name: string;
4457
- tableFrom: string;
4458
- columnsFrom: string[];
4459
- tableTo: string;
4460
- columnsTo: string[];
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
- uniqueConstraints?: Record<string, {
4474
- name: string;
4475
- columns: string[];
4476
- nullsNotDistinct: boolean;
4477
- }> | undefined;
4478
- name: string;
4479
- columns: Record<string, {
4480
- isUnique?: any;
4481
- default?: any;
4482
- typeSchema?: string | undefined;
4483
- uniqueName?: string | undefined;
4484
- nullsNotDistinct?: boolean | undefined;
4485
- name: string;
4486
- type: string;
4487
- primaryKey: boolean;
4488
- notNull: boolean;
4489
- }>;
4490
- indexes: Record<string, {
4491
- name: string;
4492
- columns: string[];
4493
- isUnique: boolean;
4494
- }>;
4495
- foreignKeys: Record<string, {
4496
- onUpdate?: string | undefined;
4497
- onDelete?: string | undefined;
4498
- schemaTo?: string | undefined;
4499
- name: string;
4500
- tableFrom: string;
4501
- columnsFrom: string[];
4502
- tableTo: string;
4503
- columnsTo: string[];
4504
- }>;
4505
- schema: string;
4506
- compositePrimaryKeys: Record<string, {
4507
- name: string;
4508
- columns: string[];
4509
- }>;
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
- internal?: {
4588
- tables: Record<string, {
4589
- columns: Record<string, {
4590
- isArray?: boolean | undefined;
4591
- dimensions?: number | undefined;
4592
- rawType?: string | undefined;
4593
- } | undefined>;
4594
- } | undefined>;
4595
- } | undefined;
4596
- tables: Record<string, {
4597
- name: string;
4598
- columns: Record<string, {
4599
- isUnique?: any;
4600
- default?: any;
4601
- typeSchema?: string | undefined;
4602
- uniqueName?: string | undefined;
4603
- nullsNotDistinct?: boolean | undefined;
4604
- name: string;
4605
- type: string;
4606
- primaryKey: boolean;
4607
- notNull: boolean;
4608
- }>;
4609
- indexes: Record<string, {
4610
- name: string;
4611
- columns: string[];
4612
- isUnique: boolean;
4613
- }>;
4614
- foreignKeys: Record<string, {
4615
- onUpdate?: string | undefined;
4616
- onDelete?: string | undefined;
4617
- schemaTo?: string | undefined;
4618
- name: string;
4619
- tableFrom: string;
4620
- columnsFrom: string[];
4621
- tableTo: string;
4622
- columnsTo: string[];
4623
- }>;
4624
- schema: string;
4625
- compositePrimaryKeys: Record<string, {
4626
- name: string;
4627
- columns: string[];
4628
- }>;
4629
- uniqueConstraints: Record<string, {
4630
- name: string;
4631
- columns: string[];
4632
- nullsNotDistinct: boolean;
4633
- }>;
4634
- }>;
4635
- id: string;
4636
- prevId: string;
4637
- version: "6";
4638
- dialect: "postgresql";
4639
- schemas: Record<string, string>;
4640
- _meta: {
4641
- columns: Record<string, string>;
4642
- tables: Record<string, string>;
4643
- schemas: Record<string, string>;
4644
- };
4645
- enums: Record<string, {
4646
- name: string;
4647
- values: string[];
4648
- schema: string;
4649
- }>;
4650
- }, {
4651
- internal?: {
4652
- tables: Record<string, {
4653
- columns: Record<string, {
4654
- isArray?: boolean | undefined;
4655
- dimensions?: number | undefined;
4656
- rawType?: string | undefined;
4657
- } | undefined>;
4658
- } | undefined>;
4659
- } | undefined;
4660
- tables: Record<string, {
4661
- uniqueConstraints?: Record<string, {
4662
- name: string;
4663
- columns: string[];
4664
- nullsNotDistinct: boolean;
4665
- }> | undefined;
4666
- name: string;
4667
- columns: Record<string, {
4668
- isUnique?: any;
4669
- default?: any;
4670
- typeSchema?: string | undefined;
4671
- uniqueName?: string | undefined;
4672
- nullsNotDistinct?: boolean | undefined;
4673
- name: string;
4674
- type: string;
4675
- primaryKey: boolean;
4676
- notNull: boolean;
4677
- }>;
4678
- indexes: Record<string, {
4679
- name: string;
4680
- columns: string[];
4681
- isUnique: boolean;
4682
- }>;
4683
- foreignKeys: Record<string, {
4684
- onUpdate?: string | undefined;
4685
- onDelete?: string | undefined;
4686
- schemaTo?: string | undefined;
4687
- name: string;
4688
- tableFrom: string;
4689
- columnsFrom: string[];
4690
- tableTo: string;
4691
- columnsTo: string[];
4692
- }>;
4693
- schema: string;
4694
- compositePrimaryKeys: Record<string, {
4695
- name: string;
4696
- columns: string[];
4697
- }>;
4698
- }>;
4699
- id: string;
4700
- prevId: string;
4701
- version: "6";
4702
- dialect: "postgresql";
4703
- schemas: Record<string, string>;
4704
- _meta: {
4705
- columns: Record<string, string>;
4706
- tables: Record<string, string>;
4707
- schemas: Record<string, string>;
4708
- };
4709
- enums: Record<string, {
4710
- name: string;
4711
- values: string[];
4712
- schema: string;
4713
- }>;
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
- internal?: {
4729
- tables: Record<string, {
4730
- columns: Record<string, {
4731
- isArray?: boolean | undefined;
4732
- dimensions?: number | undefined;
4733
- rawType?: string | undefined;
4734
- } | undefined>;
4735
- } | undefined>;
4736
- } | undefined;
4737
- tables: Record<string, {
4738
- name: string;
4739
- columns: Record<string, {
4740
- isUnique?: any;
4741
- default?: any;
4742
- typeSchema?: string | undefined;
4743
- uniqueName?: string | undefined;
4744
- nullsNotDistinct?: boolean | undefined;
4745
- name: string;
4746
- type: string;
4747
- primaryKey: boolean;
4748
- notNull: boolean;
4749
- }>;
4750
- indexes: Record<string, {
4751
- name: string;
4752
- columns: string[];
4753
- isUnique: boolean;
4754
- }>;
4755
- foreignKeys: Record<string, {
4756
- onUpdate?: string | undefined;
4757
- onDelete?: string | undefined;
4758
- schemaTo?: string | undefined;
4759
- name: string;
4760
- tableFrom: string;
4761
- columnsFrom: string[];
4762
- tableTo: string;
4763
- columnsTo: string[];
4764
- }>;
4765
- schema: string;
4766
- compositePrimaryKeys: Record<string, {
4767
- name: string;
4768
- columns: string[];
4769
- }>;
4770
- uniqueConstraints: Record<string, {
4771
- name: string;
4772
- columns: string[];
4773
- nullsNotDistinct: boolean;
4774
- }>;
4775
- }>;
4776
- id: string;
4777
- prevId: string;
4778
- version: "6";
4779
- dialect: "postgresql";
4780
- schemas: Record<string, string>;
4781
- _meta: {
4782
- columns: Record<string, string>;
4783
- tables: Record<string, string>;
4784
- schemas: Record<string, string>;
4785
- };
4786
- enums: Record<string, {
4787
- name: string;
4788
- values: string[];
4789
- schema: string;
4790
- }>;
4791
- };
4792
- export {};