drizzle-kit 0.23.1 → 0.23.2-5be2712

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (11) hide show
  1. package/{readme.md → README.md} +1 -1
  2. package/{payload.d.mts → api.d.mts} +518 -518
  3. package/{payload.d.ts → api.d.ts} +518 -518
  4. package/{payload.js → api.js} +24530 -25190
  5. package/{payload.mjs → api.mjs} +24528 -25189
  6. package/bin.cjs +12252 -12775
  7. package/index.d.mts +14 -20
  8. package/index.d.ts +14 -20
  9. package/package.json +139 -115
  10. package/utils.js +20 -18
  11. package/utils.mjs +20 -26
package/{payload.d.ts → api.d.ts} RENAMED
@@ -1,179 +1,84 @@
1
+ import { LibSQLDatabase } from 'drizzle-orm/libsql';
2
+ import { MySql2Database } from 'drizzle-orm/mysql2';
1
3
  import { PgDatabase } from 'drizzle-orm/pg-core';
2
4
  import * as zod from 'zod';
3
5
  import { TypeOf } from 'zod';
4
- import { MySql2Database } from 'drizzle-orm/mysql2';
5
- import { LibSQLDatabase } from 'drizzle-orm/libsql';
6
6
 
7
- declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
8
- version: zod.ZodLiteral<"7">;
9
- dialect: zod.ZodLiteral<"postgresql">;
7
+ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
8
+ version: zod.ZodLiteral<"5">;
9
+ dialect: zod.ZodLiteral<"mysql">;
10
10
  tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
11
11
  name: zod.ZodString;
12
- schema: zod.ZodString;
13
12
  columns: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
14
13
  name: zod.ZodString;
15
14
  type: zod.ZodString;
16
- typeSchema: zod.ZodOptional<zod.ZodString>;
17
15
  primaryKey: zod.ZodBoolean;
18
16
  notNull: zod.ZodBoolean;
17
+ autoincrement: zod.ZodOptional<zod.ZodBoolean>;
19
18
  default: zod.ZodOptional<zod.ZodAny>;
20
- isUnique: zod.ZodOptional<zod.ZodAny>;
21
- uniqueName: zod.ZodOptional<zod.ZodString>;
22
- nullsNotDistinct: zod.ZodOptional<zod.ZodBoolean>;
19
+ onUpdate: zod.ZodOptional<zod.ZodAny>;
23
20
  generated: zod.ZodOptional<zod.ZodObject<{
24
- type: zod.ZodLiteral<"stored">;
21
+ type: zod.ZodEnum<["stored", "virtual"]>;
25
22
  as: zod.ZodString;
26
23
  }, "strip", zod.ZodTypeAny, {
27
- type: "stored";
24
+ type: "stored" | "virtual";
28
25
  as: string;
29
26
  }, {
30
- type: "stored";
27
+ type: "stored" | "virtual";
31
28
  as: string;
32
29
  }>>;
33
- identity: zod.ZodOptional<zod.ZodObject<zod.objectUtil.extendShape<{
34
- name: zod.ZodString;
35
- increment: zod.ZodOptional<zod.ZodString>;
36
- minValue: zod.ZodOptional<zod.ZodString>;
37
- maxValue: zod.ZodOptional<zod.ZodString>;
38
- startWith: zod.ZodOptional<zod.ZodString>;
39
- cache: zod.ZodOptional<zod.ZodString>;
40
- cycle: zod.ZodOptional<zod.ZodBoolean>;
41
- schema: zod.ZodString;
42
- }, {
43
- type: zod.ZodEnum<["always", "byDefault"]>;
44
- }>, "strip", zod.ZodTypeAny, {
45
- name: string;
46
- type: "always" | "byDefault";
47
- schema: string;
48
- increment?: string | undefined;
49
- minValue?: string | undefined;
50
- maxValue?: string | undefined;
51
- startWith?: string | undefined;
52
- cache?: string | undefined;
53
- cycle?: boolean | undefined;
54
- }, {
55
- name: string;
56
- type: "always" | "byDefault";
57
- schema: string;
58
- increment?: string | undefined;
59
- minValue?: string | undefined;
60
- maxValue?: string | undefined;
61
- startWith?: string | undefined;
62
- cache?: string | undefined;
63
- cycle?: boolean | undefined;
64
- }>>;
65
30
  }, "strict", zod.ZodTypeAny, {
66
31
  name: string;
67
32
  type: string;
68
33
  primaryKey: boolean;
69
34
  notNull: boolean;
70
- isUnique?: any;
71
35
  default?: any;
36
+ onUpdate?: any;
37
+ autoincrement?: boolean | undefined;
72
38
  generated?: {
73
- type: "stored";
39
+ type: "stored" | "virtual";
74
40
  as: string;
75
41
  } | undefined;
76
- typeSchema?: string | undefined;
77
- uniqueName?: string | undefined;
78
- nullsNotDistinct?: boolean | undefined;
79
- identity?: {
80
- name: string;
81
- type: "always" | "byDefault";
82
- schema: string;
83
- increment?: string | undefined;
84
- minValue?: string | undefined;
85
- maxValue?: string | undefined;
86
- startWith?: string | undefined;
87
- cache?: string | undefined;
88
- cycle?: boolean | undefined;
89
- } | undefined;
90
42
  }, {
91
43
  name: string;
92
44
  type: string;
93
45
  primaryKey: boolean;
94
46
  notNull: boolean;
95
- isUnique?: any;
96
47
  default?: any;
48
+ onUpdate?: any;
49
+ autoincrement?: boolean | undefined;
97
50
  generated?: {
98
- type: "stored";
51
+ type: "stored" | "virtual";
99
52
  as: string;
100
53
  } | undefined;
101
- typeSchema?: string | undefined;
102
- uniqueName?: string | undefined;
103
- nullsNotDistinct?: boolean | undefined;
104
- identity?: {
105
- name: string;
106
- type: "always" | "byDefault";
107
- schema: string;
108
- increment?: string | undefined;
109
- minValue?: string | undefined;
110
- maxValue?: string | undefined;
111
- startWith?: string | undefined;
112
- cache?: string | undefined;
113
- cycle?: boolean | undefined;
114
- } | undefined;
115
54
  }>>;
116
55
  indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
117
56
  name: zod.ZodString;
118
- columns: zod.ZodArray<zod.ZodObject<{
119
- expression: zod.ZodString;
120
- isExpression: zod.ZodBoolean;
121
- asc: zod.ZodBoolean;
122
- nulls: zod.ZodOptional<zod.ZodString>;
123
- opclass: zod.ZodOptional<zod.ZodString>;
124
- }, "strip", zod.ZodTypeAny, {
125
- isExpression: boolean;
126
- expression: string;
127
- asc: boolean;
128
- nulls?: string | undefined;
129
- opclass?: string | undefined;
130
- }, {
131
- isExpression: boolean;
132
- expression: string;
133
- asc: boolean;
134
- nulls?: string | undefined;
135
- opclass?: string | undefined;
136
- }>, "many">;
57
+ columns: zod.ZodArray<zod.ZodString, "many">;
137
58
  isUnique: zod.ZodBoolean;
138
- with: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodAny>>;
139
- method: zod.ZodDefault<zod.ZodString>;
140
- where: zod.ZodOptional<zod.ZodString>;
141
- concurrently: zod.ZodDefault<zod.ZodBoolean>;
59
+ using: zod.ZodOptional<zod.ZodEnum<["btree", "hash"]>>;
60
+ algorithm: zod.ZodOptional<zod.ZodEnum<["default", "inplace", "copy"]>>;
61
+ lock: zod.ZodOptional<zod.ZodEnum<["default", "none", "shared", "exclusive"]>>;
142
62
  }, "strict", zod.ZodTypeAny, {
143
63
  name: string;
144
- columns: {
145
- isExpression: boolean;
146
- expression: string;
147
- asc: boolean;
148
- nulls?: string | undefined;
149
- opclass?: string | undefined;
150
- }[];
64
+ columns: string[];
151
65
  isUnique: boolean;
152
- method: string;
153
- concurrently: boolean;
154
- with?: Record<string, any> | undefined;
155
- where?: string | undefined;
66
+ using?: "btree" | "hash" | undefined;
67
+ algorithm?: "default" | "inplace" | "copy" | undefined;
68
+ lock?: "none" | "default" | "shared" | "exclusive" | undefined;
156
69
  }, {
157
70
  name: string;
158
- columns: {
159
- isExpression: boolean;
160
- expression: string;
161
- asc: boolean;
162
- nulls?: string | undefined;
163
- opclass?: string | undefined;
164
- }[];
71
+ columns: string[];
165
72
  isUnique: boolean;
166
- with?: Record<string, any> | undefined;
167
- method?: string | undefined;
168
- where?: string | undefined;
169
- concurrently?: boolean | undefined;
73
+ using?: "btree" | "hash" | undefined;
74
+ algorithm?: "default" | "inplace" | "copy" | undefined;
75
+ lock?: "none" | "default" | "shared" | "exclusive" | undefined;
170
76
  }>>;
171
77
  foreignKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
172
78
  name: zod.ZodString;
173
79
  tableFrom: zod.ZodString;
174
80
  columnsFrom: zod.ZodArray<zod.ZodString, "many">;
175
81
  tableTo: zod.ZodString;
176
- schemaTo: zod.ZodOptional<zod.ZodString>;
177
82
  columnsTo: zod.ZodArray<zod.ZodString, "many">;
178
83
  onUpdate: zod.ZodOptional<zod.ZodString>;
179
84
  onDelete: zod.ZodOptional<zod.ZodString>;
@@ -185,7 +90,6 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
185
90
  columnsTo: string[];
186
91
  onUpdate?: string | undefined;
187
92
  onDelete?: string | undefined;
188
- schemaTo?: string | undefined;
189
93
  }, {
190
94
  name: string;
191
95
  tableFrom: string;
@@ -194,7 +98,6 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
194
98
  columnsTo: string[];
195
99
  onUpdate?: string | undefined;
196
100
  onDelete?: string | undefined;
197
- schemaTo?: string | undefined;
198
101
  }>>;
199
102
  compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
200
103
  name: zod.ZodString;
@@ -209,15 +112,12 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
209
112
  uniqueConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
210
113
  name: zod.ZodString;
211
114
  columns: zod.ZodArray<zod.ZodString, "many">;
212
- nullsNotDistinct: zod.ZodBoolean;
213
115
  }, "strict", zod.ZodTypeAny, {
214
116
  name: string;
215
117
  columns: string[];
216
- nullsNotDistinct: boolean;
217
118
  }, {
218
119
  name: string;
219
120
  columns: string[];
220
- nullsNotDistinct: boolean;
221
121
  }>>>;
222
122
  }, "strict", zod.ZodTypeAny, {
223
123
  name: string;
@@ -226,41 +126,21 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
226
126
  type: string;
227
127
  primaryKey: boolean;
228
128
  notNull: boolean;
229
- isUnique?: any;
230
129
  default?: any;
130
+ onUpdate?: any;
131
+ autoincrement?: boolean | undefined;
231
132
  generated?: {
232
- type: "stored";
133
+ type: "stored" | "virtual";
233
134
  as: string;
234
135
  } | undefined;
235
- typeSchema?: string | undefined;
236
- uniqueName?: string | undefined;
237
- nullsNotDistinct?: boolean | undefined;
238
- identity?: {
239
- name: string;
240
- type: "always" | "byDefault";
241
- schema: string;
242
- increment?: string | undefined;
243
- minValue?: string | undefined;
244
- maxValue?: string | undefined;
245
- startWith?: string | undefined;
246
- cache?: string | undefined;
247
- cycle?: boolean | undefined;
248
- } | undefined;
249
136
  }>;
250
137
  indexes: Record<string, {
251
138
  name: string;
252
- columns: {
253
- isExpression: boolean;
254
- expression: string;
255
- asc: boolean;
256
- nulls?: string | undefined;
257
- opclass?: string | undefined;
258
- }[];
139
+ columns: string[];
259
140
  isUnique: boolean;
260
- method: string;
261
- concurrently: boolean;
262
- with?: Record<string, any> | undefined;
263
- where?: string | undefined;
141
+ using?: "btree" | "hash" | undefined;
142
+ algorithm?: "default" | "inplace" | "copy" | undefined;
143
+ lock?: "none" | "default" | "shared" | "exclusive" | undefined;
264
144
  }>;
265
145
  foreignKeys: Record<string, {
266
146
  name: string;
@@ -270,9 +150,7 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
270
150
  columnsTo: string[];
271
151
  onUpdate?: string | undefined;
272
152
  onDelete?: string | undefined;
273
- schemaTo?: string | undefined;
274
153
  }>;
275
- schema: string;
276
154
  compositePrimaryKeys: Record<string, {
277
155
  name: string;
278
156
  columns: string[];
@@ -280,7 +158,6 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
280
158
  uniqueConstraints: Record<string, {
281
159
  name: string;
282
160
  columns: string[];
283
- nullsNotDistinct: boolean;
284
161
  }>;
285
162
  }, {
286
163
  name: string;
@@ -289,41 +166,21 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
289
166
  type: string;
290
167
  primaryKey: boolean;
291
168
  notNull: boolean;
292
- isUnique?: any;
293
169
  default?: any;
170
+ onUpdate?: any;
171
+ autoincrement?: boolean | undefined;
294
172
  generated?: {
295
- type: "stored";
173
+ type: "stored" | "virtual";
296
174
  as: string;
297
175
  } | undefined;
298
- typeSchema?: string | undefined;
299
- uniqueName?: string | undefined;
300
- nullsNotDistinct?: boolean | undefined;
301
- identity?: {
302
- name: string;
303
- type: "always" | "byDefault";
304
- schema: string;
305
- increment?: string | undefined;
306
- minValue?: string | undefined;
307
- maxValue?: string | undefined;
308
- startWith?: string | undefined;
309
- cache?: string | undefined;
310
- cycle?: boolean | undefined;
311
- } | undefined;
312
176
  }>;
313
177
  indexes: Record<string, {
314
178
  name: string;
315
- columns: {
316
- isExpression: boolean;
317
- expression: string;
318
- asc: boolean;
319
- nulls?: string | undefined;
320
- opclass?: string | undefined;
321
- }[];
179
+ columns: string[];
322
180
  isUnique: boolean;
323
- with?: Record<string, any> | undefined;
324
- method?: string | undefined;
325
- where?: string | undefined;
326
- concurrently?: boolean | undefined;
181
+ using?: "btree" | "hash" | undefined;
182
+ algorithm?: "default" | "inplace" | "copy" | undefined;
183
+ lock?: "none" | "default" | "shared" | "exclusive" | undefined;
327
184
  }>;
328
185
  foreignKeys: Record<string, {
329
186
  name: string;
@@ -333,9 +190,7 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
333
190
  columnsTo: string[];
334
191
  onUpdate?: string | undefined;
335
192
  onDelete?: string | undefined;
336
- schemaTo?: string | undefined;
337
193
  }>;
338
- schema: string;
339
194
  compositePrimaryKeys: Record<string, {
340
195
  name: string;
341
196
  columns: string[];
@@ -343,108 +198,75 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
343
198
  uniqueConstraints?: Record<string, {
344
199
  name: string;
345
200
  columns: string[];
346
- nullsNotDistinct: boolean;
347
201
  }> | undefined;
348
202
  }>>;
349
- enums: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
350
- name: zod.ZodString;
351
- schema: zod.ZodString;
352
- values: zod.ZodArray<zod.ZodString, "many">;
353
- }, "strict", zod.ZodTypeAny, {
354
- name: string;
355
- values: string[];
356
- schema: string;
357
- }, {
358
- name: string;
359
- values: string[];
360
- schema: string;
361
- }>>;
362
- schemas: zod.ZodRecord<zod.ZodString, zod.ZodString>;
363
- sequences: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
364
- name: zod.ZodString;
365
- increment: zod.ZodOptional<zod.ZodString>;
366
- minValue: zod.ZodOptional<zod.ZodString>;
367
- maxValue: zod.ZodOptional<zod.ZodString>;
368
- startWith: zod.ZodOptional<zod.ZodString>;
369
- cache: zod.ZodOptional<zod.ZodString>;
370
- cycle: zod.ZodOptional<zod.ZodBoolean>;
371
- schema: zod.ZodString;
372
- }, "strict", zod.ZodTypeAny, {
373
- name: string;
374
- schema: string;
375
- increment?: string | undefined;
376
- minValue?: string | undefined;
377
- maxValue?: string | undefined;
378
- startWith?: string | undefined;
379
- cache?: string | undefined;
380
- cycle?: boolean | undefined;
381
- }, {
382
- name: string;
383
- schema: string;
384
- increment?: string | undefined;
385
- minValue?: string | undefined;
386
- maxValue?: string | undefined;
387
- startWith?: string | undefined;
388
- cache?: string | undefined;
389
- cycle?: boolean | undefined;
390
- }>>>;
391
- _meta: zod.ZodObject<{
392
- schemas: zod.ZodRecord<zod.ZodString, zod.ZodString>;
393
- tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
394
- columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
395
- }, "strip", zod.ZodTypeAny, {
396
- columns: Record<string, string>;
397
- tables: Record<string, string>;
398
- schemas: Record<string, string>;
203
+ _meta: zod.ZodObject<{
204
+ tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
205
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
206
+ }, "strip", zod.ZodTypeAny, {
207
+ columns: Record<string, string>;
208
+ tables: Record<string, string>;
399
209
  }, {
400
210
  columns: Record<string, string>;
401
211
  tables: Record<string, string>;
402
- schemas: Record<string, string>;
403
212
  }>;
404
213
  internal: zod.ZodOptional<zod.ZodObject<{
405
- tables: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
214
+ tables: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
406
215
  columns: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
407
- isArray: zod.ZodOptional<zod.ZodBoolean>;
408
- dimensions: zod.ZodOptional<zod.ZodNumber>;
409
- rawType: zod.ZodOptional<zod.ZodString>;
216
+ isDefaultAnExpression: zod.ZodOptional<zod.ZodBoolean>;
410
217
  }, "strip", zod.ZodTypeAny, {
411
- isArray?: boolean | undefined;
412
- dimensions?: number | undefined;
413
- rawType?: string | undefined;
218
+ isDefaultAnExpression?: boolean | undefined;
414
219
  }, {
415
- isArray?: boolean | undefined;
416
- dimensions?: number | undefined;
417
- rawType?: string | undefined;
220
+ isDefaultAnExpression?: boolean | undefined;
418
221
  }>>>;
419
222
  }, "strip", zod.ZodTypeAny, {
420
223
  columns: Record<string, {
421
- isArray?: boolean | undefined;
422
- dimensions?: number | undefined;
423
- rawType?: string | undefined;
224
+ isDefaultAnExpression?: boolean | undefined;
424
225
  } | undefined>;
425
226
  }, {
426
227
  columns: Record<string, {
427
- isArray?: boolean | undefined;
428
- dimensions?: number | undefined;
429
- rawType?: string | undefined;
228
+ isDefaultAnExpression?: boolean | undefined;
430
229
  } | undefined>;
431
- }>>>;
230
+ }>>>>;
231
+ indexes: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
232
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
233
+ isExpression: zod.ZodOptional<zod.ZodBoolean>;
234
+ }, "strip", zod.ZodTypeAny, {
235
+ isExpression?: boolean | undefined;
236
+ }, {
237
+ isExpression?: boolean | undefined;
238
+ }>>>;
239
+ }, "strip", zod.ZodTypeAny, {
240
+ columns: Record<string, {
241
+ isExpression?: boolean | undefined;
242
+ } | undefined>;
243
+ }, {
244
+ columns: Record<string, {
245
+ isExpression?: boolean | undefined;
246
+ } | undefined>;
247
+ }>>>>;
432
248
  }, "strip", zod.ZodTypeAny, {
433
- tables: Record<string, {
249
+ indexes?: Record<string, {
434
250
  columns: Record<string, {
435
- isArray?: boolean | undefined;
436
- dimensions?: number | undefined;
437
- rawType?: string | undefined;
251
+ isExpression?: boolean | undefined;
438
252
  } | undefined>;
439
- } | undefined>;
253
+ } | undefined> | undefined;
254
+ tables?: Record<string, {
255
+ columns: Record<string, {
256
+ isDefaultAnExpression?: boolean | undefined;
257
+ } | undefined>;
258
+ } | undefined> | undefined;
440
259
  }, {
441
- tables: Record<string, {
260
+ indexes?: Record<string, {
442
261
  columns: Record<string, {
443
- isArray?: boolean | undefined;
444
- dimensions?: number | undefined;
445
- rawType?: string | undefined;
262
+ isExpression?: boolean | undefined;
446
263
  } | undefined>;
447
- } | undefined>;
264
+ } | undefined> | undefined;
265
+ tables?: Record<string, {
266
+ columns: Record<string, {
267
+ isDefaultAnExpression?: boolean | undefined;
268
+ } | undefined>;
269
+ } | undefined> | undefined;
448
270
  }>>;
449
271
  }, {
450
272
  id: zod.ZodString;
@@ -457,41 +279,21 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
457
279
  type: string;
458
280
  primaryKey: boolean;
459
281
  notNull: boolean;
460
- isUnique?: any;
461
282
  default?: any;
283
+ onUpdate?: any;
284
+ autoincrement?: boolean | undefined;
462
285
  generated?: {
463
- type: "stored";
286
+ type: "stored" | "virtual";
464
287
  as: string;
465
288
  } | undefined;
466
- typeSchema?: string | undefined;
467
- uniqueName?: string | undefined;
468
- nullsNotDistinct?: boolean | undefined;
469
- identity?: {
470
- name: string;
471
- type: "always" | "byDefault";
472
- schema: string;
473
- increment?: string | undefined;
474
- minValue?: string | undefined;
475
- maxValue?: string | undefined;
476
- startWith?: string | undefined;
477
- cache?: string | undefined;
478
- cycle?: boolean | undefined;
479
- } | undefined;
480
289
  }>;
481
290
  indexes: Record<string, {
482
291
  name: string;
483
- columns: {
484
- isExpression: boolean;
485
- expression: string;
486
- asc: boolean;
487
- nulls?: string | undefined;
488
- opclass?: string | undefined;
489
- }[];
292
+ columns: string[];
490
293
  isUnique: boolean;
491
- method: string;
492
- concurrently: boolean;
493
- with?: Record<string, any> | undefined;
494
- where?: string | undefined;
294
+ using?: "btree" | "hash" | undefined;
295
+ algorithm?: "default" | "inplace" | "copy" | undefined;
296
+ lock?: "none" | "default" | "shared" | "exclusive" | undefined;
495
297
  }>;
496
298
  foreignKeys: Record<string, {
497
299
  name: string;
@@ -501,9 +303,7 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
501
303
  columnsTo: string[];
502
304
  onUpdate?: string | undefined;
503
305
  onDelete?: string | undefined;
504
- schemaTo?: string | undefined;
505
306
  }>;
506
- schema: string;
507
307
  compositePrimaryKeys: Record<string, {
508
308
  name: string;
509
309
  columns: string[];
@@ -511,42 +311,27 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
511
311
  uniqueConstraints: Record<string, {
512
312
  name: string;
513
313
  columns: string[];
514
- nullsNotDistinct: boolean;
515
314
  }>;
516
315
  }>;
517
316
  id: string;
518
317
  prevId: string;
519
- version: "7";
520
- dialect: "postgresql";
521
- schemas: Record<string, string>;
318
+ version: "5";
319
+ dialect: "mysql";
522
320
  _meta: {
523
321
  columns: Record<string, string>;
524
322
  tables: Record<string, string>;
525
- schemas: Record<string, string>;
526
323
  };
527
- enums: Record<string, {
528
- name: string;
529
- values: string[];
530
- schema: string;
531
- }>;
532
- sequences: Record<string, {
533
- name: string;
534
- schema: string;
535
- increment?: string | undefined;
536
- minValue?: string | undefined;
537
- maxValue?: string | undefined;
538
- startWith?: string | undefined;
539
- cache?: string | undefined;
540
- cycle?: boolean | undefined;
541
- }>;
542
324
  internal?: {
543
- tables: Record<string, {
325
+ indexes?: Record<string, {
544
326
  columns: Record<string, {
545
- isArray?: boolean | undefined;
546
- dimensions?: number | undefined;
547
- rawType?: string | undefined;
327
+ isExpression?: boolean | undefined;
548
328
  } | undefined>;
549
- } | undefined>;
329
+ } | undefined> | undefined;
330
+ tables?: Record<string, {
331
+ columns: Record<string, {
332
+ isDefaultAnExpression?: boolean | undefined;
333
+ } | undefined>;
334
+ } | undefined> | undefined;
550
335
  } | undefined;
551
336
  }, {
552
337
  tables: Record<string, {
@@ -556,41 +341,21 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
556
341
  type: string;
557
342
  primaryKey: boolean;
558
343
  notNull: boolean;
559
- isUnique?: any;
560
344
  default?: any;
345
+ onUpdate?: any;
346
+ autoincrement?: boolean | undefined;
561
347
  generated?: {
562
- type: "stored";
348
+ type: "stored" | "virtual";
563
349
  as: string;
564
350
  } | undefined;
565
- typeSchema?: string | undefined;
566
- uniqueName?: string | undefined;
567
- nullsNotDistinct?: boolean | undefined;
568
- identity?: {
569
- name: string;
570
- type: "always" | "byDefault";
571
- schema: string;
572
- increment?: string | undefined;
573
- minValue?: string | undefined;
574
- maxValue?: string | undefined;
575
- startWith?: string | undefined;
576
- cache?: string | undefined;
577
- cycle?: boolean | undefined;
578
- } | undefined;
579
351
  }>;
580
352
  indexes: Record<string, {
581
353
  name: string;
582
- columns: {
583
- isExpression: boolean;
584
- expression: string;
585
- asc: boolean;
586
- nulls?: string | undefined;
587
- opclass?: string | undefined;
588
- }[];
354
+ columns: string[];
589
355
  isUnique: boolean;
590
- with?: Record<string, any> | undefined;
591
- method?: string | undefined;
592
- where?: string | undefined;
593
- concurrently?: boolean | undefined;
356
+ using?: "btree" | "hash" | undefined;
357
+ algorithm?: "default" | "inplace" | "copy" | undefined;
358
+ lock?: "none" | "default" | "shared" | "exclusive" | undefined;
594
359
  }>;
595
360
  foreignKeys: Record<string, {
596
361
  name: string;
@@ -600,9 +365,7 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
600
365
  columnsTo: string[];
601
366
  onUpdate?: string | undefined;
602
367
  onDelete?: string | undefined;
603
- schemaTo?: string | undefined;
604
368
  }>;
605
- schema: string;
606
369
  compositePrimaryKeys: Record<string, {
607
370
  name: string;
608
371
  columns: string[];
@@ -610,112 +373,201 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
610
373
  uniqueConstraints?: Record<string, {
611
374
  name: string;
612
375
  columns: string[];
613
- nullsNotDistinct: boolean;
614
376
  }> | undefined;
615
377
  }>;
616
378
  id: string;
617
379
  prevId: string;
618
- version: "7";
619
- dialect: "postgresql";
620
- schemas: Record<string, string>;
380
+ version: "5";
381
+ dialect: "mysql";
621
382
  _meta: {
622
383
  columns: Record<string, string>;
623
384
  tables: Record<string, string>;
624
- schemas: Record<string, string>;
625
385
  };
626
- enums: Record<string, {
627
- name: string;
628
- values: string[];
629
- schema: string;
630
- }>;
631
386
  internal?: {
632
- tables: Record<string, {
387
+ indexes?: Record<string, {
633
388
  columns: Record<string, {
634
- isArray?: boolean | undefined;
635
- dimensions?: number | undefined;
636
- rawType?: string | undefined;
389
+ isExpression?: boolean | undefined;
637
390
  } | undefined>;
638
- } | undefined>;
391
+ } | undefined> | undefined;
392
+ tables?: Record<string, {
393
+ columns: Record<string, {
394
+ isDefaultAnExpression?: boolean | undefined;
395
+ } | undefined>;
396
+ } | undefined> | undefined;
639
397
  } | undefined;
640
- sequences?: Record<string, {
641
- name: string;
642
- schema: string;
643
- increment?: string | undefined;
644
- minValue?: string | undefined;
645
- maxValue?: string | undefined;
646
- startWith?: string | undefined;
647
- cache?: string | undefined;
648
- cycle?: boolean | undefined;
649
- }> | undefined;
650
398
  }>;
651
- type PgSchema = TypeOf<typeof pgSchema>;
399
+ type MySqlSchema = TypeOf<typeof schema$1>;
652
400
 
653
- declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
654
- version: zod.ZodLiteral<"6">;
655
- dialect: zod.ZodEnum<["sqlite"]>;
401
+ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
402
+ version: zod.ZodLiteral<"7">;
403
+ dialect: zod.ZodLiteral<"postgresql">;
656
404
  tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
657
405
  name: zod.ZodString;
406
+ schema: zod.ZodString;
658
407
  columns: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
659
408
  name: zod.ZodString;
660
409
  type: zod.ZodString;
410
+ typeSchema: zod.ZodOptional<zod.ZodString>;
661
411
  primaryKey: zod.ZodBoolean;
662
412
  notNull: zod.ZodBoolean;
663
- autoincrement: zod.ZodOptional<zod.ZodBoolean>;
664
413
  default: zod.ZodOptional<zod.ZodAny>;
414
+ isUnique: zod.ZodOptional<zod.ZodAny>;
415
+ uniqueName: zod.ZodOptional<zod.ZodString>;
416
+ nullsNotDistinct: zod.ZodOptional<zod.ZodBoolean>;
665
417
  generated: zod.ZodOptional<zod.ZodObject<{
666
- type: zod.ZodEnum<["stored", "virtual"]>;
418
+ type: zod.ZodLiteral<"stored">;
667
419
  as: zod.ZodString;
668
420
  }, "strip", zod.ZodTypeAny, {
669
- type: "stored" | "virtual";
421
+ type: "stored";
422
+ as: string;
423
+ }, {
424
+ type: "stored";
670
425
  as: string;
426
+ }>>;
427
+ identity: zod.ZodOptional<zod.ZodObject<zod.objectUtil.extendShape<{
428
+ name: zod.ZodString;
429
+ increment: zod.ZodOptional<zod.ZodString>;
430
+ minValue: zod.ZodOptional<zod.ZodString>;
431
+ maxValue: zod.ZodOptional<zod.ZodString>;
432
+ startWith: zod.ZodOptional<zod.ZodString>;
433
+ cache: zod.ZodOptional<zod.ZodString>;
434
+ cycle: zod.ZodOptional<zod.ZodBoolean>;
435
+ schema: zod.ZodString;
671
436
  }, {
672
- type: "stored" | "virtual";
673
- as: string;
437
+ type: zod.ZodEnum<["always", "byDefault"]>;
438
+ }>, "strip", zod.ZodTypeAny, {
439
+ name: string;
440
+ type: "always" | "byDefault";
441
+ schema: string;
442
+ increment?: string | undefined;
443
+ minValue?: string | undefined;
444
+ maxValue?: string | undefined;
445
+ startWith?: string | undefined;
446
+ cache?: string | undefined;
447
+ cycle?: boolean | undefined;
448
+ }, {
449
+ name: string;
450
+ type: "always" | "byDefault";
451
+ schema: string;
452
+ increment?: string | undefined;
453
+ minValue?: string | undefined;
454
+ maxValue?: string | undefined;
455
+ startWith?: string | undefined;
456
+ cache?: string | undefined;
457
+ cycle?: boolean | undefined;
674
458
  }>>;
675
459
  }, "strict", zod.ZodTypeAny, {
676
460
  name: string;
677
461
  type: string;
678
462
  primaryKey: boolean;
679
463
  notNull: boolean;
464
+ isUnique?: any;
680
465
  default?: any;
681
- autoincrement?: boolean | undefined;
682
466
  generated?: {
683
- type: "stored" | "virtual";
467
+ type: "stored";
684
468
  as: string;
685
469
  } | undefined;
470
+ typeSchema?: string | undefined;
471
+ uniqueName?: string | undefined;
472
+ nullsNotDistinct?: boolean | undefined;
473
+ identity?: {
474
+ name: string;
475
+ type: "always" | "byDefault";
476
+ schema: string;
477
+ increment?: string | undefined;
478
+ minValue?: string | undefined;
479
+ maxValue?: string | undefined;
480
+ startWith?: string | undefined;
481
+ cache?: string | undefined;
482
+ cycle?: boolean | undefined;
483
+ } | undefined;
686
484
  }, {
687
485
  name: string;
688
486
  type: string;
689
487
  primaryKey: boolean;
690
488
  notNull: boolean;
489
+ isUnique?: any;
691
490
  default?: any;
692
- autoincrement?: boolean | undefined;
693
491
  generated?: {
694
- type: "stored" | "virtual";
492
+ type: "stored";
695
493
  as: string;
696
494
  } | undefined;
495
+ typeSchema?: string | undefined;
496
+ uniqueName?: string | undefined;
497
+ nullsNotDistinct?: boolean | undefined;
498
+ identity?: {
499
+ name: string;
500
+ type: "always" | "byDefault";
501
+ schema: string;
502
+ increment?: string | undefined;
503
+ minValue?: string | undefined;
504
+ maxValue?: string | undefined;
505
+ startWith?: string | undefined;
506
+ cache?: string | undefined;
507
+ cycle?: boolean | undefined;
508
+ } | undefined;
697
509
  }>>;
698
510
  indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
699
511
  name: zod.ZodString;
700
- columns: zod.ZodArray<zod.ZodString, "many">;
701
- where: zod.ZodOptional<zod.ZodString>;
512
+ columns: zod.ZodArray<zod.ZodObject<{
513
+ expression: zod.ZodString;
514
+ isExpression: zod.ZodBoolean;
515
+ asc: zod.ZodBoolean;
516
+ nulls: zod.ZodOptional<zod.ZodString>;
517
+ opclass: zod.ZodOptional<zod.ZodString>;
518
+ }, "strip", zod.ZodTypeAny, {
519
+ isExpression: boolean;
520
+ expression: string;
521
+ asc: boolean;
522
+ nulls?: string | undefined;
523
+ opclass?: string | undefined;
524
+ }, {
525
+ isExpression: boolean;
526
+ expression: string;
527
+ asc: boolean;
528
+ nulls?: string | undefined;
529
+ opclass?: string | undefined;
530
+ }>, "many">;
702
531
  isUnique: zod.ZodBoolean;
532
+ with: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodAny>>;
533
+ method: zod.ZodDefault<zod.ZodString>;
534
+ where: zod.ZodOptional<zod.ZodString>;
535
+ concurrently: zod.ZodDefault<zod.ZodBoolean>;
703
536
  }, "strict", zod.ZodTypeAny, {
704
537
  name: string;
705
- columns: string[];
538
+ columns: {
539
+ isExpression: boolean;
540
+ expression: string;
541
+ asc: boolean;
542
+ nulls?: string | undefined;
543
+ opclass?: string | undefined;
544
+ }[];
706
545
  isUnique: boolean;
546
+ method: string;
547
+ concurrently: boolean;
548
+ with?: Record<string, any> | undefined;
707
549
  where?: string | undefined;
708
550
  }, {
709
551
  name: string;
710
- columns: string[];
552
+ columns: {
553
+ isExpression: boolean;
554
+ expression: string;
555
+ asc: boolean;
556
+ nulls?: string | undefined;
557
+ opclass?: string | undefined;
558
+ }[];
711
559
  isUnique: boolean;
560
+ with?: Record<string, any> | undefined;
561
+ method?: string | undefined;
712
562
  where?: string | undefined;
563
+ concurrently?: boolean | undefined;
713
564
  }>>;
714
565
  foreignKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
715
566
  name: zod.ZodString;
716
567
  tableFrom: zod.ZodString;
717
568
  columnsFrom: zod.ZodArray<zod.ZodString, "many">;
718
569
  tableTo: zod.ZodString;
570
+ schemaTo: zod.ZodOptional<zod.ZodString>;
719
571
  columnsTo: zod.ZodArray<zod.ZodString, "many">;
720
572
  onUpdate: zod.ZodOptional<zod.ZodString>;
721
573
  onDelete: zod.ZodOptional<zod.ZodString>;
@@ -727,6 +579,7 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
727
579
  columnsTo: string[];
728
580
  onUpdate?: string | undefined;
729
581
  onDelete?: string | undefined;
582
+ schemaTo?: string | undefined;
730
583
  }, {
731
584
  name: string;
732
585
  tableFrom: string;
@@ -735,26 +588,30 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
735
588
  columnsTo: string[];
736
589
  onUpdate?: string | undefined;
737
590
  onDelete?: string | undefined;
591
+ schemaTo?: string | undefined;
738
592
  }>>;
739
593
  compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
594
+ name: zod.ZodString;
740
595
  columns: zod.ZodArray<zod.ZodString, "many">;
741
- name: zod.ZodOptional<zod.ZodString>;
742
596
  }, "strict", zod.ZodTypeAny, {
597
+ name: string;
743
598
  columns: string[];
744
- name?: string | undefined;
745
599
  }, {
600
+ name: string;
746
601
  columns: string[];
747
- name?: string | undefined;
748
602
  }>>;
749
603
  uniqueConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
750
604
  name: zod.ZodString;
751
605
  columns: zod.ZodArray<zod.ZodString, "many">;
606
+ nullsNotDistinct: zod.ZodBoolean;
752
607
  }, "strict", zod.ZodTypeAny, {
753
608
  name: string;
754
609
  columns: string[];
610
+ nullsNotDistinct: boolean;
755
611
  }, {
756
612
  name: string;
757
613
  columns: string[];
614
+ nullsNotDistinct: boolean;
758
615
  }>>>;
759
616
  }, "strict", zod.ZodTypeAny, {
760
617
  name: string;
@@ -763,17 +620,40 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
763
620
  type: string;
764
621
  primaryKey: boolean;
765
622
  notNull: boolean;
623
+ isUnique?: any;
766
624
  default?: any;
767
- autoincrement?: boolean | undefined;
768
625
  generated?: {
769
- type: "stored" | "virtual";
626
+ type: "stored";
770
627
  as: string;
771
628
  } | undefined;
629
+ typeSchema?: string | undefined;
630
+ uniqueName?: string | undefined;
631
+ nullsNotDistinct?: boolean | undefined;
632
+ identity?: {
633
+ name: string;
634
+ type: "always" | "byDefault";
635
+ schema: string;
636
+ increment?: string | undefined;
637
+ minValue?: string | undefined;
638
+ maxValue?: string | undefined;
639
+ startWith?: string | undefined;
640
+ cache?: string | undefined;
641
+ cycle?: boolean | undefined;
642
+ } | undefined;
772
643
  }>;
773
644
  indexes: Record<string, {
774
645
  name: string;
775
- columns: string[];
646
+ columns: {
647
+ isExpression: boolean;
648
+ expression: string;
649
+ asc: boolean;
650
+ nulls?: string | undefined;
651
+ opclass?: string | undefined;
652
+ }[];
776
653
  isUnique: boolean;
654
+ method: string;
655
+ concurrently: boolean;
656
+ with?: Record<string, any> | undefined;
777
657
  where?: string | undefined;
778
658
  }>;
779
659
  foreignKeys: Record<string, {
@@ -784,14 +664,17 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
784
664
  columnsTo: string[];
785
665
  onUpdate?: string | undefined;
786
666
  onDelete?: string | undefined;
667
+ schemaTo?: string | undefined;
787
668
  }>;
669
+ schema: string;
788
670
  compositePrimaryKeys: Record<string, {
671
+ name: string;
789
672
  columns: string[];
790
- name?: string | undefined;
791
673
  }>;
792
674
  uniqueConstraints: Record<string, {
793
675
  name: string;
794
676
  columns: string[];
677
+ nullsNotDistinct: boolean;
795
678
  }>;
796
679
  }, {
797
680
  name: string;
@@ -800,18 +683,41 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
800
683
  type: string;
801
684
  primaryKey: boolean;
802
685
  notNull: boolean;
686
+ isUnique?: any;
803
687
  default?: any;
804
- autoincrement?: boolean | undefined;
805
688
  generated?: {
806
- type: "stored" | "virtual";
689
+ type: "stored";
807
690
  as: string;
808
691
  } | undefined;
692
+ typeSchema?: string | undefined;
693
+ uniqueName?: string | undefined;
694
+ nullsNotDistinct?: boolean | undefined;
695
+ identity?: {
696
+ name: string;
697
+ type: "always" | "byDefault";
698
+ schema: string;
699
+ increment?: string | undefined;
700
+ minValue?: string | undefined;
701
+ maxValue?: string | undefined;
702
+ startWith?: string | undefined;
703
+ cache?: string | undefined;
704
+ cycle?: boolean | undefined;
705
+ } | undefined;
809
706
  }>;
810
707
  indexes: Record<string, {
811
708
  name: string;
812
- columns: string[];
709
+ columns: {
710
+ isExpression: boolean;
711
+ expression: string;
712
+ asc: boolean;
713
+ nulls?: string | undefined;
714
+ opclass?: string | undefined;
715
+ }[];
813
716
  isUnique: boolean;
717
+ with?: Record<string, any> | undefined;
718
+ method?: string | undefined;
814
719
  where?: string | undefined;
720
+ concurrently?: boolean | undefined;
815
721
  }>;
816
722
  foreignKeys: Record<string, {
817
723
  name: string;
@@ -821,62 +727,123 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
821
727
  columnsTo: string[];
822
728
  onUpdate?: string | undefined;
823
729
  onDelete?: string | undefined;
730
+ schemaTo?: string | undefined;
824
731
  }>;
732
+ schema: string;
825
733
  compositePrimaryKeys: Record<string, {
734
+ name: string;
826
735
  columns: string[];
827
- name?: string | undefined;
828
736
  }>;
829
737
  uniqueConstraints?: Record<string, {
830
738
  name: string;
831
739
  columns: string[];
740
+ nullsNotDistinct: boolean;
832
741
  }> | undefined;
833
742
  }>>;
834
- enums: zod.ZodObject<{}, "strip", zod.ZodTypeAny, {}, {}>;
743
+ enums: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
744
+ name: zod.ZodString;
745
+ schema: zod.ZodString;
746
+ values: zod.ZodArray<zod.ZodString, "many">;
747
+ }, "strict", zod.ZodTypeAny, {
748
+ name: string;
749
+ values: string[];
750
+ schema: string;
751
+ }, {
752
+ name: string;
753
+ values: string[];
754
+ schema: string;
755
+ }>>;
756
+ schemas: zod.ZodRecord<zod.ZodString, zod.ZodString>;
757
+ sequences: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
758
+ name: zod.ZodString;
759
+ increment: zod.ZodOptional<zod.ZodString>;
760
+ minValue: zod.ZodOptional<zod.ZodString>;
761
+ maxValue: zod.ZodOptional<zod.ZodString>;
762
+ startWith: zod.ZodOptional<zod.ZodString>;
763
+ cache: zod.ZodOptional<zod.ZodString>;
764
+ cycle: zod.ZodOptional<zod.ZodBoolean>;
765
+ schema: zod.ZodString;
766
+ }, "strict", zod.ZodTypeAny, {
767
+ name: string;
768
+ schema: string;
769
+ increment?: string | undefined;
770
+ minValue?: string | undefined;
771
+ maxValue?: string | undefined;
772
+ startWith?: string | undefined;
773
+ cache?: string | undefined;
774
+ cycle?: boolean | undefined;
775
+ }, {
776
+ name: string;
777
+ schema: string;
778
+ increment?: string | undefined;
779
+ minValue?: string | undefined;
780
+ maxValue?: string | undefined;
781
+ startWith?: string | undefined;
782
+ cache?: string | undefined;
783
+ cycle?: boolean | undefined;
784
+ }>>>;
835
785
  _meta: zod.ZodObject<{
786
+ schemas: zod.ZodRecord<zod.ZodString, zod.ZodString>;
836
787
  tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
837
788
  columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
838
789
  }, "strip", zod.ZodTypeAny, {
839
790
  columns: Record<string, string>;
840
791
  tables: Record<string, string>;
792
+ schemas: Record<string, string>;
841
793
  }, {
842
794
  columns: Record<string, string>;
843
795
  tables: Record<string, string>;
796
+ schemas: Record<string, string>;
844
797
  }>;
845
798
  internal: zod.ZodOptional<zod.ZodObject<{
846
- indexes: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
799
+ tables: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
847
800
  columns: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
848
- isExpression: zod.ZodOptional<zod.ZodBoolean>;
801
+ isArray: zod.ZodOptional<zod.ZodBoolean>;
802
+ dimensions: zod.ZodOptional<zod.ZodNumber>;
803
+ rawType: zod.ZodOptional<zod.ZodString>;
849
804
  }, "strip", zod.ZodTypeAny, {
850
- isExpression?: boolean | undefined;
805
+ isArray?: boolean | undefined;
806
+ dimensions?: number | undefined;
807
+ rawType?: string | undefined;
851
808
  }, {
852
- isExpression?: boolean | undefined;
809
+ isArray?: boolean | undefined;
810
+ dimensions?: number | undefined;
811
+ rawType?: string | undefined;
853
812
  }>>>;
854
813
  }, "strip", zod.ZodTypeAny, {
855
814
  columns: Record<string, {
856
- isExpression?: boolean | undefined;
815
+ isArray?: boolean | undefined;
816
+ dimensions?: number | undefined;
817
+ rawType?: string | undefined;
857
818
  } | undefined>;
858
819
  }, {
859
820
  columns: Record<string, {
860
- isExpression?: boolean | undefined;
821
+ isArray?: boolean | undefined;
822
+ dimensions?: number | undefined;
823
+ rawType?: string | undefined;
861
824
  } | undefined>;
862
- }>>>>;
825
+ }>>>;
863
826
  }, "strip", zod.ZodTypeAny, {
864
- indexes?: Record<string, {
827
+ tables: Record<string, {
865
828
  columns: Record<string, {
866
- isExpression?: boolean | undefined;
829
+ isArray?: boolean | undefined;
830
+ dimensions?: number | undefined;
831
+ rawType?: string | undefined;
867
832
  } | undefined>;
868
- } | undefined> | undefined;
833
+ } | undefined>;
869
834
  }, {
870
- indexes?: Record<string, {
835
+ tables: Record<string, {
871
836
  columns: Record<string, {
872
- isExpression?: boolean | undefined;
837
+ isArray?: boolean | undefined;
838
+ dimensions?: number | undefined;
839
+ rawType?: string | undefined;
873
840
  } | undefined>;
874
- } | undefined> | undefined;
841
+ } | undefined>;
875
842
  }>>;
876
843
  }, {
877
844
  id: zod.ZodString;
878
845
  prevId: zod.ZodString;
879
- }>, "strict", zod.ZodTypeAny, {
846
+ }>, "strip", zod.ZodTypeAny, {
880
847
  tables: Record<string, {
881
848
  name: string;
882
849
  columns: Record<string, {
@@ -884,17 +851,40 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
884
851
  type: string;
885
852
  primaryKey: boolean;
886
853
  notNull: boolean;
854
+ isUnique?: any;
887
855
  default?: any;
888
- autoincrement?: boolean | undefined;
889
856
  generated?: {
890
- type: "stored" | "virtual";
857
+ type: "stored";
891
858
  as: string;
892
859
  } | undefined;
860
+ typeSchema?: string | undefined;
861
+ uniqueName?: string | undefined;
862
+ nullsNotDistinct?: boolean | undefined;
863
+ identity?: {
864
+ name: string;
865
+ type: "always" | "byDefault";
866
+ schema: string;
867
+ increment?: string | undefined;
868
+ minValue?: string | undefined;
869
+ maxValue?: string | undefined;
870
+ startWith?: string | undefined;
871
+ cache?: string | undefined;
872
+ cycle?: boolean | undefined;
873
+ } | undefined;
893
874
  }>;
894
875
  indexes: Record<string, {
895
876
  name: string;
896
- columns: string[];
877
+ columns: {
878
+ isExpression: boolean;
879
+ expression: string;
880
+ asc: boolean;
881
+ nulls?: string | undefined;
882
+ opclass?: string | undefined;
883
+ }[];
897
884
  isUnique: boolean;
885
+ method: string;
886
+ concurrently: boolean;
887
+ with?: Record<string, any> | undefined;
898
888
  where?: string | undefined;
899
889
  }>;
900
890
  foreignKeys: Record<string, {
@@ -905,31 +895,52 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
905
895
  columnsTo: string[];
906
896
  onUpdate?: string | undefined;
907
897
  onDelete?: string | undefined;
898
+ schemaTo?: string | undefined;
908
899
  }>;
900
+ schema: string;
909
901
  compositePrimaryKeys: Record<string, {
902
+ name: string;
910
903
  columns: string[];
911
- name?: string | undefined;
912
904
  }>;
913
905
  uniqueConstraints: Record<string, {
914
906
  name: string;
915
907
  columns: string[];
908
+ nullsNotDistinct: boolean;
916
909
  }>;
917
910
  }>;
918
911
  id: string;
919
912
  prevId: string;
920
- version: "6";
921
- dialect: "sqlite";
913
+ version: "7";
914
+ dialect: "postgresql";
915
+ schemas: Record<string, string>;
922
916
  _meta: {
923
917
  columns: Record<string, string>;
924
918
  tables: Record<string, string>;
919
+ schemas: Record<string, string>;
925
920
  };
926
- enums: {};
921
+ enums: Record<string, {
922
+ name: string;
923
+ values: string[];
924
+ schema: string;
925
+ }>;
926
+ sequences: Record<string, {
927
+ name: string;
928
+ schema: string;
929
+ increment?: string | undefined;
930
+ minValue?: string | undefined;
931
+ maxValue?: string | undefined;
932
+ startWith?: string | undefined;
933
+ cache?: string | undefined;
934
+ cycle?: boolean | undefined;
935
+ }>;
927
936
  internal?: {
928
- indexes?: Record<string, {
937
+ tables: Record<string, {
929
938
  columns: Record<string, {
930
- isExpression?: boolean | undefined;
939
+ isArray?: boolean | undefined;
940
+ dimensions?: number | undefined;
941
+ rawType?: string | undefined;
931
942
  } | undefined>;
932
- } | undefined> | undefined;
943
+ } | undefined>;
933
944
  } | undefined;
934
945
  }, {
935
946
  tables: Record<string, {
@@ -939,18 +950,41 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
939
950
  type: string;
940
951
  primaryKey: boolean;
941
952
  notNull: boolean;
953
+ isUnique?: any;
942
954
  default?: any;
943
- autoincrement?: boolean | undefined;
944
955
  generated?: {
945
- type: "stored" | "virtual";
956
+ type: "stored";
946
957
  as: string;
947
958
  } | undefined;
959
+ typeSchema?: string | undefined;
960
+ uniqueName?: string | undefined;
961
+ nullsNotDistinct?: boolean | undefined;
962
+ identity?: {
963
+ name: string;
964
+ type: "always" | "byDefault";
965
+ schema: string;
966
+ increment?: string | undefined;
967
+ minValue?: string | undefined;
968
+ maxValue?: string | undefined;
969
+ startWith?: string | undefined;
970
+ cache?: string | undefined;
971
+ cycle?: boolean | undefined;
972
+ } | undefined;
948
973
  }>;
949
974
  indexes: Record<string, {
950
975
  name: string;
951
- columns: string[];
976
+ columns: {
977
+ isExpression: boolean;
978
+ expression: string;
979
+ asc: boolean;
980
+ nulls?: string | undefined;
981
+ opclass?: string | undefined;
982
+ }[];
952
983
  isUnique: boolean;
984
+ with?: Record<string, any> | undefined;
985
+ method?: string | undefined;
953
986
  where?: string | undefined;
987
+ concurrently?: boolean | undefined;
954
988
  }>;
955
989
  foreignKeys: Record<string, {
956
990
  name: string;
@@ -960,38 +994,59 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
960
994
  columnsTo: string[];
961
995
  onUpdate?: string | undefined;
962
996
  onDelete?: string | undefined;
997
+ schemaTo?: string | undefined;
963
998
  }>;
999
+ schema: string;
964
1000
  compositePrimaryKeys: Record<string, {
1001
+ name: string;
965
1002
  columns: string[];
966
- name?: string | undefined;
967
1003
  }>;
968
1004
  uniqueConstraints?: Record<string, {
969
1005
  name: string;
970
1006
  columns: string[];
1007
+ nullsNotDistinct: boolean;
971
1008
  }> | undefined;
972
1009
  }>;
973
1010
  id: string;
974
1011
  prevId: string;
975
- version: "6";
976
- dialect: "sqlite";
1012
+ version: "7";
1013
+ dialect: "postgresql";
1014
+ schemas: Record<string, string>;
977
1015
  _meta: {
978
1016
  columns: Record<string, string>;
979
1017
  tables: Record<string, string>;
1018
+ schemas: Record<string, string>;
980
1019
  };
981
- enums: {};
1020
+ enums: Record<string, {
1021
+ name: string;
1022
+ values: string[];
1023
+ schema: string;
1024
+ }>;
982
1025
  internal?: {
983
- indexes?: Record<string, {
1026
+ tables: Record<string, {
984
1027
  columns: Record<string, {
985
- isExpression?: boolean | undefined;
1028
+ isArray?: boolean | undefined;
1029
+ dimensions?: number | undefined;
1030
+ rawType?: string | undefined;
986
1031
  } | undefined>;
987
- } | undefined> | undefined;
1032
+ } | undefined>;
988
1033
  } | undefined;
1034
+ sequences?: Record<string, {
1035
+ name: string;
1036
+ schema: string;
1037
+ increment?: string | undefined;
1038
+ minValue?: string | undefined;
1039
+ maxValue?: string | undefined;
1040
+ startWith?: string | undefined;
1041
+ cache?: string | undefined;
1042
+ cycle?: boolean | undefined;
1043
+ }> | undefined;
989
1044
  }>;
990
- type SQLiteSchema = TypeOf<typeof schema$1>;
1045
+ type PgSchema = TypeOf<typeof pgSchema>;
991
1046
 
992
1047
  declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
993
- version: zod.ZodLiteral<"5">;
994
- dialect: zod.ZodLiteral<"mysql">;
1048
+ version: zod.ZodLiteral<"6">;
1049
+ dialect: zod.ZodEnum<["sqlite"]>;
995
1050
  tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
996
1051
  name: zod.ZodString;
997
1052
  columns: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
@@ -1001,7 +1056,6 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
1001
1056
  notNull: zod.ZodBoolean;
1002
1057
  autoincrement: zod.ZodOptional<zod.ZodBoolean>;
1003
1058
  default: zod.ZodOptional<zod.ZodAny>;
1004
- onUpdate: zod.ZodOptional<zod.ZodAny>;
1005
1059
  generated: zod.ZodOptional<zod.ZodObject<{
1006
1060
  type: zod.ZodEnum<["stored", "virtual"]>;
1007
1061
  as: zod.ZodString;
@@ -1018,7 +1072,6 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
1018
1072
  primaryKey: boolean;
1019
1073
  notNull: boolean;
1020
1074
  default?: any;
1021
- onUpdate?: any;
1022
1075
  autoincrement?: boolean | undefined;
1023
1076
  generated?: {
1024
1077
  type: "stored" | "virtual";
@@ -1030,7 +1083,6 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
1030
1083
  primaryKey: boolean;
1031
1084
  notNull: boolean;
1032
1085
  default?: any;
1033
- onUpdate?: any;
1034
1086
  autoincrement?: boolean | undefined;
1035
1087
  generated?: {
1036
1088
  type: "stored" | "virtual";
@@ -1040,24 +1092,18 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
1040
1092
  indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1041
1093
  name: zod.ZodString;
1042
1094
  columns: zod.ZodArray<zod.ZodString, "many">;
1095
+ where: zod.ZodOptional<zod.ZodString>;
1043
1096
  isUnique: zod.ZodBoolean;
1044
- using: zod.ZodOptional<zod.ZodEnum<["btree", "hash"]>>;
1045
- algorithm: zod.ZodOptional<zod.ZodEnum<["default", "inplace", "copy"]>>;
1046
- lock: zod.ZodOptional<zod.ZodEnum<["default", "none", "shared", "exclusive"]>>;
1047
1097
  }, "strict", zod.ZodTypeAny, {
1048
1098
  name: string;
1049
1099
  columns: string[];
1050
1100
  isUnique: boolean;
1051
- using?: "btree" | "hash" | undefined;
1052
- algorithm?: "default" | "inplace" | "copy" | undefined;
1053
- lock?: "none" | "default" | "shared" | "exclusive" | undefined;
1101
+ where?: string | undefined;
1054
1102
  }, {
1055
1103
  name: string;
1056
1104
  columns: string[];
1057
1105
  isUnique: boolean;
1058
- using?: "btree" | "hash" | undefined;
1059
- algorithm?: "default" | "inplace" | "copy" | undefined;
1060
- lock?: "none" | "default" | "shared" | "exclusive" | undefined;
1106
+ where?: string | undefined;
1061
1107
  }>>;
1062
1108
  foreignKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1063
1109
  name: zod.ZodString;
@@ -1085,14 +1131,14 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
1085
1131
  onDelete?: string | undefined;
1086
1132
  }>>;
1087
1133
  compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1088
- name: zod.ZodString;
1089
1134
  columns: zod.ZodArray<zod.ZodString, "many">;
1135
+ name: zod.ZodOptional<zod.ZodString>;
1090
1136
  }, "strict", zod.ZodTypeAny, {
1091
- name: string;
1092
1137
  columns: string[];
1138
+ name?: string | undefined;
1093
1139
  }, {
1094
- name: string;
1095
1140
  columns: string[];
1141
+ name?: string | undefined;
1096
1142
  }>>;
1097
1143
  uniqueConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1098
1144
  name: zod.ZodString;
@@ -1112,7 +1158,6 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
1112
1158
  primaryKey: boolean;
1113
1159
  notNull: boolean;
1114
1160
  default?: any;
1115
- onUpdate?: any;
1116
1161
  autoincrement?: boolean | undefined;
1117
1162
  generated?: {
1118
1163
  type: "stored" | "virtual";
@@ -1123,9 +1168,7 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
1123
1168
  name: string;
1124
1169
  columns: string[];
1125
1170
  isUnique: boolean;
1126
- using?: "btree" | "hash" | undefined;
1127
- algorithm?: "default" | "inplace" | "copy" | undefined;
1128
- lock?: "none" | "default" | "shared" | "exclusive" | undefined;
1171
+ where?: string | undefined;
1129
1172
  }>;
1130
1173
  foreignKeys: Record<string, {
1131
1174
  name: string;
@@ -1137,8 +1180,8 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
1137
1180
  onDelete?: string | undefined;
1138
1181
  }>;
1139
1182
  compositePrimaryKeys: Record<string, {
1140
- name: string;
1141
1183
  columns: string[];
1184
+ name?: string | undefined;
1142
1185
  }>;
1143
1186
  uniqueConstraints: Record<string, {
1144
1187
  name: string;
@@ -1152,7 +1195,6 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
1152
1195
  primaryKey: boolean;
1153
1196
  notNull: boolean;
1154
1197
  default?: any;
1155
- onUpdate?: any;
1156
1198
  autoincrement?: boolean | undefined;
1157
1199
  generated?: {
1158
1200
  type: "stored" | "virtual";
@@ -1163,9 +1205,7 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
1163
1205
  name: string;
1164
1206
  columns: string[];
1165
1207
  isUnique: boolean;
1166
- using?: "btree" | "hash" | undefined;
1167
- algorithm?: "default" | "inplace" | "copy" | undefined;
1168
- lock?: "none" | "default" | "shared" | "exclusive" | undefined;
1208
+ where?: string | undefined;
1169
1209
  }>;
1170
1210
  foreignKeys: Record<string, {
1171
1211
  name: string;
@@ -1177,14 +1217,15 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
1177
1217
  onDelete?: string | undefined;
1178
1218
  }>;
1179
1219
  compositePrimaryKeys: Record<string, {
1180
- name: string;
1181
1220
  columns: string[];
1221
+ name?: string | undefined;
1182
1222
  }>;
1183
1223
  uniqueConstraints?: Record<string, {
1184
1224
  name: string;
1185
1225
  columns: string[];
1186
1226
  }> | undefined;
1187
1227
  }>>;
1228
+ enums: zod.ZodObject<{}, "strip", zod.ZodTypeAny, {}, {}>;
1188
1229
  _meta: zod.ZodObject<{
1189
1230
  tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
1190
1231
  columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
@@ -1196,23 +1237,6 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
1196
1237
  tables: Record<string, string>;
1197
1238
  }>;
1198
1239
  internal: zod.ZodOptional<zod.ZodObject<{
1199
- tables: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
1200
- columns: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
1201
- isDefaultAnExpression: zod.ZodOptional<zod.ZodBoolean>;
1202
- }, "strip", zod.ZodTypeAny, {
1203
- isDefaultAnExpression?: boolean | undefined;
1204
- }, {
1205
- isDefaultAnExpression?: boolean | undefined;
1206
- }>>>;
1207
- }, "strip", zod.ZodTypeAny, {
1208
- columns: Record<string, {
1209
- isDefaultAnExpression?: boolean | undefined;
1210
- } | undefined>;
1211
- }, {
1212
- columns: Record<string, {
1213
- isDefaultAnExpression?: boolean | undefined;
1214
- } | undefined>;
1215
- }>>>>;
1216
1240
  indexes: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
1217
1241
  columns: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
1218
1242
  isExpression: zod.ZodOptional<zod.ZodBoolean>;
@@ -1236,27 +1260,17 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
1236
1260
  isExpression?: boolean | undefined;
1237
1261
  } | undefined>;
1238
1262
  } | undefined> | undefined;
1239
- tables?: Record<string, {
1240
- columns: Record<string, {
1241
- isDefaultAnExpression?: boolean | undefined;
1242
- } | undefined>;
1243
- } | undefined> | undefined;
1244
1263
  }, {
1245
1264
  indexes?: Record<string, {
1246
1265
  columns: Record<string, {
1247
1266
  isExpression?: boolean | undefined;
1248
1267
  } | undefined>;
1249
1268
  } | undefined> | undefined;
1250
- tables?: Record<string, {
1251
- columns: Record<string, {
1252
- isDefaultAnExpression?: boolean | undefined;
1253
- } | undefined>;
1254
- } | undefined> | undefined;
1255
1269
  }>>;
1256
1270
  }, {
1257
1271
  id: zod.ZodString;
1258
1272
  prevId: zod.ZodString;
1259
- }>, "strip", zod.ZodTypeAny, {
1273
+ }>, "strict", zod.ZodTypeAny, {
1260
1274
  tables: Record<string, {
1261
1275
  name: string;
1262
1276
  columns: Record<string, {
@@ -1265,7 +1279,6 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
1265
1279
  primaryKey: boolean;
1266
1280
  notNull: boolean;
1267
1281
  default?: any;
1268
- onUpdate?: any;
1269
1282
  autoincrement?: boolean | undefined;
1270
1283
  generated?: {
1271
1284
  type: "stored" | "virtual";
@@ -1276,9 +1289,7 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
1276
1289
  name: string;
1277
1290
  columns: string[];
1278
1291
  isUnique: boolean;
1279
- using?: "btree" | "hash" | undefined;
1280
- algorithm?: "default" | "inplace" | "copy" | undefined;
1281
- lock?: "none" | "default" | "shared" | "exclusive" | undefined;
1292
+ where?: string | undefined;
1282
1293
  }>;
1283
1294
  foreignKeys: Record<string, {
1284
1295
  name: string;
@@ -1290,8 +1301,8 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
1290
1301
  onDelete?: string | undefined;
1291
1302
  }>;
1292
1303
  compositePrimaryKeys: Record<string, {
1293
- name: string;
1294
1304
  columns: string[];
1305
+ name?: string | undefined;
1295
1306
  }>;
1296
1307
  uniqueConstraints: Record<string, {
1297
1308
  name: string;
@@ -1300,23 +1311,19 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
1300
1311
  }>;
1301
1312
  id: string;
1302
1313
  prevId: string;
1303
- version: "5";
1304
- dialect: "mysql";
1314
+ version: "6";
1315
+ dialect: "sqlite";
1305
1316
  _meta: {
1306
1317
  columns: Record<string, string>;
1307
1318
  tables: Record<string, string>;
1308
1319
  };
1320
+ enums: {};
1309
1321
  internal?: {
1310
1322
  indexes?: Record<string, {
1311
1323
  columns: Record<string, {
1312
1324
  isExpression?: boolean | undefined;
1313
1325
  } | undefined>;
1314
1326
  } | undefined> | undefined;
1315
- tables?: Record<string, {
1316
- columns: Record<string, {
1317
- isDefaultAnExpression?: boolean | undefined;
1318
- } | undefined>;
1319
- } | undefined> | undefined;
1320
1327
  } | undefined;
1321
1328
  }, {
1322
1329
  tables: Record<string, {
@@ -1327,7 +1334,6 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
1327
1334
  primaryKey: boolean;
1328
1335
  notNull: boolean;
1329
1336
  default?: any;
1330
- onUpdate?: any;
1331
1337
  autoincrement?: boolean | undefined;
1332
1338
  generated?: {
1333
1339
  type: "stored" | "virtual";
@@ -1338,9 +1344,7 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
1338
1344
  name: string;
1339
1345
  columns: string[];
1340
1346
  isUnique: boolean;
1341
- using?: "btree" | "hash" | undefined;
1342
- algorithm?: "default" | "inplace" | "copy" | undefined;
1343
- lock?: "none" | "default" | "shared" | "exclusive" | undefined;
1347
+ where?: string | undefined;
1344
1348
  }>;
1345
1349
  foreignKeys: Record<string, {
1346
1350
  name: string;
@@ -1352,8 +1356,8 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
1352
1356
  onDelete?: string | undefined;
1353
1357
  }>;
1354
1358
  compositePrimaryKeys: Record<string, {
1355
- name: string;
1356
1359
  columns: string[];
1360
+ name?: string | undefined;
1357
1361
  }>;
1358
1362
  uniqueConstraints?: Record<string, {
1359
1363
  name: string;
@@ -1362,26 +1366,22 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
1362
1366
  }>;
1363
1367
  id: string;
1364
1368
  prevId: string;
1365
- version: "5";
1366
- dialect: "mysql";
1369
+ version: "6";
1370
+ dialect: "sqlite";
1367
1371
  _meta: {
1368
1372
  columns: Record<string, string>;
1369
1373
  tables: Record<string, string>;
1370
1374
  };
1375
+ enums: {};
1371
1376
  internal?: {
1372
1377
  indexes?: Record<string, {
1373
1378
  columns: Record<string, {
1374
1379
  isExpression?: boolean | undefined;
1375
1380
  } | undefined>;
1376
1381
  } | undefined> | undefined;
1377
- tables?: Record<string, {
1378
- columns: Record<string, {
1379
- isDefaultAnExpression?: boolean | undefined;
1380
- } | undefined>;
1381
- } | undefined> | undefined;
1382
1382
  } | undefined;
1383
1383
  }>;
1384
- type MySqlSchema = TypeOf<typeof schema>;
1384
+ type SQLiteSchema = TypeOf<typeof schema>;
1385
1385
 
1386
1386
  type DrizzleSnapshotJSON = PgSchema;
1387
1387
  type DrizzleSQLiteSnapshotJSON = SQLiteSchema;