drizzle-kit 0.23.1 → 0.23.2-505c62f

Sign up to get free protection for your applications and to get access to all the features.
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} +24916 -25193
  5. package/{payload.mjs → api.mjs} +24914 -25192
  6. package/bin.cjs +49528 -95613
  7. package/index.d.mts +14 -20
  8. package/index.d.ts +14 -20
  9. package/package.json +138 -115
  10. package/utils.js +25 -18
  11. package/utils.mjs +24 -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;