drizzle-kit 0.20.17-a2979a1 → 0.20.17-b08243d
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.
- package/bin.cjs +25462 -26322
- package/cli/commands/migrate.d.ts +41 -41
- package/cli/commands/mysqlIntrospect.d.ts +8 -8
- package/cli/commands/pgIntrospect.d.ts +8 -8
- package/cli/commands/sqliteIntrospect.d.ts +12 -12
- package/cli/commands/utils.d.ts +2 -2
- package/cli/validations/cli.d.ts +29 -29
- package/cli/validations/common.d.ts +35 -35
- package/cli/validations/mysql.d.ts +4 -4
- package/cli/validations/outputs.d.ts +1 -2
- package/cli/validations/pg.d.ts +4 -4
- package/index.d.mts +2 -48
- package/index.d.ts +2 -48
- package/package.json +1 -1
- package/payload.js +476 -1080
- package/payload.mjs +283 -887
- package/schemaValidator.d.ts +222 -222
- package/serializer/mysqlSchema.d.ts +890 -890
- package/serializer/pgSchema.d.ts +745 -745
- package/serializer/sqliteSchema.d.ts +457 -457
- package/serializer/studio.d.ts +1 -1
- package/snapshotsDiffer.d.ts +315 -316
- package/utils-studio.js +841 -947
- package/utils-studio.mjs +814 -920
- package/utils.js +219 -844
- package/utils.mjs +194 -819
|
@@ -7,19 +7,19 @@ declare const index: import("zod").ZodObject<{
|
|
|
7
7
|
algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
|
|
8
8
|
lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
|
|
9
9
|
}, "strict", import("zod").ZodTypeAny, {
|
|
10
|
-
name: string;
|
|
11
|
-
columns: string[];
|
|
12
|
-
isUnique: boolean;
|
|
13
10
|
using?: "btree" | "hash" | undefined;
|
|
14
11
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
15
12
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
16
|
-
}, {
|
|
17
13
|
name: string;
|
|
18
14
|
columns: string[];
|
|
19
15
|
isUnique: boolean;
|
|
16
|
+
}, {
|
|
20
17
|
using?: "btree" | "hash" | undefined;
|
|
21
18
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
22
19
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
20
|
+
name: string;
|
|
21
|
+
columns: string[];
|
|
22
|
+
isUnique: boolean;
|
|
23
23
|
}>;
|
|
24
24
|
declare const fk: import("zod").ZodObject<{
|
|
25
25
|
name: import("zod").ZodString;
|
|
@@ -30,21 +30,21 @@ declare const fk: import("zod").ZodObject<{
|
|
|
30
30
|
onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
|
|
31
31
|
onDelete: import("zod").ZodOptional<import("zod").ZodString>;
|
|
32
32
|
}, "strict", import("zod").ZodTypeAny, {
|
|
33
|
+
onUpdate?: string | undefined;
|
|
34
|
+
onDelete?: string | undefined;
|
|
33
35
|
name: string;
|
|
34
36
|
tableFrom: string;
|
|
35
37
|
columnsFrom: string[];
|
|
36
38
|
tableTo: string;
|
|
37
39
|
columnsTo: string[];
|
|
40
|
+
}, {
|
|
38
41
|
onUpdate?: string | undefined;
|
|
39
42
|
onDelete?: string | undefined;
|
|
40
|
-
}, {
|
|
41
43
|
name: string;
|
|
42
44
|
tableFrom: string;
|
|
43
45
|
columnsFrom: string[];
|
|
44
46
|
tableTo: string;
|
|
45
47
|
columnsTo: string[];
|
|
46
|
-
onUpdate?: string | undefined;
|
|
47
|
-
onDelete?: string | undefined;
|
|
48
48
|
}>;
|
|
49
49
|
declare const column: import("zod").ZodObject<{
|
|
50
50
|
name: import("zod").ZodString;
|
|
@@ -55,21 +55,21 @@ declare const column: import("zod").ZodObject<{
|
|
|
55
55
|
default: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
56
56
|
onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
57
57
|
}, "strict", import("zod").ZodTypeAny, {
|
|
58
|
+
default?: any;
|
|
59
|
+
onUpdate?: any;
|
|
60
|
+
autoincrement?: boolean | undefined;
|
|
58
61
|
name: string;
|
|
59
62
|
type: string;
|
|
60
63
|
primaryKey: boolean;
|
|
61
64
|
notNull: boolean;
|
|
65
|
+
}, {
|
|
62
66
|
default?: any;
|
|
63
67
|
onUpdate?: any;
|
|
64
68
|
autoincrement?: boolean | undefined;
|
|
65
|
-
}, {
|
|
66
69
|
name: string;
|
|
67
70
|
type: string;
|
|
68
71
|
primaryKey: boolean;
|
|
69
72
|
notNull: boolean;
|
|
70
|
-
default?: any;
|
|
71
|
-
onUpdate?: any;
|
|
72
|
-
autoincrement?: boolean | undefined;
|
|
73
73
|
}>;
|
|
74
74
|
declare const compositePK: import("zod").ZodObject<{
|
|
75
75
|
name: import("zod").ZodString;
|
|
@@ -103,21 +103,21 @@ declare const tableV4: import("zod").ZodObject<{
|
|
|
103
103
|
default: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
104
104
|
onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
105
105
|
}, "strict", import("zod").ZodTypeAny, {
|
|
106
|
+
default?: any;
|
|
107
|
+
onUpdate?: any;
|
|
108
|
+
autoincrement?: boolean | undefined;
|
|
106
109
|
name: string;
|
|
107
110
|
type: string;
|
|
108
111
|
primaryKey: boolean;
|
|
109
112
|
notNull: boolean;
|
|
113
|
+
}, {
|
|
110
114
|
default?: any;
|
|
111
115
|
onUpdate?: any;
|
|
112
116
|
autoincrement?: boolean | undefined;
|
|
113
|
-
}, {
|
|
114
117
|
name: string;
|
|
115
118
|
type: string;
|
|
116
119
|
primaryKey: boolean;
|
|
117
120
|
notNull: boolean;
|
|
118
|
-
default?: any;
|
|
119
|
-
onUpdate?: any;
|
|
120
|
-
autoincrement?: boolean | undefined;
|
|
121
121
|
}>>;
|
|
122
122
|
indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
123
123
|
name: import("zod").ZodString;
|
|
@@ -127,19 +127,19 @@ declare const tableV4: import("zod").ZodObject<{
|
|
|
127
127
|
algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
|
|
128
128
|
lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
|
|
129
129
|
}, "strict", import("zod").ZodTypeAny, {
|
|
130
|
-
name: string;
|
|
131
|
-
columns: string[];
|
|
132
|
-
isUnique: boolean;
|
|
133
130
|
using?: "btree" | "hash" | undefined;
|
|
134
131
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
135
132
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
136
|
-
}, {
|
|
137
133
|
name: string;
|
|
138
134
|
columns: string[];
|
|
139
135
|
isUnique: boolean;
|
|
136
|
+
}, {
|
|
140
137
|
using?: "btree" | "hash" | undefined;
|
|
141
138
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
142
139
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
140
|
+
name: string;
|
|
141
|
+
columns: string[];
|
|
142
|
+
isUnique: boolean;
|
|
143
143
|
}>>;
|
|
144
144
|
foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
145
145
|
name: import("zod").ZodString;
|
|
@@ -150,80 +150,80 @@ declare const tableV4: import("zod").ZodObject<{
|
|
|
150
150
|
onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
|
|
151
151
|
onDelete: import("zod").ZodOptional<import("zod").ZodString>;
|
|
152
152
|
}, "strict", import("zod").ZodTypeAny, {
|
|
153
|
+
onUpdate?: string | undefined;
|
|
154
|
+
onDelete?: string | undefined;
|
|
153
155
|
name: string;
|
|
154
156
|
tableFrom: string;
|
|
155
157
|
columnsFrom: string[];
|
|
156
158
|
tableTo: string;
|
|
157
159
|
columnsTo: string[];
|
|
160
|
+
}, {
|
|
158
161
|
onUpdate?: string | undefined;
|
|
159
162
|
onDelete?: string | undefined;
|
|
160
|
-
}, {
|
|
161
163
|
name: string;
|
|
162
164
|
tableFrom: string;
|
|
163
165
|
columnsFrom: string[];
|
|
164
166
|
tableTo: string;
|
|
165
167
|
columnsTo: string[];
|
|
166
|
-
onUpdate?: string | undefined;
|
|
167
|
-
onDelete?: string | undefined;
|
|
168
168
|
}>>;
|
|
169
169
|
}, "strict", import("zod").ZodTypeAny, {
|
|
170
|
+
schema?: string | undefined;
|
|
170
171
|
name: string;
|
|
171
172
|
columns: Record<string, {
|
|
173
|
+
default?: any;
|
|
174
|
+
onUpdate?: any;
|
|
175
|
+
autoincrement?: boolean | undefined;
|
|
172
176
|
name: string;
|
|
173
177
|
type: string;
|
|
174
178
|
primaryKey: boolean;
|
|
175
179
|
notNull: boolean;
|
|
176
|
-
default?: any;
|
|
177
|
-
onUpdate?: any;
|
|
178
|
-
autoincrement?: boolean | undefined;
|
|
179
180
|
}>;
|
|
180
181
|
indexes: Record<string, {
|
|
181
|
-
name: string;
|
|
182
|
-
columns: string[];
|
|
183
|
-
isUnique: boolean;
|
|
184
182
|
using?: "btree" | "hash" | undefined;
|
|
185
183
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
186
184
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
185
|
+
name: string;
|
|
186
|
+
columns: string[];
|
|
187
|
+
isUnique: boolean;
|
|
187
188
|
}>;
|
|
188
189
|
foreignKeys: Record<string, {
|
|
190
|
+
onUpdate?: string | undefined;
|
|
191
|
+
onDelete?: string | undefined;
|
|
189
192
|
name: string;
|
|
190
193
|
tableFrom: string;
|
|
191
194
|
columnsFrom: string[];
|
|
192
195
|
tableTo: string;
|
|
193
196
|
columnsTo: string[];
|
|
194
|
-
onUpdate?: string | undefined;
|
|
195
|
-
onDelete?: string | undefined;
|
|
196
197
|
}>;
|
|
197
|
-
schema?: string | undefined;
|
|
198
198
|
}, {
|
|
199
|
+
schema?: string | undefined;
|
|
199
200
|
name: string;
|
|
200
201
|
columns: Record<string, {
|
|
202
|
+
default?: any;
|
|
203
|
+
onUpdate?: any;
|
|
204
|
+
autoincrement?: boolean | undefined;
|
|
201
205
|
name: string;
|
|
202
206
|
type: string;
|
|
203
207
|
primaryKey: boolean;
|
|
204
208
|
notNull: boolean;
|
|
205
|
-
default?: any;
|
|
206
|
-
onUpdate?: any;
|
|
207
|
-
autoincrement?: boolean | undefined;
|
|
208
209
|
}>;
|
|
209
210
|
indexes: Record<string, {
|
|
210
|
-
name: string;
|
|
211
|
-
columns: string[];
|
|
212
|
-
isUnique: boolean;
|
|
213
211
|
using?: "btree" | "hash" | undefined;
|
|
214
212
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
215
213
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
214
|
+
name: string;
|
|
215
|
+
columns: string[];
|
|
216
|
+
isUnique: boolean;
|
|
216
217
|
}>;
|
|
217
218
|
foreignKeys: Record<string, {
|
|
219
|
+
onUpdate?: string | undefined;
|
|
220
|
+
onDelete?: string | undefined;
|
|
218
221
|
name: string;
|
|
219
222
|
tableFrom: string;
|
|
220
223
|
columnsFrom: string[];
|
|
221
224
|
tableTo: string;
|
|
222
225
|
columnsTo: string[];
|
|
223
|
-
onUpdate?: string | undefined;
|
|
224
|
-
onDelete?: string | undefined;
|
|
225
226
|
}>;
|
|
226
|
-
schema?: string | undefined;
|
|
227
227
|
}>;
|
|
228
228
|
declare const table: import("zod").ZodObject<{
|
|
229
229
|
name: import("zod").ZodString;
|
|
@@ -236,21 +236,21 @@ declare const table: import("zod").ZodObject<{
|
|
|
236
236
|
default: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
237
237
|
onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
238
238
|
}, "strict", import("zod").ZodTypeAny, {
|
|
239
|
+
default?: any;
|
|
240
|
+
onUpdate?: any;
|
|
241
|
+
autoincrement?: boolean | undefined;
|
|
239
242
|
name: string;
|
|
240
243
|
type: string;
|
|
241
244
|
primaryKey: boolean;
|
|
242
245
|
notNull: boolean;
|
|
246
|
+
}, {
|
|
243
247
|
default?: any;
|
|
244
248
|
onUpdate?: any;
|
|
245
249
|
autoincrement?: boolean | undefined;
|
|
246
|
-
}, {
|
|
247
250
|
name: string;
|
|
248
251
|
type: string;
|
|
249
252
|
primaryKey: boolean;
|
|
250
253
|
notNull: boolean;
|
|
251
|
-
default?: any;
|
|
252
|
-
onUpdate?: any;
|
|
253
|
-
autoincrement?: boolean | undefined;
|
|
254
254
|
}>>;
|
|
255
255
|
indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
256
256
|
name: import("zod").ZodString;
|
|
@@ -260,19 +260,19 @@ declare const table: import("zod").ZodObject<{
|
|
|
260
260
|
algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
|
|
261
261
|
lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
|
|
262
262
|
}, "strict", import("zod").ZodTypeAny, {
|
|
263
|
-
name: string;
|
|
264
|
-
columns: string[];
|
|
265
|
-
isUnique: boolean;
|
|
266
263
|
using?: "btree" | "hash" | undefined;
|
|
267
264
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
268
265
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
269
|
-
}, {
|
|
270
266
|
name: string;
|
|
271
267
|
columns: string[];
|
|
272
268
|
isUnique: boolean;
|
|
269
|
+
}, {
|
|
273
270
|
using?: "btree" | "hash" | undefined;
|
|
274
271
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
275
272
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
273
|
+
name: string;
|
|
274
|
+
columns: string[];
|
|
275
|
+
isUnique: boolean;
|
|
276
276
|
}>>;
|
|
277
277
|
foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
278
278
|
name: import("zod").ZodString;
|
|
@@ -283,21 +283,21 @@ declare const table: import("zod").ZodObject<{
|
|
|
283
283
|
onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
|
|
284
284
|
onDelete: import("zod").ZodOptional<import("zod").ZodString>;
|
|
285
285
|
}, "strict", import("zod").ZodTypeAny, {
|
|
286
|
+
onUpdate?: string | undefined;
|
|
287
|
+
onDelete?: string | undefined;
|
|
286
288
|
name: string;
|
|
287
289
|
tableFrom: string;
|
|
288
290
|
columnsFrom: string[];
|
|
289
291
|
tableTo: string;
|
|
290
292
|
columnsTo: string[];
|
|
293
|
+
}, {
|
|
291
294
|
onUpdate?: string | undefined;
|
|
292
295
|
onDelete?: string | undefined;
|
|
293
|
-
}, {
|
|
294
296
|
name: string;
|
|
295
297
|
tableFrom: string;
|
|
296
298
|
columnsFrom: string[];
|
|
297
299
|
tableTo: string;
|
|
298
300
|
columnsTo: string[];
|
|
299
|
-
onUpdate?: string | undefined;
|
|
300
|
-
onDelete?: string | undefined;
|
|
301
301
|
}>>;
|
|
302
302
|
compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
303
303
|
name: import("zod").ZodString;
|
|
@@ -322,30 +322,30 @@ declare const table: import("zod").ZodObject<{
|
|
|
322
322
|
}, "strict", import("zod").ZodTypeAny, {
|
|
323
323
|
name: string;
|
|
324
324
|
columns: Record<string, {
|
|
325
|
+
default?: any;
|
|
326
|
+
onUpdate?: any;
|
|
327
|
+
autoincrement?: boolean | undefined;
|
|
325
328
|
name: string;
|
|
326
329
|
type: string;
|
|
327
330
|
primaryKey: boolean;
|
|
328
331
|
notNull: boolean;
|
|
329
|
-
default?: any;
|
|
330
|
-
onUpdate?: any;
|
|
331
|
-
autoincrement?: boolean | undefined;
|
|
332
332
|
}>;
|
|
333
333
|
indexes: Record<string, {
|
|
334
|
-
name: string;
|
|
335
|
-
columns: string[];
|
|
336
|
-
isUnique: boolean;
|
|
337
334
|
using?: "btree" | "hash" | undefined;
|
|
338
335
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
339
336
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
337
|
+
name: string;
|
|
338
|
+
columns: string[];
|
|
339
|
+
isUnique: boolean;
|
|
340
340
|
}>;
|
|
341
341
|
foreignKeys: Record<string, {
|
|
342
|
+
onUpdate?: string | undefined;
|
|
343
|
+
onDelete?: string | undefined;
|
|
342
344
|
name: string;
|
|
343
345
|
tableFrom: string;
|
|
344
346
|
columnsFrom: string[];
|
|
345
347
|
tableTo: string;
|
|
346
348
|
columnsTo: string[];
|
|
347
|
-
onUpdate?: string | undefined;
|
|
348
|
-
onDelete?: string | undefined;
|
|
349
349
|
}>;
|
|
350
350
|
compositePrimaryKeys: Record<string, {
|
|
351
351
|
name: string;
|
|
@@ -356,41 +356,41 @@ declare const table: import("zod").ZodObject<{
|
|
|
356
356
|
columns: string[];
|
|
357
357
|
}>;
|
|
358
358
|
}, {
|
|
359
|
+
uniqueConstraints?: Record<string, {
|
|
360
|
+
name: string;
|
|
361
|
+
columns: string[];
|
|
362
|
+
}> | undefined;
|
|
359
363
|
name: string;
|
|
360
364
|
columns: Record<string, {
|
|
365
|
+
default?: any;
|
|
366
|
+
onUpdate?: any;
|
|
367
|
+
autoincrement?: boolean | undefined;
|
|
361
368
|
name: string;
|
|
362
369
|
type: string;
|
|
363
370
|
primaryKey: boolean;
|
|
364
371
|
notNull: boolean;
|
|
365
|
-
default?: any;
|
|
366
|
-
onUpdate?: any;
|
|
367
|
-
autoincrement?: boolean | undefined;
|
|
368
372
|
}>;
|
|
369
373
|
indexes: Record<string, {
|
|
370
|
-
name: string;
|
|
371
|
-
columns: string[];
|
|
372
|
-
isUnique: boolean;
|
|
373
374
|
using?: "btree" | "hash" | undefined;
|
|
374
375
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
375
376
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
377
|
+
name: string;
|
|
378
|
+
columns: string[];
|
|
379
|
+
isUnique: boolean;
|
|
376
380
|
}>;
|
|
377
381
|
foreignKeys: Record<string, {
|
|
382
|
+
onUpdate?: string | undefined;
|
|
383
|
+
onDelete?: string | undefined;
|
|
378
384
|
name: string;
|
|
379
385
|
tableFrom: string;
|
|
380
386
|
columnsFrom: string[];
|
|
381
387
|
tableTo: string;
|
|
382
388
|
columnsTo: string[];
|
|
383
|
-
onUpdate?: string | undefined;
|
|
384
|
-
onDelete?: string | undefined;
|
|
385
389
|
}>;
|
|
386
390
|
compositePrimaryKeys: Record<string, {
|
|
387
391
|
name: string;
|
|
388
392
|
columns: string[];
|
|
389
393
|
}>;
|
|
390
|
-
uniqueConstraints?: Record<string, {
|
|
391
|
-
name: string;
|
|
392
|
-
columns: string[];
|
|
393
|
-
}> | undefined;
|
|
394
394
|
}>;
|
|
395
395
|
export declare const kitInternals: import("zod").ZodOptional<import("zod").ZodObject<{
|
|
396
396
|
tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
|
|
@@ -438,21 +438,21 @@ export declare const schemaInternalV3: import("zod").ZodObject<{
|
|
|
438
438
|
default: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
439
439
|
onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
440
440
|
}, "strict", import("zod").ZodTypeAny, {
|
|
441
|
+
default?: any;
|
|
442
|
+
onUpdate?: any;
|
|
443
|
+
autoincrement?: boolean | undefined;
|
|
441
444
|
name: string;
|
|
442
445
|
type: string;
|
|
443
446
|
primaryKey: boolean;
|
|
444
447
|
notNull: boolean;
|
|
448
|
+
}, {
|
|
445
449
|
default?: any;
|
|
446
450
|
onUpdate?: any;
|
|
447
451
|
autoincrement?: boolean | undefined;
|
|
448
|
-
}, {
|
|
449
452
|
name: string;
|
|
450
453
|
type: string;
|
|
451
454
|
primaryKey: boolean;
|
|
452
455
|
notNull: boolean;
|
|
453
|
-
default?: any;
|
|
454
|
-
onUpdate?: any;
|
|
455
|
-
autoincrement?: boolean | undefined;
|
|
456
456
|
}>>;
|
|
457
457
|
indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
458
458
|
name: import("zod").ZodString;
|
|
@@ -462,19 +462,19 @@ export declare const schemaInternalV3: import("zod").ZodObject<{
|
|
|
462
462
|
algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
|
|
463
463
|
lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
|
|
464
464
|
}, "strict", import("zod").ZodTypeAny, {
|
|
465
|
-
name: string;
|
|
466
|
-
columns: string[];
|
|
467
|
-
isUnique: boolean;
|
|
468
465
|
using?: "btree" | "hash" | undefined;
|
|
469
466
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
470
467
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
471
|
-
}, {
|
|
472
468
|
name: string;
|
|
473
469
|
columns: string[];
|
|
474
470
|
isUnique: boolean;
|
|
471
|
+
}, {
|
|
475
472
|
using?: "btree" | "hash" | undefined;
|
|
476
473
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
477
474
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
475
|
+
name: string;
|
|
476
|
+
columns: string[];
|
|
477
|
+
isUnique: boolean;
|
|
478
478
|
}>>;
|
|
479
479
|
foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
480
480
|
name: import("zod").ZodString;
|
|
@@ -485,107 +485,107 @@ export declare const schemaInternalV3: import("zod").ZodObject<{
|
|
|
485
485
|
onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
|
|
486
486
|
onDelete: import("zod").ZodOptional<import("zod").ZodString>;
|
|
487
487
|
}, "strict", import("zod").ZodTypeAny, {
|
|
488
|
+
onUpdate?: string | undefined;
|
|
489
|
+
onDelete?: string | undefined;
|
|
488
490
|
name: string;
|
|
489
491
|
tableFrom: string;
|
|
490
492
|
columnsFrom: string[];
|
|
491
493
|
tableTo: string;
|
|
492
494
|
columnsTo: string[];
|
|
495
|
+
}, {
|
|
493
496
|
onUpdate?: string | undefined;
|
|
494
497
|
onDelete?: string | undefined;
|
|
495
|
-
}, {
|
|
496
498
|
name: string;
|
|
497
499
|
tableFrom: string;
|
|
498
500
|
columnsFrom: string[];
|
|
499
501
|
tableTo: string;
|
|
500
502
|
columnsTo: string[];
|
|
501
|
-
onUpdate?: string | undefined;
|
|
502
|
-
onDelete?: string | undefined;
|
|
503
503
|
}>>;
|
|
504
504
|
}, "strict", import("zod").ZodTypeAny, {
|
|
505
505
|
name: string;
|
|
506
506
|
columns: Record<string, {
|
|
507
|
+
default?: any;
|
|
508
|
+
onUpdate?: any;
|
|
509
|
+
autoincrement?: boolean | undefined;
|
|
507
510
|
name: string;
|
|
508
511
|
type: string;
|
|
509
512
|
primaryKey: boolean;
|
|
510
513
|
notNull: boolean;
|
|
511
|
-
default?: any;
|
|
512
|
-
onUpdate?: any;
|
|
513
|
-
autoincrement?: boolean | undefined;
|
|
514
514
|
}>;
|
|
515
515
|
indexes: Record<string, {
|
|
516
|
-
name: string;
|
|
517
|
-
columns: string[];
|
|
518
|
-
isUnique: boolean;
|
|
519
516
|
using?: "btree" | "hash" | undefined;
|
|
520
517
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
521
518
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
519
|
+
name: string;
|
|
520
|
+
columns: string[];
|
|
521
|
+
isUnique: boolean;
|
|
522
522
|
}>;
|
|
523
523
|
foreignKeys: Record<string, {
|
|
524
|
+
onUpdate?: string | undefined;
|
|
525
|
+
onDelete?: string | undefined;
|
|
524
526
|
name: string;
|
|
525
527
|
tableFrom: string;
|
|
526
528
|
columnsFrom: string[];
|
|
527
529
|
tableTo: string;
|
|
528
530
|
columnsTo: string[];
|
|
529
|
-
onUpdate?: string | undefined;
|
|
530
|
-
onDelete?: string | undefined;
|
|
531
531
|
}>;
|
|
532
532
|
}, {
|
|
533
533
|
name: string;
|
|
534
534
|
columns: Record<string, {
|
|
535
|
+
default?: any;
|
|
536
|
+
onUpdate?: any;
|
|
537
|
+
autoincrement?: boolean | undefined;
|
|
535
538
|
name: string;
|
|
536
539
|
type: string;
|
|
537
540
|
primaryKey: boolean;
|
|
538
541
|
notNull: boolean;
|
|
539
|
-
default?: any;
|
|
540
|
-
onUpdate?: any;
|
|
541
|
-
autoincrement?: boolean | undefined;
|
|
542
542
|
}>;
|
|
543
543
|
indexes: Record<string, {
|
|
544
|
-
name: string;
|
|
545
|
-
columns: string[];
|
|
546
|
-
isUnique: boolean;
|
|
547
544
|
using?: "btree" | "hash" | undefined;
|
|
548
545
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
549
546
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
547
|
+
name: string;
|
|
548
|
+
columns: string[];
|
|
549
|
+
isUnique: boolean;
|
|
550
550
|
}>;
|
|
551
551
|
foreignKeys: Record<string, {
|
|
552
|
+
onUpdate?: string | undefined;
|
|
553
|
+
onDelete?: string | undefined;
|
|
552
554
|
name: string;
|
|
553
555
|
tableFrom: string;
|
|
554
556
|
columnsFrom: string[];
|
|
555
557
|
tableTo: string;
|
|
556
558
|
columnsTo: string[];
|
|
557
|
-
onUpdate?: string | undefined;
|
|
558
|
-
onDelete?: string | undefined;
|
|
559
559
|
}>;
|
|
560
560
|
}>>;
|
|
561
561
|
}, "strict", import("zod").ZodTypeAny, {
|
|
562
562
|
tables: Record<string, {
|
|
563
563
|
name: string;
|
|
564
564
|
columns: Record<string, {
|
|
565
|
+
default?: any;
|
|
566
|
+
onUpdate?: any;
|
|
567
|
+
autoincrement?: boolean | undefined;
|
|
565
568
|
name: string;
|
|
566
569
|
type: string;
|
|
567
570
|
primaryKey: boolean;
|
|
568
571
|
notNull: boolean;
|
|
569
|
-
default?: any;
|
|
570
|
-
onUpdate?: any;
|
|
571
|
-
autoincrement?: boolean | undefined;
|
|
572
572
|
}>;
|
|
573
573
|
indexes: Record<string, {
|
|
574
|
-
name: string;
|
|
575
|
-
columns: string[];
|
|
576
|
-
isUnique: boolean;
|
|
577
574
|
using?: "btree" | "hash" | undefined;
|
|
578
575
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
579
576
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
577
|
+
name: string;
|
|
578
|
+
columns: string[];
|
|
579
|
+
isUnique: boolean;
|
|
580
580
|
}>;
|
|
581
581
|
foreignKeys: Record<string, {
|
|
582
|
+
onUpdate?: string | undefined;
|
|
583
|
+
onDelete?: string | undefined;
|
|
582
584
|
name: string;
|
|
583
585
|
tableFrom: string;
|
|
584
586
|
columnsFrom: string[];
|
|
585
587
|
tableTo: string;
|
|
586
588
|
columnsTo: string[];
|
|
587
|
-
onUpdate?: string | undefined;
|
|
588
|
-
onDelete?: string | undefined;
|
|
589
589
|
}>;
|
|
590
590
|
}>;
|
|
591
591
|
version: "3";
|
|
@@ -594,30 +594,30 @@ export declare const schemaInternalV3: import("zod").ZodObject<{
|
|
|
594
594
|
tables: Record<string, {
|
|
595
595
|
name: string;
|
|
596
596
|
columns: Record<string, {
|
|
597
|
+
default?: any;
|
|
598
|
+
onUpdate?: any;
|
|
599
|
+
autoincrement?: boolean | undefined;
|
|
597
600
|
name: string;
|
|
598
601
|
type: string;
|
|
599
602
|
primaryKey: boolean;
|
|
600
603
|
notNull: boolean;
|
|
601
|
-
default?: any;
|
|
602
|
-
onUpdate?: any;
|
|
603
|
-
autoincrement?: boolean | undefined;
|
|
604
604
|
}>;
|
|
605
605
|
indexes: Record<string, {
|
|
606
|
-
name: string;
|
|
607
|
-
columns: string[];
|
|
608
|
-
isUnique: boolean;
|
|
609
606
|
using?: "btree" | "hash" | undefined;
|
|
610
607
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
611
608
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
609
|
+
name: string;
|
|
610
|
+
columns: string[];
|
|
611
|
+
isUnique: boolean;
|
|
612
612
|
}>;
|
|
613
613
|
foreignKeys: Record<string, {
|
|
614
|
+
onUpdate?: string | undefined;
|
|
615
|
+
onDelete?: string | undefined;
|
|
614
616
|
name: string;
|
|
615
617
|
tableFrom: string;
|
|
616
618
|
columnsFrom: string[];
|
|
617
619
|
tableTo: string;
|
|
618
620
|
columnsTo: string[];
|
|
619
|
-
onUpdate?: string | undefined;
|
|
620
|
-
onDelete?: string | undefined;
|
|
621
621
|
}>;
|
|
622
622
|
}>;
|
|
623
623
|
version: "3";
|
|
@@ -638,21 +638,21 @@ export declare const schemaInternalV4: import("zod").ZodObject<{
|
|
|
638
638
|
default: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
639
639
|
onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
640
640
|
}, "strict", import("zod").ZodTypeAny, {
|
|
641
|
+
default?: any;
|
|
642
|
+
onUpdate?: any;
|
|
643
|
+
autoincrement?: boolean | undefined;
|
|
641
644
|
name: string;
|
|
642
645
|
type: string;
|
|
643
646
|
primaryKey: boolean;
|
|
644
647
|
notNull: boolean;
|
|
648
|
+
}, {
|
|
645
649
|
default?: any;
|
|
646
650
|
onUpdate?: any;
|
|
647
651
|
autoincrement?: boolean | undefined;
|
|
648
|
-
}, {
|
|
649
652
|
name: string;
|
|
650
653
|
type: string;
|
|
651
654
|
primaryKey: boolean;
|
|
652
655
|
notNull: boolean;
|
|
653
|
-
default?: any;
|
|
654
|
-
onUpdate?: any;
|
|
655
|
-
autoincrement?: boolean | undefined;
|
|
656
656
|
}>>;
|
|
657
657
|
indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
658
658
|
name: import("zod").ZodString;
|
|
@@ -662,19 +662,19 @@ export declare const schemaInternalV4: import("zod").ZodObject<{
|
|
|
662
662
|
algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
|
|
663
663
|
lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
|
|
664
664
|
}, "strict", import("zod").ZodTypeAny, {
|
|
665
|
-
name: string;
|
|
666
|
-
columns: string[];
|
|
667
|
-
isUnique: boolean;
|
|
668
665
|
using?: "btree" | "hash" | undefined;
|
|
669
666
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
670
667
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
671
|
-
}, {
|
|
672
668
|
name: string;
|
|
673
669
|
columns: string[];
|
|
674
670
|
isUnique: boolean;
|
|
671
|
+
}, {
|
|
675
672
|
using?: "btree" | "hash" | undefined;
|
|
676
673
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
677
674
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
675
|
+
name: string;
|
|
676
|
+
columns: string[];
|
|
677
|
+
isUnique: boolean;
|
|
678
678
|
}>>;
|
|
679
679
|
foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
680
680
|
name: import("zod").ZodString;
|
|
@@ -685,146 +685,146 @@ export declare const schemaInternalV4: import("zod").ZodObject<{
|
|
|
685
685
|
onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
|
|
686
686
|
onDelete: import("zod").ZodOptional<import("zod").ZodString>;
|
|
687
687
|
}, "strict", import("zod").ZodTypeAny, {
|
|
688
|
+
onUpdate?: string | undefined;
|
|
689
|
+
onDelete?: string | undefined;
|
|
688
690
|
name: string;
|
|
689
691
|
tableFrom: string;
|
|
690
692
|
columnsFrom: string[];
|
|
691
693
|
tableTo: string;
|
|
692
694
|
columnsTo: string[];
|
|
695
|
+
}, {
|
|
693
696
|
onUpdate?: string | undefined;
|
|
694
697
|
onDelete?: string | undefined;
|
|
695
|
-
}, {
|
|
696
698
|
name: string;
|
|
697
699
|
tableFrom: string;
|
|
698
700
|
columnsFrom: string[];
|
|
699
701
|
tableTo: string;
|
|
700
702
|
columnsTo: string[];
|
|
701
|
-
onUpdate?: string | undefined;
|
|
702
|
-
onDelete?: string | undefined;
|
|
703
703
|
}>>;
|
|
704
704
|
}, "strict", import("zod").ZodTypeAny, {
|
|
705
|
+
schema?: string | undefined;
|
|
705
706
|
name: string;
|
|
706
707
|
columns: Record<string, {
|
|
708
|
+
default?: any;
|
|
709
|
+
onUpdate?: any;
|
|
710
|
+
autoincrement?: boolean | undefined;
|
|
707
711
|
name: string;
|
|
708
712
|
type: string;
|
|
709
713
|
primaryKey: boolean;
|
|
710
714
|
notNull: boolean;
|
|
711
|
-
default?: any;
|
|
712
|
-
onUpdate?: any;
|
|
713
|
-
autoincrement?: boolean | undefined;
|
|
714
715
|
}>;
|
|
715
716
|
indexes: Record<string, {
|
|
716
|
-
name: string;
|
|
717
|
-
columns: string[];
|
|
718
|
-
isUnique: boolean;
|
|
719
717
|
using?: "btree" | "hash" | undefined;
|
|
720
718
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
721
719
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
720
|
+
name: string;
|
|
721
|
+
columns: string[];
|
|
722
|
+
isUnique: boolean;
|
|
722
723
|
}>;
|
|
723
724
|
foreignKeys: Record<string, {
|
|
725
|
+
onUpdate?: string | undefined;
|
|
726
|
+
onDelete?: string | undefined;
|
|
724
727
|
name: string;
|
|
725
728
|
tableFrom: string;
|
|
726
729
|
columnsFrom: string[];
|
|
727
730
|
tableTo: string;
|
|
728
731
|
columnsTo: string[];
|
|
729
|
-
onUpdate?: string | undefined;
|
|
730
|
-
onDelete?: string | undefined;
|
|
731
732
|
}>;
|
|
732
|
-
schema?: string | undefined;
|
|
733
733
|
}, {
|
|
734
|
+
schema?: string | undefined;
|
|
734
735
|
name: string;
|
|
735
736
|
columns: Record<string, {
|
|
737
|
+
default?: any;
|
|
738
|
+
onUpdate?: any;
|
|
739
|
+
autoincrement?: boolean | undefined;
|
|
736
740
|
name: string;
|
|
737
741
|
type: string;
|
|
738
742
|
primaryKey: boolean;
|
|
739
743
|
notNull: boolean;
|
|
740
|
-
default?: any;
|
|
741
|
-
onUpdate?: any;
|
|
742
|
-
autoincrement?: boolean | undefined;
|
|
743
744
|
}>;
|
|
744
745
|
indexes: Record<string, {
|
|
745
|
-
name: string;
|
|
746
|
-
columns: string[];
|
|
747
|
-
isUnique: boolean;
|
|
748
746
|
using?: "btree" | "hash" | undefined;
|
|
749
747
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
750
748
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
749
|
+
name: string;
|
|
750
|
+
columns: string[];
|
|
751
|
+
isUnique: boolean;
|
|
751
752
|
}>;
|
|
752
753
|
foreignKeys: Record<string, {
|
|
754
|
+
onUpdate?: string | undefined;
|
|
755
|
+
onDelete?: string | undefined;
|
|
753
756
|
name: string;
|
|
754
757
|
tableFrom: string;
|
|
755
758
|
columnsFrom: string[];
|
|
756
759
|
tableTo: string;
|
|
757
760
|
columnsTo: string[];
|
|
758
|
-
onUpdate?: string | undefined;
|
|
759
|
-
onDelete?: string | undefined;
|
|
760
761
|
}>;
|
|
761
|
-
schema?: string | undefined;
|
|
762
762
|
}>>;
|
|
763
763
|
schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
|
|
764
764
|
}, "strict", import("zod").ZodTypeAny, {
|
|
765
765
|
tables: Record<string, {
|
|
766
|
+
schema?: string | undefined;
|
|
766
767
|
name: string;
|
|
767
768
|
columns: Record<string, {
|
|
769
|
+
default?: any;
|
|
770
|
+
onUpdate?: any;
|
|
771
|
+
autoincrement?: boolean | undefined;
|
|
768
772
|
name: string;
|
|
769
773
|
type: string;
|
|
770
774
|
primaryKey: boolean;
|
|
771
775
|
notNull: boolean;
|
|
772
|
-
default?: any;
|
|
773
|
-
onUpdate?: any;
|
|
774
|
-
autoincrement?: boolean | undefined;
|
|
775
776
|
}>;
|
|
776
777
|
indexes: Record<string, {
|
|
777
|
-
name: string;
|
|
778
|
-
columns: string[];
|
|
779
|
-
isUnique: boolean;
|
|
780
778
|
using?: "btree" | "hash" | undefined;
|
|
781
779
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
782
780
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
781
|
+
name: string;
|
|
782
|
+
columns: string[];
|
|
783
|
+
isUnique: boolean;
|
|
783
784
|
}>;
|
|
784
785
|
foreignKeys: Record<string, {
|
|
786
|
+
onUpdate?: string | undefined;
|
|
787
|
+
onDelete?: string | undefined;
|
|
785
788
|
name: string;
|
|
786
789
|
tableFrom: string;
|
|
787
790
|
columnsFrom: string[];
|
|
788
791
|
tableTo: string;
|
|
789
792
|
columnsTo: string[];
|
|
790
|
-
onUpdate?: string | undefined;
|
|
791
|
-
onDelete?: string | undefined;
|
|
792
793
|
}>;
|
|
793
|
-
schema?: string | undefined;
|
|
794
794
|
}>;
|
|
795
795
|
version: "4";
|
|
796
796
|
dialect: "mysql";
|
|
797
797
|
schemas: Record<string, string>;
|
|
798
798
|
}, {
|
|
799
799
|
tables: Record<string, {
|
|
800
|
+
schema?: string | undefined;
|
|
800
801
|
name: string;
|
|
801
802
|
columns: Record<string, {
|
|
803
|
+
default?: any;
|
|
804
|
+
onUpdate?: any;
|
|
805
|
+
autoincrement?: boolean | undefined;
|
|
802
806
|
name: string;
|
|
803
807
|
type: string;
|
|
804
808
|
primaryKey: boolean;
|
|
805
809
|
notNull: boolean;
|
|
806
|
-
default?: any;
|
|
807
|
-
onUpdate?: any;
|
|
808
|
-
autoincrement?: boolean | undefined;
|
|
809
810
|
}>;
|
|
810
811
|
indexes: Record<string, {
|
|
811
|
-
name: string;
|
|
812
|
-
columns: string[];
|
|
813
|
-
isUnique: boolean;
|
|
814
812
|
using?: "btree" | "hash" | undefined;
|
|
815
813
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
816
814
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
815
|
+
name: string;
|
|
816
|
+
columns: string[];
|
|
817
|
+
isUnique: boolean;
|
|
817
818
|
}>;
|
|
818
819
|
foreignKeys: Record<string, {
|
|
820
|
+
onUpdate?: string | undefined;
|
|
821
|
+
onDelete?: string | undefined;
|
|
819
822
|
name: string;
|
|
820
823
|
tableFrom: string;
|
|
821
824
|
columnsFrom: string[];
|
|
822
825
|
tableTo: string;
|
|
823
826
|
columnsTo: string[];
|
|
824
|
-
onUpdate?: string | undefined;
|
|
825
|
-
onDelete?: string | undefined;
|
|
826
827
|
}>;
|
|
827
|
-
schema?: string | undefined;
|
|
828
828
|
}>;
|
|
829
829
|
version: "4";
|
|
830
830
|
dialect: "mysql";
|
|
@@ -844,21 +844,21 @@ export declare const schemaInternalV5: import("zod").ZodObject<{
|
|
|
844
844
|
default: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
845
845
|
onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
846
846
|
}, "strict", import("zod").ZodTypeAny, {
|
|
847
|
+
default?: any;
|
|
848
|
+
onUpdate?: any;
|
|
849
|
+
autoincrement?: boolean | undefined;
|
|
847
850
|
name: string;
|
|
848
851
|
type: string;
|
|
849
852
|
primaryKey: boolean;
|
|
850
853
|
notNull: boolean;
|
|
854
|
+
}, {
|
|
851
855
|
default?: any;
|
|
852
856
|
onUpdate?: any;
|
|
853
857
|
autoincrement?: boolean | undefined;
|
|
854
|
-
}, {
|
|
855
858
|
name: string;
|
|
856
859
|
type: string;
|
|
857
860
|
primaryKey: boolean;
|
|
858
861
|
notNull: boolean;
|
|
859
|
-
default?: any;
|
|
860
|
-
onUpdate?: any;
|
|
861
|
-
autoincrement?: boolean | undefined;
|
|
862
862
|
}>>;
|
|
863
863
|
indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
864
864
|
name: import("zod").ZodString;
|
|
@@ -868,19 +868,19 @@ export declare const schemaInternalV5: import("zod").ZodObject<{
|
|
|
868
868
|
algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
|
|
869
869
|
lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
|
|
870
870
|
}, "strict", import("zod").ZodTypeAny, {
|
|
871
|
-
name: string;
|
|
872
|
-
columns: string[];
|
|
873
|
-
isUnique: boolean;
|
|
874
871
|
using?: "btree" | "hash" | undefined;
|
|
875
872
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
876
873
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
877
|
-
}, {
|
|
878
874
|
name: string;
|
|
879
875
|
columns: string[];
|
|
880
876
|
isUnique: boolean;
|
|
877
|
+
}, {
|
|
881
878
|
using?: "btree" | "hash" | undefined;
|
|
882
879
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
883
880
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
881
|
+
name: string;
|
|
882
|
+
columns: string[];
|
|
883
|
+
isUnique: boolean;
|
|
884
884
|
}>>;
|
|
885
885
|
foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
886
886
|
name: import("zod").ZodString;
|
|
@@ -891,21 +891,21 @@ export declare const schemaInternalV5: import("zod").ZodObject<{
|
|
|
891
891
|
onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
|
|
892
892
|
onDelete: import("zod").ZodOptional<import("zod").ZodString>;
|
|
893
893
|
}, "strict", import("zod").ZodTypeAny, {
|
|
894
|
+
onUpdate?: string | undefined;
|
|
895
|
+
onDelete?: string | undefined;
|
|
894
896
|
name: string;
|
|
895
897
|
tableFrom: string;
|
|
896
898
|
columnsFrom: string[];
|
|
897
899
|
tableTo: string;
|
|
898
900
|
columnsTo: string[];
|
|
901
|
+
}, {
|
|
899
902
|
onUpdate?: string | undefined;
|
|
900
903
|
onDelete?: string | undefined;
|
|
901
|
-
}, {
|
|
902
904
|
name: string;
|
|
903
905
|
tableFrom: string;
|
|
904
906
|
columnsFrom: string[];
|
|
905
907
|
tableTo: string;
|
|
906
908
|
columnsTo: string[];
|
|
907
|
-
onUpdate?: string | undefined;
|
|
908
|
-
onDelete?: string | undefined;
|
|
909
909
|
}>>;
|
|
910
910
|
compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
911
911
|
name: import("zod").ZodString;
|
|
@@ -930,30 +930,30 @@ export declare const schemaInternalV5: import("zod").ZodObject<{
|
|
|
930
930
|
}, "strict", import("zod").ZodTypeAny, {
|
|
931
931
|
name: string;
|
|
932
932
|
columns: Record<string, {
|
|
933
|
+
default?: any;
|
|
934
|
+
onUpdate?: any;
|
|
935
|
+
autoincrement?: boolean | undefined;
|
|
933
936
|
name: string;
|
|
934
937
|
type: string;
|
|
935
938
|
primaryKey: boolean;
|
|
936
939
|
notNull: boolean;
|
|
937
|
-
default?: any;
|
|
938
|
-
onUpdate?: any;
|
|
939
|
-
autoincrement?: boolean | undefined;
|
|
940
940
|
}>;
|
|
941
941
|
indexes: Record<string, {
|
|
942
|
-
name: string;
|
|
943
|
-
columns: string[];
|
|
944
|
-
isUnique: boolean;
|
|
945
942
|
using?: "btree" | "hash" | undefined;
|
|
946
943
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
947
944
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
945
|
+
name: string;
|
|
946
|
+
columns: string[];
|
|
947
|
+
isUnique: boolean;
|
|
948
948
|
}>;
|
|
949
949
|
foreignKeys: Record<string, {
|
|
950
|
+
onUpdate?: string | undefined;
|
|
951
|
+
onDelete?: string | undefined;
|
|
950
952
|
name: string;
|
|
951
953
|
tableFrom: string;
|
|
952
954
|
columnsFrom: string[];
|
|
953
955
|
tableTo: string;
|
|
954
956
|
columnsTo: string[];
|
|
955
|
-
onUpdate?: string | undefined;
|
|
956
|
-
onDelete?: string | undefined;
|
|
957
957
|
}>;
|
|
958
958
|
compositePrimaryKeys: Record<string, {
|
|
959
959
|
name: string;
|
|
@@ -964,41 +964,41 @@ export declare const schemaInternalV5: import("zod").ZodObject<{
|
|
|
964
964
|
columns: string[];
|
|
965
965
|
}>;
|
|
966
966
|
}, {
|
|
967
|
+
uniqueConstraints?: Record<string, {
|
|
968
|
+
name: string;
|
|
969
|
+
columns: string[];
|
|
970
|
+
}> | undefined;
|
|
967
971
|
name: string;
|
|
968
972
|
columns: Record<string, {
|
|
973
|
+
default?: any;
|
|
974
|
+
onUpdate?: any;
|
|
975
|
+
autoincrement?: boolean | undefined;
|
|
969
976
|
name: string;
|
|
970
977
|
type: string;
|
|
971
978
|
primaryKey: boolean;
|
|
972
979
|
notNull: boolean;
|
|
973
|
-
default?: any;
|
|
974
|
-
onUpdate?: any;
|
|
975
|
-
autoincrement?: boolean | undefined;
|
|
976
980
|
}>;
|
|
977
981
|
indexes: Record<string, {
|
|
978
|
-
name: string;
|
|
979
|
-
columns: string[];
|
|
980
|
-
isUnique: boolean;
|
|
981
982
|
using?: "btree" | "hash" | undefined;
|
|
982
983
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
983
984
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
985
|
+
name: string;
|
|
986
|
+
columns: string[];
|
|
987
|
+
isUnique: boolean;
|
|
984
988
|
}>;
|
|
985
989
|
foreignKeys: Record<string, {
|
|
990
|
+
onUpdate?: string | undefined;
|
|
991
|
+
onDelete?: string | undefined;
|
|
986
992
|
name: string;
|
|
987
993
|
tableFrom: string;
|
|
988
994
|
columnsFrom: string[];
|
|
989
995
|
tableTo: string;
|
|
990
996
|
columnsTo: string[];
|
|
991
|
-
onUpdate?: string | undefined;
|
|
992
|
-
onDelete?: string | undefined;
|
|
993
997
|
}>;
|
|
994
998
|
compositePrimaryKeys: Record<string, {
|
|
995
999
|
name: string;
|
|
996
1000
|
columns: string[];
|
|
997
1001
|
}>;
|
|
998
|
-
uniqueConstraints?: Record<string, {
|
|
999
|
-
name: string;
|
|
1000
|
-
columns: string[];
|
|
1001
|
-
}> | undefined;
|
|
1002
1002
|
}>>;
|
|
1003
1003
|
schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
|
|
1004
1004
|
_meta: import("zod").ZodObject<{
|
|
@@ -1046,33 +1046,40 @@ export declare const schemaInternalV5: import("zod").ZodObject<{
|
|
|
1046
1046
|
} | undefined>;
|
|
1047
1047
|
}>>;
|
|
1048
1048
|
}, "strict", import("zod").ZodTypeAny, {
|
|
1049
|
+
internal?: {
|
|
1050
|
+
tables: Record<string, {
|
|
1051
|
+
columns: Record<string, {
|
|
1052
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
1053
|
+
} | undefined>;
|
|
1054
|
+
} | undefined>;
|
|
1055
|
+
} | undefined;
|
|
1049
1056
|
tables: Record<string, {
|
|
1050
1057
|
name: string;
|
|
1051
1058
|
columns: Record<string, {
|
|
1059
|
+
default?: any;
|
|
1060
|
+
onUpdate?: any;
|
|
1061
|
+
autoincrement?: boolean | undefined;
|
|
1052
1062
|
name: string;
|
|
1053
1063
|
type: string;
|
|
1054
1064
|
primaryKey: boolean;
|
|
1055
1065
|
notNull: boolean;
|
|
1056
|
-
default?: any;
|
|
1057
|
-
onUpdate?: any;
|
|
1058
|
-
autoincrement?: boolean | undefined;
|
|
1059
1066
|
}>;
|
|
1060
1067
|
indexes: Record<string, {
|
|
1061
|
-
name: string;
|
|
1062
|
-
columns: string[];
|
|
1063
|
-
isUnique: boolean;
|
|
1064
1068
|
using?: "btree" | "hash" | undefined;
|
|
1065
1069
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1066
1070
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1071
|
+
name: string;
|
|
1072
|
+
columns: string[];
|
|
1073
|
+
isUnique: boolean;
|
|
1067
1074
|
}>;
|
|
1068
1075
|
foreignKeys: Record<string, {
|
|
1076
|
+
onUpdate?: string | undefined;
|
|
1077
|
+
onDelete?: string | undefined;
|
|
1069
1078
|
name: string;
|
|
1070
1079
|
tableFrom: string;
|
|
1071
1080
|
columnsFrom: string[];
|
|
1072
1081
|
tableTo: string;
|
|
1073
1082
|
columnsTo: string[];
|
|
1074
|
-
onUpdate?: string | undefined;
|
|
1075
|
-
onDelete?: string | undefined;
|
|
1076
1083
|
}>;
|
|
1077
1084
|
compositePrimaryKeys: Record<string, {
|
|
1078
1085
|
name: string;
|
|
@@ -1091,6 +1098,7 @@ export declare const schemaInternalV5: import("zod").ZodObject<{
|
|
|
1091
1098
|
tables: Record<string, string>;
|
|
1092
1099
|
schemas: Record<string, string>;
|
|
1093
1100
|
};
|
|
1101
|
+
}, {
|
|
1094
1102
|
internal?: {
|
|
1095
1103
|
tables: Record<string, {
|
|
1096
1104
|
columns: Record<string, {
|
|
@@ -1098,43 +1106,42 @@ export declare const schemaInternalV5: import("zod").ZodObject<{
|
|
|
1098
1106
|
} | undefined>;
|
|
1099
1107
|
} | undefined>;
|
|
1100
1108
|
} | undefined;
|
|
1101
|
-
}, {
|
|
1102
1109
|
tables: Record<string, {
|
|
1110
|
+
uniqueConstraints?: Record<string, {
|
|
1111
|
+
name: string;
|
|
1112
|
+
columns: string[];
|
|
1113
|
+
}> | undefined;
|
|
1103
1114
|
name: string;
|
|
1104
1115
|
columns: Record<string, {
|
|
1116
|
+
default?: any;
|
|
1117
|
+
onUpdate?: any;
|
|
1118
|
+
autoincrement?: boolean | undefined;
|
|
1105
1119
|
name: string;
|
|
1106
1120
|
type: string;
|
|
1107
1121
|
primaryKey: boolean;
|
|
1108
1122
|
notNull: boolean;
|
|
1109
|
-
default?: any;
|
|
1110
|
-
onUpdate?: any;
|
|
1111
|
-
autoincrement?: boolean | undefined;
|
|
1112
1123
|
}>;
|
|
1113
1124
|
indexes: Record<string, {
|
|
1114
|
-
name: string;
|
|
1115
|
-
columns: string[];
|
|
1116
|
-
isUnique: boolean;
|
|
1117
1125
|
using?: "btree" | "hash" | undefined;
|
|
1118
1126
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1119
1127
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1128
|
+
name: string;
|
|
1129
|
+
columns: string[];
|
|
1130
|
+
isUnique: boolean;
|
|
1120
1131
|
}>;
|
|
1121
1132
|
foreignKeys: Record<string, {
|
|
1133
|
+
onUpdate?: string | undefined;
|
|
1134
|
+
onDelete?: string | undefined;
|
|
1122
1135
|
name: string;
|
|
1123
1136
|
tableFrom: string;
|
|
1124
1137
|
columnsFrom: string[];
|
|
1125
1138
|
tableTo: string;
|
|
1126
1139
|
columnsTo: string[];
|
|
1127
|
-
onUpdate?: string | undefined;
|
|
1128
|
-
onDelete?: string | undefined;
|
|
1129
1140
|
}>;
|
|
1130
1141
|
compositePrimaryKeys: Record<string, {
|
|
1131
1142
|
name: string;
|
|
1132
1143
|
columns: string[];
|
|
1133
1144
|
}>;
|
|
1134
|
-
uniqueConstraints?: Record<string, {
|
|
1135
|
-
name: string;
|
|
1136
|
-
columns: string[];
|
|
1137
|
-
}> | undefined;
|
|
1138
1145
|
}>;
|
|
1139
1146
|
version: "5";
|
|
1140
1147
|
dialect: "mysql";
|
|
@@ -1144,13 +1151,6 @@ export declare const schemaInternalV5: import("zod").ZodObject<{
|
|
|
1144
1151
|
tables: Record<string, string>;
|
|
1145
1152
|
schemas: Record<string, string>;
|
|
1146
1153
|
};
|
|
1147
|
-
internal?: {
|
|
1148
|
-
tables: Record<string, {
|
|
1149
|
-
columns: Record<string, {
|
|
1150
|
-
isDefaultAnExpression?: boolean | undefined;
|
|
1151
|
-
} | undefined>;
|
|
1152
|
-
} | undefined>;
|
|
1153
|
-
} | undefined;
|
|
1154
1154
|
}>;
|
|
1155
1155
|
export declare const schemaInternal: import("zod").ZodObject<{
|
|
1156
1156
|
version: import("zod").ZodLiteral<"5">;
|
|
@@ -1166,21 +1166,21 @@ export declare const schemaInternal: import("zod").ZodObject<{
|
|
|
1166
1166
|
default: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
1167
1167
|
onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
1168
1168
|
}, "strict", import("zod").ZodTypeAny, {
|
|
1169
|
+
default?: any;
|
|
1170
|
+
onUpdate?: any;
|
|
1171
|
+
autoincrement?: boolean | undefined;
|
|
1169
1172
|
name: string;
|
|
1170
1173
|
type: string;
|
|
1171
1174
|
primaryKey: boolean;
|
|
1172
1175
|
notNull: boolean;
|
|
1176
|
+
}, {
|
|
1173
1177
|
default?: any;
|
|
1174
1178
|
onUpdate?: any;
|
|
1175
1179
|
autoincrement?: boolean | undefined;
|
|
1176
|
-
}, {
|
|
1177
1180
|
name: string;
|
|
1178
1181
|
type: string;
|
|
1179
1182
|
primaryKey: boolean;
|
|
1180
1183
|
notNull: boolean;
|
|
1181
|
-
default?: any;
|
|
1182
|
-
onUpdate?: any;
|
|
1183
|
-
autoincrement?: boolean | undefined;
|
|
1184
1184
|
}>>;
|
|
1185
1185
|
indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
1186
1186
|
name: import("zod").ZodString;
|
|
@@ -1190,19 +1190,19 @@ export declare const schemaInternal: import("zod").ZodObject<{
|
|
|
1190
1190
|
algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
|
|
1191
1191
|
lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
|
|
1192
1192
|
}, "strict", import("zod").ZodTypeAny, {
|
|
1193
|
-
name: string;
|
|
1194
|
-
columns: string[];
|
|
1195
|
-
isUnique: boolean;
|
|
1196
1193
|
using?: "btree" | "hash" | undefined;
|
|
1197
1194
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1198
1195
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1199
|
-
}, {
|
|
1200
1196
|
name: string;
|
|
1201
1197
|
columns: string[];
|
|
1202
1198
|
isUnique: boolean;
|
|
1199
|
+
}, {
|
|
1203
1200
|
using?: "btree" | "hash" | undefined;
|
|
1204
1201
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1205
1202
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1203
|
+
name: string;
|
|
1204
|
+
columns: string[];
|
|
1205
|
+
isUnique: boolean;
|
|
1206
1206
|
}>>;
|
|
1207
1207
|
foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
1208
1208
|
name: import("zod").ZodString;
|
|
@@ -1213,21 +1213,21 @@ export declare const schemaInternal: import("zod").ZodObject<{
|
|
|
1213
1213
|
onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
|
|
1214
1214
|
onDelete: import("zod").ZodOptional<import("zod").ZodString>;
|
|
1215
1215
|
}, "strict", import("zod").ZodTypeAny, {
|
|
1216
|
+
onUpdate?: string | undefined;
|
|
1217
|
+
onDelete?: string | undefined;
|
|
1216
1218
|
name: string;
|
|
1217
1219
|
tableFrom: string;
|
|
1218
1220
|
columnsFrom: string[];
|
|
1219
1221
|
tableTo: string;
|
|
1220
1222
|
columnsTo: string[];
|
|
1223
|
+
}, {
|
|
1221
1224
|
onUpdate?: string | undefined;
|
|
1222
1225
|
onDelete?: string | undefined;
|
|
1223
|
-
}, {
|
|
1224
1226
|
name: string;
|
|
1225
1227
|
tableFrom: string;
|
|
1226
1228
|
columnsFrom: string[];
|
|
1227
1229
|
tableTo: string;
|
|
1228
1230
|
columnsTo: string[];
|
|
1229
|
-
onUpdate?: string | undefined;
|
|
1230
|
-
onDelete?: string | undefined;
|
|
1231
1231
|
}>>;
|
|
1232
1232
|
compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
1233
1233
|
name: import("zod").ZodString;
|
|
@@ -1252,30 +1252,30 @@ export declare const schemaInternal: import("zod").ZodObject<{
|
|
|
1252
1252
|
}, "strict", import("zod").ZodTypeAny, {
|
|
1253
1253
|
name: string;
|
|
1254
1254
|
columns: Record<string, {
|
|
1255
|
+
default?: any;
|
|
1256
|
+
onUpdate?: any;
|
|
1257
|
+
autoincrement?: boolean | undefined;
|
|
1255
1258
|
name: string;
|
|
1256
1259
|
type: string;
|
|
1257
1260
|
primaryKey: boolean;
|
|
1258
1261
|
notNull: boolean;
|
|
1259
|
-
default?: any;
|
|
1260
|
-
onUpdate?: any;
|
|
1261
|
-
autoincrement?: boolean | undefined;
|
|
1262
1262
|
}>;
|
|
1263
1263
|
indexes: Record<string, {
|
|
1264
|
-
name: string;
|
|
1265
|
-
columns: string[];
|
|
1266
|
-
isUnique: boolean;
|
|
1267
1264
|
using?: "btree" | "hash" | undefined;
|
|
1268
1265
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1269
1266
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1267
|
+
name: string;
|
|
1268
|
+
columns: string[];
|
|
1269
|
+
isUnique: boolean;
|
|
1270
1270
|
}>;
|
|
1271
1271
|
foreignKeys: Record<string, {
|
|
1272
|
+
onUpdate?: string | undefined;
|
|
1273
|
+
onDelete?: string | undefined;
|
|
1272
1274
|
name: string;
|
|
1273
1275
|
tableFrom: string;
|
|
1274
1276
|
columnsFrom: string[];
|
|
1275
1277
|
tableTo: string;
|
|
1276
1278
|
columnsTo: string[];
|
|
1277
|
-
onUpdate?: string | undefined;
|
|
1278
|
-
onDelete?: string | undefined;
|
|
1279
1279
|
}>;
|
|
1280
1280
|
compositePrimaryKeys: Record<string, {
|
|
1281
1281
|
name: string;
|
|
@@ -1286,41 +1286,41 @@ export declare const schemaInternal: import("zod").ZodObject<{
|
|
|
1286
1286
|
columns: string[];
|
|
1287
1287
|
}>;
|
|
1288
1288
|
}, {
|
|
1289
|
+
uniqueConstraints?: Record<string, {
|
|
1290
|
+
name: string;
|
|
1291
|
+
columns: string[];
|
|
1292
|
+
}> | undefined;
|
|
1289
1293
|
name: string;
|
|
1290
1294
|
columns: Record<string, {
|
|
1295
|
+
default?: any;
|
|
1296
|
+
onUpdate?: any;
|
|
1297
|
+
autoincrement?: boolean | undefined;
|
|
1291
1298
|
name: string;
|
|
1292
1299
|
type: string;
|
|
1293
1300
|
primaryKey: boolean;
|
|
1294
1301
|
notNull: boolean;
|
|
1295
|
-
default?: any;
|
|
1296
|
-
onUpdate?: any;
|
|
1297
|
-
autoincrement?: boolean | undefined;
|
|
1298
1302
|
}>;
|
|
1299
1303
|
indexes: Record<string, {
|
|
1300
|
-
name: string;
|
|
1301
|
-
columns: string[];
|
|
1302
|
-
isUnique: boolean;
|
|
1303
1304
|
using?: "btree" | "hash" | undefined;
|
|
1304
1305
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1305
1306
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1307
|
+
name: string;
|
|
1308
|
+
columns: string[];
|
|
1309
|
+
isUnique: boolean;
|
|
1306
1310
|
}>;
|
|
1307
1311
|
foreignKeys: Record<string, {
|
|
1312
|
+
onUpdate?: string | undefined;
|
|
1313
|
+
onDelete?: string | undefined;
|
|
1308
1314
|
name: string;
|
|
1309
1315
|
tableFrom: string;
|
|
1310
1316
|
columnsFrom: string[];
|
|
1311
1317
|
tableTo: string;
|
|
1312
1318
|
columnsTo: string[];
|
|
1313
|
-
onUpdate?: string | undefined;
|
|
1314
|
-
onDelete?: string | undefined;
|
|
1315
1319
|
}>;
|
|
1316
1320
|
compositePrimaryKeys: Record<string, {
|
|
1317
1321
|
name: string;
|
|
1318
1322
|
columns: string[];
|
|
1319
1323
|
}>;
|
|
1320
|
-
uniqueConstraints?: Record<string, {
|
|
1321
|
-
name: string;
|
|
1322
|
-
columns: string[];
|
|
1323
|
-
}> | undefined;
|
|
1324
1324
|
}>>;
|
|
1325
1325
|
_meta: import("zod").ZodObject<{
|
|
1326
1326
|
tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
|
|
@@ -1364,33 +1364,40 @@ export declare const schemaInternal: import("zod").ZodObject<{
|
|
|
1364
1364
|
} | undefined>;
|
|
1365
1365
|
}>>;
|
|
1366
1366
|
}, "strict", import("zod").ZodTypeAny, {
|
|
1367
|
+
internal?: {
|
|
1368
|
+
tables: Record<string, {
|
|
1369
|
+
columns: Record<string, {
|
|
1370
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
1371
|
+
} | undefined>;
|
|
1372
|
+
} | undefined>;
|
|
1373
|
+
} | undefined;
|
|
1367
1374
|
tables: Record<string, {
|
|
1368
1375
|
name: string;
|
|
1369
1376
|
columns: Record<string, {
|
|
1377
|
+
default?: any;
|
|
1378
|
+
onUpdate?: any;
|
|
1379
|
+
autoincrement?: boolean | undefined;
|
|
1370
1380
|
name: string;
|
|
1371
1381
|
type: string;
|
|
1372
1382
|
primaryKey: boolean;
|
|
1373
1383
|
notNull: boolean;
|
|
1374
|
-
default?: any;
|
|
1375
|
-
onUpdate?: any;
|
|
1376
|
-
autoincrement?: boolean | undefined;
|
|
1377
1384
|
}>;
|
|
1378
1385
|
indexes: Record<string, {
|
|
1379
|
-
name: string;
|
|
1380
|
-
columns: string[];
|
|
1381
|
-
isUnique: boolean;
|
|
1382
1386
|
using?: "btree" | "hash" | undefined;
|
|
1383
1387
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1384
1388
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1389
|
+
name: string;
|
|
1390
|
+
columns: string[];
|
|
1391
|
+
isUnique: boolean;
|
|
1385
1392
|
}>;
|
|
1386
1393
|
foreignKeys: Record<string, {
|
|
1394
|
+
onUpdate?: string | undefined;
|
|
1395
|
+
onDelete?: string | undefined;
|
|
1387
1396
|
name: string;
|
|
1388
1397
|
tableFrom: string;
|
|
1389
1398
|
columnsFrom: string[];
|
|
1390
1399
|
tableTo: string;
|
|
1391
1400
|
columnsTo: string[];
|
|
1392
|
-
onUpdate?: string | undefined;
|
|
1393
|
-
onDelete?: string | undefined;
|
|
1394
1401
|
}>;
|
|
1395
1402
|
compositePrimaryKeys: Record<string, {
|
|
1396
1403
|
name: string;
|
|
@@ -1407,6 +1414,7 @@ export declare const schemaInternal: import("zod").ZodObject<{
|
|
|
1407
1414
|
columns: Record<string, string>;
|
|
1408
1415
|
tables: Record<string, string>;
|
|
1409
1416
|
};
|
|
1417
|
+
}, {
|
|
1410
1418
|
internal?: {
|
|
1411
1419
|
tables: Record<string, {
|
|
1412
1420
|
columns: Record<string, {
|
|
@@ -1414,43 +1422,42 @@ export declare const schemaInternal: import("zod").ZodObject<{
|
|
|
1414
1422
|
} | undefined>;
|
|
1415
1423
|
} | undefined>;
|
|
1416
1424
|
} | undefined;
|
|
1417
|
-
}, {
|
|
1418
1425
|
tables: Record<string, {
|
|
1426
|
+
uniqueConstraints?: Record<string, {
|
|
1427
|
+
name: string;
|
|
1428
|
+
columns: string[];
|
|
1429
|
+
}> | undefined;
|
|
1419
1430
|
name: string;
|
|
1420
1431
|
columns: Record<string, {
|
|
1432
|
+
default?: any;
|
|
1433
|
+
onUpdate?: any;
|
|
1434
|
+
autoincrement?: boolean | undefined;
|
|
1421
1435
|
name: string;
|
|
1422
1436
|
type: string;
|
|
1423
1437
|
primaryKey: boolean;
|
|
1424
1438
|
notNull: boolean;
|
|
1425
|
-
default?: any;
|
|
1426
|
-
onUpdate?: any;
|
|
1427
|
-
autoincrement?: boolean | undefined;
|
|
1428
1439
|
}>;
|
|
1429
1440
|
indexes: Record<string, {
|
|
1430
|
-
name: string;
|
|
1431
|
-
columns: string[];
|
|
1432
|
-
isUnique: boolean;
|
|
1433
1441
|
using?: "btree" | "hash" | undefined;
|
|
1434
1442
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1435
1443
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1444
|
+
name: string;
|
|
1445
|
+
columns: string[];
|
|
1446
|
+
isUnique: boolean;
|
|
1436
1447
|
}>;
|
|
1437
1448
|
foreignKeys: Record<string, {
|
|
1449
|
+
onUpdate?: string | undefined;
|
|
1450
|
+
onDelete?: string | undefined;
|
|
1438
1451
|
name: string;
|
|
1439
1452
|
tableFrom: string;
|
|
1440
1453
|
columnsFrom: string[];
|
|
1441
1454
|
tableTo: string;
|
|
1442
1455
|
columnsTo: string[];
|
|
1443
|
-
onUpdate?: string | undefined;
|
|
1444
|
-
onDelete?: string | undefined;
|
|
1445
1456
|
}>;
|
|
1446
1457
|
compositePrimaryKeys: Record<string, {
|
|
1447
1458
|
name: string;
|
|
1448
1459
|
columns: string[];
|
|
1449
1460
|
}>;
|
|
1450
|
-
uniqueConstraints?: Record<string, {
|
|
1451
|
-
name: string;
|
|
1452
|
-
columns: string[];
|
|
1453
|
-
}> | undefined;
|
|
1454
1461
|
}>;
|
|
1455
1462
|
version: "5";
|
|
1456
1463
|
dialect: "mysql";
|
|
@@ -1458,15 +1465,8 @@ export declare const schemaInternal: import("zod").ZodObject<{
|
|
|
1458
1465
|
columns: Record<string, string>;
|
|
1459
1466
|
tables: Record<string, string>;
|
|
1460
1467
|
};
|
|
1461
|
-
internal?: {
|
|
1462
|
-
tables: Record<string, {
|
|
1463
|
-
columns: Record<string, {
|
|
1464
|
-
isDefaultAnExpression?: boolean | undefined;
|
|
1465
|
-
} | undefined>;
|
|
1466
|
-
} | undefined>;
|
|
1467
|
-
} | undefined;
|
|
1468
1468
|
}>;
|
|
1469
|
-
export declare const schemaV3: import("zod").ZodObject<import("zod").
|
|
1469
|
+
export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape<{
|
|
1470
1470
|
version: import("zod").ZodLiteral<"3">;
|
|
1471
1471
|
dialect: import("zod").ZodLiteral<"mysql">;
|
|
1472
1472
|
tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
@@ -1480,21 +1480,21 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").objectUtil.
|
|
|
1480
1480
|
default: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
1481
1481
|
onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
1482
1482
|
}, "strict", import("zod").ZodTypeAny, {
|
|
1483
|
+
default?: any;
|
|
1484
|
+
onUpdate?: any;
|
|
1485
|
+
autoincrement?: boolean | undefined;
|
|
1483
1486
|
name: string;
|
|
1484
1487
|
type: string;
|
|
1485
1488
|
primaryKey: boolean;
|
|
1486
1489
|
notNull: boolean;
|
|
1490
|
+
}, {
|
|
1487
1491
|
default?: any;
|
|
1488
1492
|
onUpdate?: any;
|
|
1489
1493
|
autoincrement?: boolean | undefined;
|
|
1490
|
-
}, {
|
|
1491
1494
|
name: string;
|
|
1492
1495
|
type: string;
|
|
1493
1496
|
primaryKey: boolean;
|
|
1494
1497
|
notNull: boolean;
|
|
1495
|
-
default?: any;
|
|
1496
|
-
onUpdate?: any;
|
|
1497
|
-
autoincrement?: boolean | undefined;
|
|
1498
1498
|
}>>;
|
|
1499
1499
|
indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
1500
1500
|
name: import("zod").ZodString;
|
|
@@ -1504,19 +1504,19 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").objectUtil.
|
|
|
1504
1504
|
algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
|
|
1505
1505
|
lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
|
|
1506
1506
|
}, "strict", import("zod").ZodTypeAny, {
|
|
1507
|
-
name: string;
|
|
1508
|
-
columns: string[];
|
|
1509
|
-
isUnique: boolean;
|
|
1510
1507
|
using?: "btree" | "hash" | undefined;
|
|
1511
1508
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1512
1509
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1513
|
-
}, {
|
|
1514
1510
|
name: string;
|
|
1515
1511
|
columns: string[];
|
|
1516
1512
|
isUnique: boolean;
|
|
1513
|
+
}, {
|
|
1517
1514
|
using?: "btree" | "hash" | undefined;
|
|
1518
1515
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1519
1516
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1517
|
+
name: string;
|
|
1518
|
+
columns: string[];
|
|
1519
|
+
isUnique: boolean;
|
|
1520
1520
|
}>>;
|
|
1521
1521
|
foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
1522
1522
|
name: import("zod").ZodString;
|
|
@@ -1527,77 +1527,77 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").objectUtil.
|
|
|
1527
1527
|
onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
|
|
1528
1528
|
onDelete: import("zod").ZodOptional<import("zod").ZodString>;
|
|
1529
1529
|
}, "strict", import("zod").ZodTypeAny, {
|
|
1530
|
+
onUpdate?: string | undefined;
|
|
1531
|
+
onDelete?: string | undefined;
|
|
1530
1532
|
name: string;
|
|
1531
1533
|
tableFrom: string;
|
|
1532
1534
|
columnsFrom: string[];
|
|
1533
1535
|
tableTo: string;
|
|
1534
1536
|
columnsTo: string[];
|
|
1537
|
+
}, {
|
|
1535
1538
|
onUpdate?: string | undefined;
|
|
1536
1539
|
onDelete?: string | undefined;
|
|
1537
|
-
}, {
|
|
1538
1540
|
name: string;
|
|
1539
1541
|
tableFrom: string;
|
|
1540
1542
|
columnsFrom: string[];
|
|
1541
1543
|
tableTo: string;
|
|
1542
1544
|
columnsTo: string[];
|
|
1543
|
-
onUpdate?: string | undefined;
|
|
1544
|
-
onDelete?: string | undefined;
|
|
1545
1545
|
}>>;
|
|
1546
1546
|
}, "strict", import("zod").ZodTypeAny, {
|
|
1547
1547
|
name: string;
|
|
1548
1548
|
columns: Record<string, {
|
|
1549
|
+
default?: any;
|
|
1550
|
+
onUpdate?: any;
|
|
1551
|
+
autoincrement?: boolean | undefined;
|
|
1549
1552
|
name: string;
|
|
1550
1553
|
type: string;
|
|
1551
1554
|
primaryKey: boolean;
|
|
1552
1555
|
notNull: boolean;
|
|
1553
|
-
default?: any;
|
|
1554
|
-
onUpdate?: any;
|
|
1555
|
-
autoincrement?: boolean | undefined;
|
|
1556
1556
|
}>;
|
|
1557
1557
|
indexes: Record<string, {
|
|
1558
|
-
name: string;
|
|
1559
|
-
columns: string[];
|
|
1560
|
-
isUnique: boolean;
|
|
1561
1558
|
using?: "btree" | "hash" | undefined;
|
|
1562
1559
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1563
1560
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1561
|
+
name: string;
|
|
1562
|
+
columns: string[];
|
|
1563
|
+
isUnique: boolean;
|
|
1564
1564
|
}>;
|
|
1565
1565
|
foreignKeys: Record<string, {
|
|
1566
|
+
onUpdate?: string | undefined;
|
|
1567
|
+
onDelete?: string | undefined;
|
|
1566
1568
|
name: string;
|
|
1567
1569
|
tableFrom: string;
|
|
1568
1570
|
columnsFrom: string[];
|
|
1569
1571
|
tableTo: string;
|
|
1570
1572
|
columnsTo: string[];
|
|
1571
|
-
onUpdate?: string | undefined;
|
|
1572
|
-
onDelete?: string | undefined;
|
|
1573
1573
|
}>;
|
|
1574
1574
|
}, {
|
|
1575
1575
|
name: string;
|
|
1576
1576
|
columns: Record<string, {
|
|
1577
|
+
default?: any;
|
|
1578
|
+
onUpdate?: any;
|
|
1579
|
+
autoincrement?: boolean | undefined;
|
|
1577
1580
|
name: string;
|
|
1578
1581
|
type: string;
|
|
1579
1582
|
primaryKey: boolean;
|
|
1580
1583
|
notNull: boolean;
|
|
1581
|
-
default?: any;
|
|
1582
|
-
onUpdate?: any;
|
|
1583
|
-
autoincrement?: boolean | undefined;
|
|
1584
1584
|
}>;
|
|
1585
1585
|
indexes: Record<string, {
|
|
1586
|
-
name: string;
|
|
1587
|
-
columns: string[];
|
|
1588
|
-
isUnique: boolean;
|
|
1589
1586
|
using?: "btree" | "hash" | undefined;
|
|
1590
1587
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1591
1588
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1589
|
+
name: string;
|
|
1590
|
+
columns: string[];
|
|
1591
|
+
isUnique: boolean;
|
|
1592
1592
|
}>;
|
|
1593
1593
|
foreignKeys: Record<string, {
|
|
1594
|
+
onUpdate?: string | undefined;
|
|
1595
|
+
onDelete?: string | undefined;
|
|
1594
1596
|
name: string;
|
|
1595
1597
|
tableFrom: string;
|
|
1596
1598
|
columnsFrom: string[];
|
|
1597
1599
|
tableTo: string;
|
|
1598
1600
|
columnsTo: string[];
|
|
1599
|
-
onUpdate?: string | undefined;
|
|
1600
|
-
onDelete?: string | undefined;
|
|
1601
1601
|
}>;
|
|
1602
1602
|
}>>;
|
|
1603
1603
|
}, {
|
|
@@ -1607,30 +1607,30 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").objectUtil.
|
|
|
1607
1607
|
tables: Record<string, {
|
|
1608
1608
|
name: string;
|
|
1609
1609
|
columns: Record<string, {
|
|
1610
|
+
default?: any;
|
|
1611
|
+
onUpdate?: any;
|
|
1612
|
+
autoincrement?: boolean | undefined;
|
|
1610
1613
|
name: string;
|
|
1611
1614
|
type: string;
|
|
1612
1615
|
primaryKey: boolean;
|
|
1613
1616
|
notNull: boolean;
|
|
1614
|
-
default?: any;
|
|
1615
|
-
onUpdate?: any;
|
|
1616
|
-
autoincrement?: boolean | undefined;
|
|
1617
1617
|
}>;
|
|
1618
1618
|
indexes: Record<string, {
|
|
1619
|
-
name: string;
|
|
1620
|
-
columns: string[];
|
|
1621
|
-
isUnique: boolean;
|
|
1622
1619
|
using?: "btree" | "hash" | undefined;
|
|
1623
1620
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1624
1621
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1622
|
+
name: string;
|
|
1623
|
+
columns: string[];
|
|
1624
|
+
isUnique: boolean;
|
|
1625
1625
|
}>;
|
|
1626
1626
|
foreignKeys: Record<string, {
|
|
1627
|
+
onUpdate?: string | undefined;
|
|
1628
|
+
onDelete?: string | undefined;
|
|
1627
1629
|
name: string;
|
|
1628
1630
|
tableFrom: string;
|
|
1629
1631
|
columnsFrom: string[];
|
|
1630
1632
|
tableTo: string;
|
|
1631
1633
|
columnsTo: string[];
|
|
1632
|
-
onUpdate?: string | undefined;
|
|
1633
|
-
onDelete?: string | undefined;
|
|
1634
1634
|
}>;
|
|
1635
1635
|
}>;
|
|
1636
1636
|
id: string;
|
|
@@ -1641,30 +1641,30 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").objectUtil.
|
|
|
1641
1641
|
tables: Record<string, {
|
|
1642
1642
|
name: string;
|
|
1643
1643
|
columns: Record<string, {
|
|
1644
|
+
default?: any;
|
|
1645
|
+
onUpdate?: any;
|
|
1646
|
+
autoincrement?: boolean | undefined;
|
|
1644
1647
|
name: string;
|
|
1645
1648
|
type: string;
|
|
1646
1649
|
primaryKey: boolean;
|
|
1647
1650
|
notNull: boolean;
|
|
1648
|
-
default?: any;
|
|
1649
|
-
onUpdate?: any;
|
|
1650
|
-
autoincrement?: boolean | undefined;
|
|
1651
1651
|
}>;
|
|
1652
1652
|
indexes: Record<string, {
|
|
1653
|
-
name: string;
|
|
1654
|
-
columns: string[];
|
|
1655
|
-
isUnique: boolean;
|
|
1656
1653
|
using?: "btree" | "hash" | undefined;
|
|
1657
1654
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1658
1655
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1656
|
+
name: string;
|
|
1657
|
+
columns: string[];
|
|
1658
|
+
isUnique: boolean;
|
|
1659
1659
|
}>;
|
|
1660
1660
|
foreignKeys: Record<string, {
|
|
1661
|
+
onUpdate?: string | undefined;
|
|
1662
|
+
onDelete?: string | undefined;
|
|
1661
1663
|
name: string;
|
|
1662
1664
|
tableFrom: string;
|
|
1663
1665
|
columnsFrom: string[];
|
|
1664
1666
|
tableTo: string;
|
|
1665
1667
|
columnsTo: string[];
|
|
1666
|
-
onUpdate?: string | undefined;
|
|
1667
|
-
onDelete?: string | undefined;
|
|
1668
1668
|
}>;
|
|
1669
1669
|
}>;
|
|
1670
1670
|
id: string;
|
|
@@ -1672,7 +1672,7 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").objectUtil.
|
|
|
1672
1672
|
version: "3";
|
|
1673
1673
|
dialect: "mysql";
|
|
1674
1674
|
}>;
|
|
1675
|
-
export declare const schemaV4: import("zod").ZodObject<import("zod").
|
|
1675
|
+
export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape<{
|
|
1676
1676
|
version: import("zod").ZodLiteral<"4">;
|
|
1677
1677
|
dialect: import("zod").ZodLiteral<"mysql">;
|
|
1678
1678
|
tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
@@ -1687,21 +1687,21 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").objectUtil.
|
|
|
1687
1687
|
default: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
1688
1688
|
onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
1689
1689
|
}, "strict", import("zod").ZodTypeAny, {
|
|
1690
|
+
default?: any;
|
|
1691
|
+
onUpdate?: any;
|
|
1692
|
+
autoincrement?: boolean | undefined;
|
|
1690
1693
|
name: string;
|
|
1691
1694
|
type: string;
|
|
1692
1695
|
primaryKey: boolean;
|
|
1693
1696
|
notNull: boolean;
|
|
1697
|
+
}, {
|
|
1694
1698
|
default?: any;
|
|
1695
1699
|
onUpdate?: any;
|
|
1696
1700
|
autoincrement?: boolean | undefined;
|
|
1697
|
-
}, {
|
|
1698
1701
|
name: string;
|
|
1699
1702
|
type: string;
|
|
1700
1703
|
primaryKey: boolean;
|
|
1701
1704
|
notNull: boolean;
|
|
1702
|
-
default?: any;
|
|
1703
|
-
onUpdate?: any;
|
|
1704
|
-
autoincrement?: boolean | undefined;
|
|
1705
1705
|
}>>;
|
|
1706
1706
|
indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
1707
1707
|
name: import("zod").ZodString;
|
|
@@ -1711,19 +1711,19 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").objectUtil.
|
|
|
1711
1711
|
algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
|
|
1712
1712
|
lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
|
|
1713
1713
|
}, "strict", import("zod").ZodTypeAny, {
|
|
1714
|
-
name: string;
|
|
1715
|
-
columns: string[];
|
|
1716
|
-
isUnique: boolean;
|
|
1717
1714
|
using?: "btree" | "hash" | undefined;
|
|
1718
1715
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1719
1716
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1720
|
-
}, {
|
|
1721
1717
|
name: string;
|
|
1722
1718
|
columns: string[];
|
|
1723
1719
|
isUnique: boolean;
|
|
1720
|
+
}, {
|
|
1724
1721
|
using?: "btree" | "hash" | undefined;
|
|
1725
1722
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1726
1723
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1724
|
+
name: string;
|
|
1725
|
+
columns: string[];
|
|
1726
|
+
isUnique: boolean;
|
|
1727
1727
|
}>>;
|
|
1728
1728
|
foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
1729
1729
|
name: import("zod").ZodString;
|
|
@@ -1734,80 +1734,80 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").objectUtil.
|
|
|
1734
1734
|
onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
|
|
1735
1735
|
onDelete: import("zod").ZodOptional<import("zod").ZodString>;
|
|
1736
1736
|
}, "strict", import("zod").ZodTypeAny, {
|
|
1737
|
+
onUpdate?: string | undefined;
|
|
1738
|
+
onDelete?: string | undefined;
|
|
1737
1739
|
name: string;
|
|
1738
1740
|
tableFrom: string;
|
|
1739
1741
|
columnsFrom: string[];
|
|
1740
1742
|
tableTo: string;
|
|
1741
1743
|
columnsTo: string[];
|
|
1744
|
+
}, {
|
|
1742
1745
|
onUpdate?: string | undefined;
|
|
1743
1746
|
onDelete?: string | undefined;
|
|
1744
|
-
}, {
|
|
1745
1747
|
name: string;
|
|
1746
1748
|
tableFrom: string;
|
|
1747
1749
|
columnsFrom: string[];
|
|
1748
1750
|
tableTo: string;
|
|
1749
1751
|
columnsTo: string[];
|
|
1750
|
-
onUpdate?: string | undefined;
|
|
1751
|
-
onDelete?: string | undefined;
|
|
1752
1752
|
}>>;
|
|
1753
1753
|
}, "strict", import("zod").ZodTypeAny, {
|
|
1754
|
+
schema?: string | undefined;
|
|
1754
1755
|
name: string;
|
|
1755
1756
|
columns: Record<string, {
|
|
1757
|
+
default?: any;
|
|
1758
|
+
onUpdate?: any;
|
|
1759
|
+
autoincrement?: boolean | undefined;
|
|
1756
1760
|
name: string;
|
|
1757
1761
|
type: string;
|
|
1758
1762
|
primaryKey: boolean;
|
|
1759
1763
|
notNull: boolean;
|
|
1760
|
-
default?: any;
|
|
1761
|
-
onUpdate?: any;
|
|
1762
|
-
autoincrement?: boolean | undefined;
|
|
1763
1764
|
}>;
|
|
1764
1765
|
indexes: Record<string, {
|
|
1765
|
-
name: string;
|
|
1766
|
-
columns: string[];
|
|
1767
|
-
isUnique: boolean;
|
|
1768
1766
|
using?: "btree" | "hash" | undefined;
|
|
1769
1767
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1770
1768
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1769
|
+
name: string;
|
|
1770
|
+
columns: string[];
|
|
1771
|
+
isUnique: boolean;
|
|
1771
1772
|
}>;
|
|
1772
1773
|
foreignKeys: Record<string, {
|
|
1774
|
+
onUpdate?: string | undefined;
|
|
1775
|
+
onDelete?: string | undefined;
|
|
1773
1776
|
name: string;
|
|
1774
1777
|
tableFrom: string;
|
|
1775
1778
|
columnsFrom: string[];
|
|
1776
1779
|
tableTo: string;
|
|
1777
1780
|
columnsTo: string[];
|
|
1778
|
-
onUpdate?: string | undefined;
|
|
1779
|
-
onDelete?: string | undefined;
|
|
1780
1781
|
}>;
|
|
1781
|
-
schema?: string | undefined;
|
|
1782
1782
|
}, {
|
|
1783
|
+
schema?: string | undefined;
|
|
1783
1784
|
name: string;
|
|
1784
1785
|
columns: Record<string, {
|
|
1786
|
+
default?: any;
|
|
1787
|
+
onUpdate?: any;
|
|
1788
|
+
autoincrement?: boolean | undefined;
|
|
1785
1789
|
name: string;
|
|
1786
1790
|
type: string;
|
|
1787
1791
|
primaryKey: boolean;
|
|
1788
1792
|
notNull: boolean;
|
|
1789
|
-
default?: any;
|
|
1790
|
-
onUpdate?: any;
|
|
1791
|
-
autoincrement?: boolean | undefined;
|
|
1792
1793
|
}>;
|
|
1793
1794
|
indexes: Record<string, {
|
|
1794
|
-
name: string;
|
|
1795
|
-
columns: string[];
|
|
1796
|
-
isUnique: boolean;
|
|
1797
1795
|
using?: "btree" | "hash" | undefined;
|
|
1798
1796
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1799
1797
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1798
|
+
name: string;
|
|
1799
|
+
columns: string[];
|
|
1800
|
+
isUnique: boolean;
|
|
1800
1801
|
}>;
|
|
1801
1802
|
foreignKeys: Record<string, {
|
|
1803
|
+
onUpdate?: string | undefined;
|
|
1804
|
+
onDelete?: string | undefined;
|
|
1802
1805
|
name: string;
|
|
1803
1806
|
tableFrom: string;
|
|
1804
1807
|
columnsFrom: string[];
|
|
1805
1808
|
tableTo: string;
|
|
1806
1809
|
columnsTo: string[];
|
|
1807
|
-
onUpdate?: string | undefined;
|
|
1808
|
-
onDelete?: string | undefined;
|
|
1809
1810
|
}>;
|
|
1810
|
-
schema?: string | undefined;
|
|
1811
1811
|
}>>;
|
|
1812
1812
|
schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
|
|
1813
1813
|
}, {
|
|
@@ -1815,34 +1815,34 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").objectUtil.
|
|
|
1815
1815
|
prevId: import("zod").ZodString;
|
|
1816
1816
|
}>, "strip", import("zod").ZodTypeAny, {
|
|
1817
1817
|
tables: Record<string, {
|
|
1818
|
+
schema?: string | undefined;
|
|
1818
1819
|
name: string;
|
|
1819
1820
|
columns: Record<string, {
|
|
1821
|
+
default?: any;
|
|
1822
|
+
onUpdate?: any;
|
|
1823
|
+
autoincrement?: boolean | undefined;
|
|
1820
1824
|
name: string;
|
|
1821
1825
|
type: string;
|
|
1822
1826
|
primaryKey: boolean;
|
|
1823
1827
|
notNull: boolean;
|
|
1824
|
-
default?: any;
|
|
1825
|
-
onUpdate?: any;
|
|
1826
|
-
autoincrement?: boolean | undefined;
|
|
1827
1828
|
}>;
|
|
1828
1829
|
indexes: Record<string, {
|
|
1829
|
-
name: string;
|
|
1830
|
-
columns: string[];
|
|
1831
|
-
isUnique: boolean;
|
|
1832
1830
|
using?: "btree" | "hash" | undefined;
|
|
1833
1831
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1834
1832
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1833
|
+
name: string;
|
|
1834
|
+
columns: string[];
|
|
1835
|
+
isUnique: boolean;
|
|
1835
1836
|
}>;
|
|
1836
1837
|
foreignKeys: Record<string, {
|
|
1838
|
+
onUpdate?: string | undefined;
|
|
1839
|
+
onDelete?: string | undefined;
|
|
1837
1840
|
name: string;
|
|
1838
1841
|
tableFrom: string;
|
|
1839
1842
|
columnsFrom: string[];
|
|
1840
1843
|
tableTo: string;
|
|
1841
1844
|
columnsTo: string[];
|
|
1842
|
-
onUpdate?: string | undefined;
|
|
1843
|
-
onDelete?: string | undefined;
|
|
1844
1845
|
}>;
|
|
1845
|
-
schema?: string | undefined;
|
|
1846
1846
|
}>;
|
|
1847
1847
|
id: string;
|
|
1848
1848
|
prevId: string;
|
|
@@ -1851,34 +1851,34 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").objectUtil.
|
|
|
1851
1851
|
schemas: Record<string, string>;
|
|
1852
1852
|
}, {
|
|
1853
1853
|
tables: Record<string, {
|
|
1854
|
+
schema?: string | undefined;
|
|
1854
1855
|
name: string;
|
|
1855
1856
|
columns: Record<string, {
|
|
1857
|
+
default?: any;
|
|
1858
|
+
onUpdate?: any;
|
|
1859
|
+
autoincrement?: boolean | undefined;
|
|
1856
1860
|
name: string;
|
|
1857
1861
|
type: string;
|
|
1858
1862
|
primaryKey: boolean;
|
|
1859
1863
|
notNull: boolean;
|
|
1860
|
-
default?: any;
|
|
1861
|
-
onUpdate?: any;
|
|
1862
|
-
autoincrement?: boolean | undefined;
|
|
1863
1864
|
}>;
|
|
1864
1865
|
indexes: Record<string, {
|
|
1865
|
-
name: string;
|
|
1866
|
-
columns: string[];
|
|
1867
|
-
isUnique: boolean;
|
|
1868
1866
|
using?: "btree" | "hash" | undefined;
|
|
1869
1867
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1870
1868
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1869
|
+
name: string;
|
|
1870
|
+
columns: string[];
|
|
1871
|
+
isUnique: boolean;
|
|
1871
1872
|
}>;
|
|
1872
1873
|
foreignKeys: Record<string, {
|
|
1874
|
+
onUpdate?: string | undefined;
|
|
1875
|
+
onDelete?: string | undefined;
|
|
1873
1876
|
name: string;
|
|
1874
1877
|
tableFrom: string;
|
|
1875
1878
|
columnsFrom: string[];
|
|
1876
1879
|
tableTo: string;
|
|
1877
1880
|
columnsTo: string[];
|
|
1878
|
-
onUpdate?: string | undefined;
|
|
1879
|
-
onDelete?: string | undefined;
|
|
1880
1881
|
}>;
|
|
1881
|
-
schema?: string | undefined;
|
|
1882
1882
|
}>;
|
|
1883
1883
|
id: string;
|
|
1884
1884
|
prevId: string;
|
|
@@ -1886,7 +1886,7 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").objectUtil.
|
|
|
1886
1886
|
dialect: "mysql";
|
|
1887
1887
|
schemas: Record<string, string>;
|
|
1888
1888
|
}>;
|
|
1889
|
-
export declare const schemaV5: import("zod").ZodObject<import("zod").
|
|
1889
|
+
export declare const schemaV5: import("zod").ZodObject<import("zod").extendShape<{
|
|
1890
1890
|
version: import("zod").ZodLiteral<"5">;
|
|
1891
1891
|
dialect: import("zod").ZodLiteral<"mysql">;
|
|
1892
1892
|
tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
@@ -1900,21 +1900,21 @@ export declare const schemaV5: import("zod").ZodObject<import("zod").objectUtil.
|
|
|
1900
1900
|
default: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
1901
1901
|
onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
1902
1902
|
}, "strict", import("zod").ZodTypeAny, {
|
|
1903
|
+
default?: any;
|
|
1904
|
+
onUpdate?: any;
|
|
1905
|
+
autoincrement?: boolean | undefined;
|
|
1903
1906
|
name: string;
|
|
1904
1907
|
type: string;
|
|
1905
1908
|
primaryKey: boolean;
|
|
1906
1909
|
notNull: boolean;
|
|
1910
|
+
}, {
|
|
1907
1911
|
default?: any;
|
|
1908
1912
|
onUpdate?: any;
|
|
1909
1913
|
autoincrement?: boolean | undefined;
|
|
1910
|
-
}, {
|
|
1911
1914
|
name: string;
|
|
1912
1915
|
type: string;
|
|
1913
1916
|
primaryKey: boolean;
|
|
1914
1917
|
notNull: boolean;
|
|
1915
|
-
default?: any;
|
|
1916
|
-
onUpdate?: any;
|
|
1917
|
-
autoincrement?: boolean | undefined;
|
|
1918
1918
|
}>>;
|
|
1919
1919
|
indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
1920
1920
|
name: import("zod").ZodString;
|
|
@@ -1924,19 +1924,19 @@ export declare const schemaV5: import("zod").ZodObject<import("zod").objectUtil.
|
|
|
1924
1924
|
algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
|
|
1925
1925
|
lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
|
|
1926
1926
|
}, "strict", import("zod").ZodTypeAny, {
|
|
1927
|
-
name: string;
|
|
1928
|
-
columns: string[];
|
|
1929
|
-
isUnique: boolean;
|
|
1930
1927
|
using?: "btree" | "hash" | undefined;
|
|
1931
1928
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1932
1929
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1933
|
-
}, {
|
|
1934
1930
|
name: string;
|
|
1935
1931
|
columns: string[];
|
|
1936
1932
|
isUnique: boolean;
|
|
1933
|
+
}, {
|
|
1937
1934
|
using?: "btree" | "hash" | undefined;
|
|
1938
1935
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1939
1936
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1937
|
+
name: string;
|
|
1938
|
+
columns: string[];
|
|
1939
|
+
isUnique: boolean;
|
|
1940
1940
|
}>>;
|
|
1941
1941
|
foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
1942
1942
|
name: import("zod").ZodString;
|
|
@@ -1947,21 +1947,21 @@ export declare const schemaV5: import("zod").ZodObject<import("zod").objectUtil.
|
|
|
1947
1947
|
onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
|
|
1948
1948
|
onDelete: import("zod").ZodOptional<import("zod").ZodString>;
|
|
1949
1949
|
}, "strict", import("zod").ZodTypeAny, {
|
|
1950
|
+
onUpdate?: string | undefined;
|
|
1951
|
+
onDelete?: string | undefined;
|
|
1950
1952
|
name: string;
|
|
1951
1953
|
tableFrom: string;
|
|
1952
1954
|
columnsFrom: string[];
|
|
1953
1955
|
tableTo: string;
|
|
1954
1956
|
columnsTo: string[];
|
|
1957
|
+
}, {
|
|
1955
1958
|
onUpdate?: string | undefined;
|
|
1956
1959
|
onDelete?: string | undefined;
|
|
1957
|
-
}, {
|
|
1958
1960
|
name: string;
|
|
1959
1961
|
tableFrom: string;
|
|
1960
1962
|
columnsFrom: string[];
|
|
1961
1963
|
tableTo: string;
|
|
1962
1964
|
columnsTo: string[];
|
|
1963
|
-
onUpdate?: string | undefined;
|
|
1964
|
-
onDelete?: string | undefined;
|
|
1965
1965
|
}>>;
|
|
1966
1966
|
compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
1967
1967
|
name: import("zod").ZodString;
|
|
@@ -1986,30 +1986,30 @@ export declare const schemaV5: import("zod").ZodObject<import("zod").objectUtil.
|
|
|
1986
1986
|
}, "strict", import("zod").ZodTypeAny, {
|
|
1987
1987
|
name: string;
|
|
1988
1988
|
columns: Record<string, {
|
|
1989
|
+
default?: any;
|
|
1990
|
+
onUpdate?: any;
|
|
1991
|
+
autoincrement?: boolean | undefined;
|
|
1989
1992
|
name: string;
|
|
1990
1993
|
type: string;
|
|
1991
1994
|
primaryKey: boolean;
|
|
1992
1995
|
notNull: boolean;
|
|
1993
|
-
default?: any;
|
|
1994
|
-
onUpdate?: any;
|
|
1995
|
-
autoincrement?: boolean | undefined;
|
|
1996
1996
|
}>;
|
|
1997
1997
|
indexes: Record<string, {
|
|
1998
|
-
name: string;
|
|
1999
|
-
columns: string[];
|
|
2000
|
-
isUnique: boolean;
|
|
2001
1998
|
using?: "btree" | "hash" | undefined;
|
|
2002
1999
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
2003
2000
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
2001
|
+
name: string;
|
|
2002
|
+
columns: string[];
|
|
2003
|
+
isUnique: boolean;
|
|
2004
2004
|
}>;
|
|
2005
2005
|
foreignKeys: Record<string, {
|
|
2006
|
+
onUpdate?: string | undefined;
|
|
2007
|
+
onDelete?: string | undefined;
|
|
2006
2008
|
name: string;
|
|
2007
2009
|
tableFrom: string;
|
|
2008
2010
|
columnsFrom: string[];
|
|
2009
2011
|
tableTo: string;
|
|
2010
2012
|
columnsTo: string[];
|
|
2011
|
-
onUpdate?: string | undefined;
|
|
2012
|
-
onDelete?: string | undefined;
|
|
2013
2013
|
}>;
|
|
2014
2014
|
compositePrimaryKeys: Record<string, {
|
|
2015
2015
|
name: string;
|
|
@@ -2020,41 +2020,41 @@ export declare const schemaV5: import("zod").ZodObject<import("zod").objectUtil.
|
|
|
2020
2020
|
columns: string[];
|
|
2021
2021
|
}>;
|
|
2022
2022
|
}, {
|
|
2023
|
+
uniqueConstraints?: Record<string, {
|
|
2024
|
+
name: string;
|
|
2025
|
+
columns: string[];
|
|
2026
|
+
}> | undefined;
|
|
2023
2027
|
name: string;
|
|
2024
2028
|
columns: Record<string, {
|
|
2029
|
+
default?: any;
|
|
2030
|
+
onUpdate?: any;
|
|
2031
|
+
autoincrement?: boolean | undefined;
|
|
2025
2032
|
name: string;
|
|
2026
2033
|
type: string;
|
|
2027
2034
|
primaryKey: boolean;
|
|
2028
2035
|
notNull: boolean;
|
|
2029
|
-
default?: any;
|
|
2030
|
-
onUpdate?: any;
|
|
2031
|
-
autoincrement?: boolean | undefined;
|
|
2032
2036
|
}>;
|
|
2033
2037
|
indexes: Record<string, {
|
|
2034
|
-
name: string;
|
|
2035
|
-
columns: string[];
|
|
2036
|
-
isUnique: boolean;
|
|
2037
2038
|
using?: "btree" | "hash" | undefined;
|
|
2038
2039
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
2039
2040
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
2041
|
+
name: string;
|
|
2042
|
+
columns: string[];
|
|
2043
|
+
isUnique: boolean;
|
|
2040
2044
|
}>;
|
|
2041
2045
|
foreignKeys: Record<string, {
|
|
2046
|
+
onUpdate?: string | undefined;
|
|
2047
|
+
onDelete?: string | undefined;
|
|
2042
2048
|
name: string;
|
|
2043
2049
|
tableFrom: string;
|
|
2044
2050
|
columnsFrom: string[];
|
|
2045
2051
|
tableTo: string;
|
|
2046
2052
|
columnsTo: string[];
|
|
2047
|
-
onUpdate?: string | undefined;
|
|
2048
|
-
onDelete?: string | undefined;
|
|
2049
2053
|
}>;
|
|
2050
2054
|
compositePrimaryKeys: Record<string, {
|
|
2051
2055
|
name: string;
|
|
2052
2056
|
columns: string[];
|
|
2053
2057
|
}>;
|
|
2054
|
-
uniqueConstraints?: Record<string, {
|
|
2055
|
-
name: string;
|
|
2056
|
-
columns: string[];
|
|
2057
|
-
}> | undefined;
|
|
2058
2058
|
}>>;
|
|
2059
2059
|
schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
|
|
2060
2060
|
_meta: import("zod").ZodObject<{
|
|
@@ -2105,33 +2105,40 @@ export declare const schemaV5: import("zod").ZodObject<import("zod").objectUtil.
|
|
|
2105
2105
|
id: import("zod").ZodString;
|
|
2106
2106
|
prevId: import("zod").ZodString;
|
|
2107
2107
|
}>, "strip", import("zod").ZodTypeAny, {
|
|
2108
|
+
internal?: {
|
|
2109
|
+
tables: Record<string, {
|
|
2110
|
+
columns: Record<string, {
|
|
2111
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
2112
|
+
} | undefined>;
|
|
2113
|
+
} | undefined>;
|
|
2114
|
+
} | undefined;
|
|
2108
2115
|
tables: Record<string, {
|
|
2109
2116
|
name: string;
|
|
2110
2117
|
columns: Record<string, {
|
|
2118
|
+
default?: any;
|
|
2119
|
+
onUpdate?: any;
|
|
2120
|
+
autoincrement?: boolean | undefined;
|
|
2111
2121
|
name: string;
|
|
2112
2122
|
type: string;
|
|
2113
2123
|
primaryKey: boolean;
|
|
2114
2124
|
notNull: boolean;
|
|
2115
|
-
default?: any;
|
|
2116
|
-
onUpdate?: any;
|
|
2117
|
-
autoincrement?: boolean | undefined;
|
|
2118
2125
|
}>;
|
|
2119
2126
|
indexes: Record<string, {
|
|
2120
|
-
name: string;
|
|
2121
|
-
columns: string[];
|
|
2122
|
-
isUnique: boolean;
|
|
2123
2127
|
using?: "btree" | "hash" | undefined;
|
|
2124
2128
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
2125
2129
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
2130
|
+
name: string;
|
|
2131
|
+
columns: string[];
|
|
2132
|
+
isUnique: boolean;
|
|
2126
2133
|
}>;
|
|
2127
2134
|
foreignKeys: Record<string, {
|
|
2135
|
+
onUpdate?: string | undefined;
|
|
2136
|
+
onDelete?: string | undefined;
|
|
2128
2137
|
name: string;
|
|
2129
2138
|
tableFrom: string;
|
|
2130
2139
|
columnsFrom: string[];
|
|
2131
2140
|
tableTo: string;
|
|
2132
2141
|
columnsTo: string[];
|
|
2133
|
-
onUpdate?: string | undefined;
|
|
2134
|
-
onDelete?: string | undefined;
|
|
2135
2142
|
}>;
|
|
2136
2143
|
compositePrimaryKeys: Record<string, {
|
|
2137
2144
|
name: string;
|
|
@@ -2152,6 +2159,7 @@ export declare const schemaV5: import("zod").ZodObject<import("zod").objectUtil.
|
|
|
2152
2159
|
tables: Record<string, string>;
|
|
2153
2160
|
schemas: Record<string, string>;
|
|
2154
2161
|
};
|
|
2162
|
+
}, {
|
|
2155
2163
|
internal?: {
|
|
2156
2164
|
tables: Record<string, {
|
|
2157
2165
|
columns: Record<string, {
|
|
@@ -2159,43 +2167,42 @@ export declare const schemaV5: import("zod").ZodObject<import("zod").objectUtil.
|
|
|
2159
2167
|
} | undefined>;
|
|
2160
2168
|
} | undefined>;
|
|
2161
2169
|
} | undefined;
|
|
2162
|
-
}, {
|
|
2163
2170
|
tables: Record<string, {
|
|
2171
|
+
uniqueConstraints?: Record<string, {
|
|
2172
|
+
name: string;
|
|
2173
|
+
columns: string[];
|
|
2174
|
+
}> | undefined;
|
|
2164
2175
|
name: string;
|
|
2165
2176
|
columns: Record<string, {
|
|
2177
|
+
default?: any;
|
|
2178
|
+
onUpdate?: any;
|
|
2179
|
+
autoincrement?: boolean | undefined;
|
|
2166
2180
|
name: string;
|
|
2167
2181
|
type: string;
|
|
2168
2182
|
primaryKey: boolean;
|
|
2169
2183
|
notNull: boolean;
|
|
2170
|
-
default?: any;
|
|
2171
|
-
onUpdate?: any;
|
|
2172
|
-
autoincrement?: boolean | undefined;
|
|
2173
2184
|
}>;
|
|
2174
2185
|
indexes: Record<string, {
|
|
2175
|
-
name: string;
|
|
2176
|
-
columns: string[];
|
|
2177
|
-
isUnique: boolean;
|
|
2178
2186
|
using?: "btree" | "hash" | undefined;
|
|
2179
2187
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
2180
2188
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
2189
|
+
name: string;
|
|
2190
|
+
columns: string[];
|
|
2191
|
+
isUnique: boolean;
|
|
2181
2192
|
}>;
|
|
2182
2193
|
foreignKeys: Record<string, {
|
|
2194
|
+
onUpdate?: string | undefined;
|
|
2195
|
+
onDelete?: string | undefined;
|
|
2183
2196
|
name: string;
|
|
2184
2197
|
tableFrom: string;
|
|
2185
2198
|
columnsFrom: string[];
|
|
2186
2199
|
tableTo: string;
|
|
2187
2200
|
columnsTo: string[];
|
|
2188
|
-
onUpdate?: string | undefined;
|
|
2189
|
-
onDelete?: string | undefined;
|
|
2190
2201
|
}>;
|
|
2191
2202
|
compositePrimaryKeys: Record<string, {
|
|
2192
2203
|
name: string;
|
|
2193
2204
|
columns: string[];
|
|
2194
2205
|
}>;
|
|
2195
|
-
uniqueConstraints?: Record<string, {
|
|
2196
|
-
name: string;
|
|
2197
|
-
columns: string[];
|
|
2198
|
-
}> | undefined;
|
|
2199
2206
|
}>;
|
|
2200
2207
|
id: string;
|
|
2201
2208
|
prevId: string;
|
|
@@ -2207,15 +2214,8 @@ export declare const schemaV5: import("zod").ZodObject<import("zod").objectUtil.
|
|
|
2207
2214
|
tables: Record<string, string>;
|
|
2208
2215
|
schemas: Record<string, string>;
|
|
2209
2216
|
};
|
|
2210
|
-
internal?: {
|
|
2211
|
-
tables: Record<string, {
|
|
2212
|
-
columns: Record<string, {
|
|
2213
|
-
isDefaultAnExpression?: boolean | undefined;
|
|
2214
|
-
} | undefined>;
|
|
2215
|
-
} | undefined>;
|
|
2216
|
-
} | undefined;
|
|
2217
2217
|
}>;
|
|
2218
|
-
export declare const schema: import("zod").ZodObject<import("zod").
|
|
2218
|
+
export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
|
|
2219
2219
|
version: import("zod").ZodLiteral<"5">;
|
|
2220
2220
|
dialect: import("zod").ZodLiteral<"mysql">;
|
|
2221
2221
|
tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
@@ -2229,21 +2229,21 @@ export declare const schema: import("zod").ZodObject<import("zod").objectUtil.ex
|
|
|
2229
2229
|
default: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
2230
2230
|
onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
2231
2231
|
}, "strict", import("zod").ZodTypeAny, {
|
|
2232
|
+
default?: any;
|
|
2233
|
+
onUpdate?: any;
|
|
2234
|
+
autoincrement?: boolean | undefined;
|
|
2232
2235
|
name: string;
|
|
2233
2236
|
type: string;
|
|
2234
2237
|
primaryKey: boolean;
|
|
2235
2238
|
notNull: boolean;
|
|
2239
|
+
}, {
|
|
2236
2240
|
default?: any;
|
|
2237
2241
|
onUpdate?: any;
|
|
2238
2242
|
autoincrement?: boolean | undefined;
|
|
2239
|
-
}, {
|
|
2240
2243
|
name: string;
|
|
2241
2244
|
type: string;
|
|
2242
2245
|
primaryKey: boolean;
|
|
2243
2246
|
notNull: boolean;
|
|
2244
|
-
default?: any;
|
|
2245
|
-
onUpdate?: any;
|
|
2246
|
-
autoincrement?: boolean | undefined;
|
|
2247
2247
|
}>>;
|
|
2248
2248
|
indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
2249
2249
|
name: import("zod").ZodString;
|
|
@@ -2253,19 +2253,19 @@ export declare const schema: import("zod").ZodObject<import("zod").objectUtil.ex
|
|
|
2253
2253
|
algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
|
|
2254
2254
|
lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
|
|
2255
2255
|
}, "strict", import("zod").ZodTypeAny, {
|
|
2256
|
-
name: string;
|
|
2257
|
-
columns: string[];
|
|
2258
|
-
isUnique: boolean;
|
|
2259
2256
|
using?: "btree" | "hash" | undefined;
|
|
2260
2257
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
2261
2258
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
2262
|
-
}, {
|
|
2263
2259
|
name: string;
|
|
2264
2260
|
columns: string[];
|
|
2265
2261
|
isUnique: boolean;
|
|
2262
|
+
}, {
|
|
2266
2263
|
using?: "btree" | "hash" | undefined;
|
|
2267
2264
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
2268
2265
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
2266
|
+
name: string;
|
|
2267
|
+
columns: string[];
|
|
2268
|
+
isUnique: boolean;
|
|
2269
2269
|
}>>;
|
|
2270
2270
|
foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
2271
2271
|
name: import("zod").ZodString;
|
|
@@ -2276,21 +2276,21 @@ export declare const schema: import("zod").ZodObject<import("zod").objectUtil.ex
|
|
|
2276
2276
|
onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
|
|
2277
2277
|
onDelete: import("zod").ZodOptional<import("zod").ZodString>;
|
|
2278
2278
|
}, "strict", import("zod").ZodTypeAny, {
|
|
2279
|
+
onUpdate?: string | undefined;
|
|
2280
|
+
onDelete?: string | undefined;
|
|
2279
2281
|
name: string;
|
|
2280
2282
|
tableFrom: string;
|
|
2281
2283
|
columnsFrom: string[];
|
|
2282
2284
|
tableTo: string;
|
|
2283
2285
|
columnsTo: string[];
|
|
2286
|
+
}, {
|
|
2284
2287
|
onUpdate?: string | undefined;
|
|
2285
2288
|
onDelete?: string | undefined;
|
|
2286
|
-
}, {
|
|
2287
2289
|
name: string;
|
|
2288
2290
|
tableFrom: string;
|
|
2289
2291
|
columnsFrom: string[];
|
|
2290
2292
|
tableTo: string;
|
|
2291
2293
|
columnsTo: string[];
|
|
2292
|
-
onUpdate?: string | undefined;
|
|
2293
|
-
onDelete?: string | undefined;
|
|
2294
2294
|
}>>;
|
|
2295
2295
|
compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
2296
2296
|
name: import("zod").ZodString;
|
|
@@ -2315,30 +2315,30 @@ export declare const schema: import("zod").ZodObject<import("zod").objectUtil.ex
|
|
|
2315
2315
|
}, "strict", import("zod").ZodTypeAny, {
|
|
2316
2316
|
name: string;
|
|
2317
2317
|
columns: Record<string, {
|
|
2318
|
+
default?: any;
|
|
2319
|
+
onUpdate?: any;
|
|
2320
|
+
autoincrement?: boolean | undefined;
|
|
2318
2321
|
name: string;
|
|
2319
2322
|
type: string;
|
|
2320
2323
|
primaryKey: boolean;
|
|
2321
2324
|
notNull: boolean;
|
|
2322
|
-
default?: any;
|
|
2323
|
-
onUpdate?: any;
|
|
2324
|
-
autoincrement?: boolean | undefined;
|
|
2325
2325
|
}>;
|
|
2326
2326
|
indexes: Record<string, {
|
|
2327
|
-
name: string;
|
|
2328
|
-
columns: string[];
|
|
2329
|
-
isUnique: boolean;
|
|
2330
2327
|
using?: "btree" | "hash" | undefined;
|
|
2331
2328
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
2332
2329
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
2330
|
+
name: string;
|
|
2331
|
+
columns: string[];
|
|
2332
|
+
isUnique: boolean;
|
|
2333
2333
|
}>;
|
|
2334
2334
|
foreignKeys: Record<string, {
|
|
2335
|
+
onUpdate?: string | undefined;
|
|
2336
|
+
onDelete?: string | undefined;
|
|
2335
2337
|
name: string;
|
|
2336
2338
|
tableFrom: string;
|
|
2337
2339
|
columnsFrom: string[];
|
|
2338
2340
|
tableTo: string;
|
|
2339
2341
|
columnsTo: string[];
|
|
2340
|
-
onUpdate?: string | undefined;
|
|
2341
|
-
onDelete?: string | undefined;
|
|
2342
2342
|
}>;
|
|
2343
2343
|
compositePrimaryKeys: Record<string, {
|
|
2344
2344
|
name: string;
|
|
@@ -2349,41 +2349,41 @@ export declare const schema: import("zod").ZodObject<import("zod").objectUtil.ex
|
|
|
2349
2349
|
columns: string[];
|
|
2350
2350
|
}>;
|
|
2351
2351
|
}, {
|
|
2352
|
+
uniqueConstraints?: Record<string, {
|
|
2353
|
+
name: string;
|
|
2354
|
+
columns: string[];
|
|
2355
|
+
}> | undefined;
|
|
2352
2356
|
name: string;
|
|
2353
2357
|
columns: Record<string, {
|
|
2358
|
+
default?: any;
|
|
2359
|
+
onUpdate?: any;
|
|
2360
|
+
autoincrement?: boolean | undefined;
|
|
2354
2361
|
name: string;
|
|
2355
2362
|
type: string;
|
|
2356
2363
|
primaryKey: boolean;
|
|
2357
2364
|
notNull: boolean;
|
|
2358
|
-
default?: any;
|
|
2359
|
-
onUpdate?: any;
|
|
2360
|
-
autoincrement?: boolean | undefined;
|
|
2361
2365
|
}>;
|
|
2362
2366
|
indexes: Record<string, {
|
|
2363
|
-
name: string;
|
|
2364
|
-
columns: string[];
|
|
2365
|
-
isUnique: boolean;
|
|
2366
2367
|
using?: "btree" | "hash" | undefined;
|
|
2367
2368
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
2368
2369
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
2370
|
+
name: string;
|
|
2371
|
+
columns: string[];
|
|
2372
|
+
isUnique: boolean;
|
|
2369
2373
|
}>;
|
|
2370
2374
|
foreignKeys: Record<string, {
|
|
2375
|
+
onUpdate?: string | undefined;
|
|
2376
|
+
onDelete?: string | undefined;
|
|
2371
2377
|
name: string;
|
|
2372
2378
|
tableFrom: string;
|
|
2373
2379
|
columnsFrom: string[];
|
|
2374
2380
|
tableTo: string;
|
|
2375
2381
|
columnsTo: string[];
|
|
2376
|
-
onUpdate?: string | undefined;
|
|
2377
|
-
onDelete?: string | undefined;
|
|
2378
2382
|
}>;
|
|
2379
2383
|
compositePrimaryKeys: Record<string, {
|
|
2380
2384
|
name: string;
|
|
2381
2385
|
columns: string[];
|
|
2382
2386
|
}>;
|
|
2383
|
-
uniqueConstraints?: Record<string, {
|
|
2384
|
-
name: string;
|
|
2385
|
-
columns: string[];
|
|
2386
|
-
}> | undefined;
|
|
2387
2387
|
}>>;
|
|
2388
2388
|
_meta: import("zod").ZodObject<{
|
|
2389
2389
|
tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
|
|
@@ -2430,33 +2430,40 @@ export declare const schema: import("zod").ZodObject<import("zod").objectUtil.ex
|
|
|
2430
2430
|
id: import("zod").ZodString;
|
|
2431
2431
|
prevId: import("zod").ZodString;
|
|
2432
2432
|
}>, "strip", import("zod").ZodTypeAny, {
|
|
2433
|
+
internal?: {
|
|
2434
|
+
tables: Record<string, {
|
|
2435
|
+
columns: Record<string, {
|
|
2436
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
2437
|
+
} | undefined>;
|
|
2438
|
+
} | undefined>;
|
|
2439
|
+
} | undefined;
|
|
2433
2440
|
tables: Record<string, {
|
|
2434
2441
|
name: string;
|
|
2435
2442
|
columns: Record<string, {
|
|
2443
|
+
default?: any;
|
|
2444
|
+
onUpdate?: any;
|
|
2445
|
+
autoincrement?: boolean | undefined;
|
|
2436
2446
|
name: string;
|
|
2437
2447
|
type: string;
|
|
2438
2448
|
primaryKey: boolean;
|
|
2439
2449
|
notNull: boolean;
|
|
2440
|
-
default?: any;
|
|
2441
|
-
onUpdate?: any;
|
|
2442
|
-
autoincrement?: boolean | undefined;
|
|
2443
2450
|
}>;
|
|
2444
2451
|
indexes: Record<string, {
|
|
2445
|
-
name: string;
|
|
2446
|
-
columns: string[];
|
|
2447
|
-
isUnique: boolean;
|
|
2448
2452
|
using?: "btree" | "hash" | undefined;
|
|
2449
2453
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
2450
2454
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
2455
|
+
name: string;
|
|
2456
|
+
columns: string[];
|
|
2457
|
+
isUnique: boolean;
|
|
2451
2458
|
}>;
|
|
2452
2459
|
foreignKeys: Record<string, {
|
|
2460
|
+
onUpdate?: string | undefined;
|
|
2461
|
+
onDelete?: string | undefined;
|
|
2453
2462
|
name: string;
|
|
2454
2463
|
tableFrom: string;
|
|
2455
2464
|
columnsFrom: string[];
|
|
2456
2465
|
tableTo: string;
|
|
2457
2466
|
columnsTo: string[];
|
|
2458
|
-
onUpdate?: string | undefined;
|
|
2459
|
-
onDelete?: string | undefined;
|
|
2460
2467
|
}>;
|
|
2461
2468
|
compositePrimaryKeys: Record<string, {
|
|
2462
2469
|
name: string;
|
|
@@ -2475,6 +2482,7 @@ export declare const schema: import("zod").ZodObject<import("zod").objectUtil.ex
|
|
|
2475
2482
|
columns: Record<string, string>;
|
|
2476
2483
|
tables: Record<string, string>;
|
|
2477
2484
|
};
|
|
2485
|
+
}, {
|
|
2478
2486
|
internal?: {
|
|
2479
2487
|
tables: Record<string, {
|
|
2480
2488
|
columns: Record<string, {
|
|
@@ -2482,43 +2490,42 @@ export declare const schema: import("zod").ZodObject<import("zod").objectUtil.ex
|
|
|
2482
2490
|
} | undefined>;
|
|
2483
2491
|
} | undefined>;
|
|
2484
2492
|
} | undefined;
|
|
2485
|
-
}, {
|
|
2486
2493
|
tables: Record<string, {
|
|
2494
|
+
uniqueConstraints?: Record<string, {
|
|
2495
|
+
name: string;
|
|
2496
|
+
columns: string[];
|
|
2497
|
+
}> | undefined;
|
|
2487
2498
|
name: string;
|
|
2488
2499
|
columns: Record<string, {
|
|
2500
|
+
default?: any;
|
|
2501
|
+
onUpdate?: any;
|
|
2502
|
+
autoincrement?: boolean | undefined;
|
|
2489
2503
|
name: string;
|
|
2490
2504
|
type: string;
|
|
2491
2505
|
primaryKey: boolean;
|
|
2492
2506
|
notNull: boolean;
|
|
2493
|
-
default?: any;
|
|
2494
|
-
onUpdate?: any;
|
|
2495
|
-
autoincrement?: boolean | undefined;
|
|
2496
2507
|
}>;
|
|
2497
2508
|
indexes: Record<string, {
|
|
2498
|
-
name: string;
|
|
2499
|
-
columns: string[];
|
|
2500
|
-
isUnique: boolean;
|
|
2501
2509
|
using?: "btree" | "hash" | undefined;
|
|
2502
2510
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
2503
2511
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
2512
|
+
name: string;
|
|
2513
|
+
columns: string[];
|
|
2514
|
+
isUnique: boolean;
|
|
2504
2515
|
}>;
|
|
2505
2516
|
foreignKeys: Record<string, {
|
|
2517
|
+
onUpdate?: string | undefined;
|
|
2518
|
+
onDelete?: string | undefined;
|
|
2506
2519
|
name: string;
|
|
2507
2520
|
tableFrom: string;
|
|
2508
2521
|
columnsFrom: string[];
|
|
2509
2522
|
tableTo: string;
|
|
2510
2523
|
columnsTo: string[];
|
|
2511
|
-
onUpdate?: string | undefined;
|
|
2512
|
-
onDelete?: string | undefined;
|
|
2513
2524
|
}>;
|
|
2514
2525
|
compositePrimaryKeys: Record<string, {
|
|
2515
2526
|
name: string;
|
|
2516
2527
|
columns: string[];
|
|
2517
2528
|
}>;
|
|
2518
|
-
uniqueConstraints?: Record<string, {
|
|
2519
|
-
name: string;
|
|
2520
|
-
columns: string[];
|
|
2521
|
-
}> | undefined;
|
|
2522
2529
|
}>;
|
|
2523
2530
|
id: string;
|
|
2524
2531
|
prevId: string;
|
|
@@ -2528,13 +2535,6 @@ export declare const schema: import("zod").ZodObject<import("zod").objectUtil.ex
|
|
|
2528
2535
|
columns: Record<string, string>;
|
|
2529
2536
|
tables: Record<string, string>;
|
|
2530
2537
|
};
|
|
2531
|
-
internal?: {
|
|
2532
|
-
tables: Record<string, {
|
|
2533
|
-
columns: Record<string, {
|
|
2534
|
-
isDefaultAnExpression?: boolean | undefined;
|
|
2535
|
-
} | undefined>;
|
|
2536
|
-
} | undefined>;
|
|
2537
|
-
} | undefined;
|
|
2538
2538
|
}>;
|
|
2539
2539
|
export declare const schemaSquashed: import("zod").ZodObject<{
|
|
2540
2540
|
version: import("zod").ZodLiteral<"5">;
|
|
@@ -2550,21 +2550,21 @@ export declare const schemaSquashed: import("zod").ZodObject<{
|
|
|
2550
2550
|
default: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
2551
2551
|
onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
2552
2552
|
}, "strict", import("zod").ZodTypeAny, {
|
|
2553
|
+
default?: any;
|
|
2554
|
+
onUpdate?: any;
|
|
2555
|
+
autoincrement?: boolean | undefined;
|
|
2553
2556
|
name: string;
|
|
2554
2557
|
type: string;
|
|
2555
2558
|
primaryKey: boolean;
|
|
2556
2559
|
notNull: boolean;
|
|
2560
|
+
}, {
|
|
2557
2561
|
default?: any;
|
|
2558
2562
|
onUpdate?: any;
|
|
2559
2563
|
autoincrement?: boolean | undefined;
|
|
2560
|
-
}, {
|
|
2561
2564
|
name: string;
|
|
2562
2565
|
type: string;
|
|
2563
2566
|
primaryKey: boolean;
|
|
2564
2567
|
notNull: boolean;
|
|
2565
|
-
default?: any;
|
|
2566
|
-
onUpdate?: any;
|
|
2567
|
-
autoincrement?: boolean | undefined;
|
|
2568
2568
|
}>>;
|
|
2569
2569
|
indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
|
|
2570
2570
|
foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
|
|
@@ -2573,45 +2573,45 @@ export declare const schemaSquashed: import("zod").ZodObject<{
|
|
|
2573
2573
|
}, "strict", import("zod").ZodTypeAny, {
|
|
2574
2574
|
name: string;
|
|
2575
2575
|
columns: Record<string, {
|
|
2576
|
+
default?: any;
|
|
2577
|
+
onUpdate?: any;
|
|
2578
|
+
autoincrement?: boolean | undefined;
|
|
2576
2579
|
name: string;
|
|
2577
2580
|
type: string;
|
|
2578
2581
|
primaryKey: boolean;
|
|
2579
2582
|
notNull: boolean;
|
|
2580
|
-
default?: any;
|
|
2581
|
-
onUpdate?: any;
|
|
2582
|
-
autoincrement?: boolean | undefined;
|
|
2583
2583
|
}>;
|
|
2584
2584
|
indexes: Record<string, string>;
|
|
2585
2585
|
foreignKeys: Record<string, string>;
|
|
2586
2586
|
compositePrimaryKeys: Record<string, string>;
|
|
2587
2587
|
uniqueConstraints: Record<string, string>;
|
|
2588
2588
|
}, {
|
|
2589
|
+
uniqueConstraints?: Record<string, string> | undefined;
|
|
2589
2590
|
name: string;
|
|
2590
2591
|
columns: Record<string, {
|
|
2592
|
+
default?: any;
|
|
2593
|
+
onUpdate?: any;
|
|
2594
|
+
autoincrement?: boolean | undefined;
|
|
2591
2595
|
name: string;
|
|
2592
2596
|
type: string;
|
|
2593
2597
|
primaryKey: boolean;
|
|
2594
2598
|
notNull: boolean;
|
|
2595
|
-
default?: any;
|
|
2596
|
-
onUpdate?: any;
|
|
2597
|
-
autoincrement?: boolean | undefined;
|
|
2598
2599
|
}>;
|
|
2599
2600
|
indexes: Record<string, string>;
|
|
2600
2601
|
foreignKeys: Record<string, string>;
|
|
2601
2602
|
compositePrimaryKeys: Record<string, string>;
|
|
2602
|
-
uniqueConstraints?: Record<string, string> | undefined;
|
|
2603
2603
|
}>>;
|
|
2604
2604
|
}, "strict", import("zod").ZodTypeAny, {
|
|
2605
2605
|
tables: Record<string, {
|
|
2606
2606
|
name: string;
|
|
2607
2607
|
columns: Record<string, {
|
|
2608
|
+
default?: any;
|
|
2609
|
+
onUpdate?: any;
|
|
2610
|
+
autoincrement?: boolean | undefined;
|
|
2608
2611
|
name: string;
|
|
2609
2612
|
type: string;
|
|
2610
2613
|
primaryKey: boolean;
|
|
2611
2614
|
notNull: boolean;
|
|
2612
|
-
default?: any;
|
|
2613
|
-
onUpdate?: any;
|
|
2614
|
-
autoincrement?: boolean | undefined;
|
|
2615
2615
|
}>;
|
|
2616
2616
|
indexes: Record<string, string>;
|
|
2617
2617
|
foreignKeys: Record<string, string>;
|
|
@@ -2622,20 +2622,20 @@ export declare const schemaSquashed: import("zod").ZodObject<{
|
|
|
2622
2622
|
dialect: "mysql";
|
|
2623
2623
|
}, {
|
|
2624
2624
|
tables: Record<string, {
|
|
2625
|
+
uniqueConstraints?: Record<string, string> | undefined;
|
|
2625
2626
|
name: string;
|
|
2626
2627
|
columns: Record<string, {
|
|
2628
|
+
default?: any;
|
|
2629
|
+
onUpdate?: any;
|
|
2630
|
+
autoincrement?: boolean | undefined;
|
|
2627
2631
|
name: string;
|
|
2628
2632
|
type: string;
|
|
2629
2633
|
primaryKey: boolean;
|
|
2630
2634
|
notNull: boolean;
|
|
2631
|
-
default?: any;
|
|
2632
|
-
onUpdate?: any;
|
|
2633
|
-
autoincrement?: boolean | undefined;
|
|
2634
2635
|
}>;
|
|
2635
2636
|
indexes: Record<string, string>;
|
|
2636
2637
|
foreignKeys: Record<string, string>;
|
|
2637
2638
|
compositePrimaryKeys: Record<string, string>;
|
|
2638
|
-
uniqueConstraints?: Record<string, string> | undefined;
|
|
2639
2639
|
}>;
|
|
2640
2640
|
version: "5";
|
|
2641
2641
|
dialect: "mysql";
|
|
@@ -2655,88 +2655,88 @@ export declare const schemaSquashedV4: import("zod").ZodObject<{
|
|
|
2655
2655
|
default: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
2656
2656
|
onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
2657
2657
|
}, "strict", import("zod").ZodTypeAny, {
|
|
2658
|
+
default?: any;
|
|
2659
|
+
onUpdate?: any;
|
|
2660
|
+
autoincrement?: boolean | undefined;
|
|
2658
2661
|
name: string;
|
|
2659
2662
|
type: string;
|
|
2660
2663
|
primaryKey: boolean;
|
|
2661
2664
|
notNull: boolean;
|
|
2665
|
+
}, {
|
|
2662
2666
|
default?: any;
|
|
2663
2667
|
onUpdate?: any;
|
|
2664
2668
|
autoincrement?: boolean | undefined;
|
|
2665
|
-
}, {
|
|
2666
2669
|
name: string;
|
|
2667
2670
|
type: string;
|
|
2668
2671
|
primaryKey: boolean;
|
|
2669
2672
|
notNull: boolean;
|
|
2670
|
-
default?: any;
|
|
2671
|
-
onUpdate?: any;
|
|
2672
|
-
autoincrement?: boolean | undefined;
|
|
2673
2673
|
}>>;
|
|
2674
2674
|
indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
|
|
2675
2675
|
foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
|
|
2676
2676
|
}, "strict", import("zod").ZodTypeAny, {
|
|
2677
|
+
schema?: string | undefined;
|
|
2677
2678
|
name: string;
|
|
2678
2679
|
columns: Record<string, {
|
|
2680
|
+
default?: any;
|
|
2681
|
+
onUpdate?: any;
|
|
2682
|
+
autoincrement?: boolean | undefined;
|
|
2679
2683
|
name: string;
|
|
2680
2684
|
type: string;
|
|
2681
2685
|
primaryKey: boolean;
|
|
2682
2686
|
notNull: boolean;
|
|
2683
|
-
default?: any;
|
|
2684
|
-
onUpdate?: any;
|
|
2685
|
-
autoincrement?: boolean | undefined;
|
|
2686
2687
|
}>;
|
|
2687
2688
|
indexes: Record<string, string>;
|
|
2688
2689
|
foreignKeys: Record<string, string>;
|
|
2689
|
-
schema?: string | undefined;
|
|
2690
2690
|
}, {
|
|
2691
|
+
schema?: string | undefined;
|
|
2691
2692
|
name: string;
|
|
2692
2693
|
columns: Record<string, {
|
|
2694
|
+
default?: any;
|
|
2695
|
+
onUpdate?: any;
|
|
2696
|
+
autoincrement?: boolean | undefined;
|
|
2693
2697
|
name: string;
|
|
2694
2698
|
type: string;
|
|
2695
2699
|
primaryKey: boolean;
|
|
2696
2700
|
notNull: boolean;
|
|
2697
|
-
default?: any;
|
|
2698
|
-
onUpdate?: any;
|
|
2699
|
-
autoincrement?: boolean | undefined;
|
|
2700
2701
|
}>;
|
|
2701
2702
|
indexes: Record<string, string>;
|
|
2702
2703
|
foreignKeys: Record<string, string>;
|
|
2703
|
-
schema?: string | undefined;
|
|
2704
2704
|
}>>;
|
|
2705
2705
|
schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
|
|
2706
2706
|
}, "strict", import("zod").ZodTypeAny, {
|
|
2707
2707
|
tables: Record<string, {
|
|
2708
|
+
schema?: string | undefined;
|
|
2708
2709
|
name: string;
|
|
2709
2710
|
columns: Record<string, {
|
|
2711
|
+
default?: any;
|
|
2712
|
+
onUpdate?: any;
|
|
2713
|
+
autoincrement?: boolean | undefined;
|
|
2710
2714
|
name: string;
|
|
2711
2715
|
type: string;
|
|
2712
2716
|
primaryKey: boolean;
|
|
2713
2717
|
notNull: boolean;
|
|
2714
|
-
default?: any;
|
|
2715
|
-
onUpdate?: any;
|
|
2716
|
-
autoincrement?: boolean | undefined;
|
|
2717
2718
|
}>;
|
|
2718
2719
|
indexes: Record<string, string>;
|
|
2719
2720
|
foreignKeys: Record<string, string>;
|
|
2720
|
-
schema?: string | undefined;
|
|
2721
2721
|
}>;
|
|
2722
2722
|
version: "4";
|
|
2723
2723
|
dialect: "mysql";
|
|
2724
2724
|
schemas: Record<string, string>;
|
|
2725
2725
|
}, {
|
|
2726
2726
|
tables: Record<string, {
|
|
2727
|
+
schema?: string | undefined;
|
|
2727
2728
|
name: string;
|
|
2728
2729
|
columns: Record<string, {
|
|
2730
|
+
default?: any;
|
|
2731
|
+
onUpdate?: any;
|
|
2732
|
+
autoincrement?: boolean | undefined;
|
|
2729
2733
|
name: string;
|
|
2730
2734
|
type: string;
|
|
2731
2735
|
primaryKey: boolean;
|
|
2732
2736
|
notNull: boolean;
|
|
2733
|
-
default?: any;
|
|
2734
|
-
onUpdate?: any;
|
|
2735
|
-
autoincrement?: boolean | undefined;
|
|
2736
2737
|
}>;
|
|
2737
2738
|
indexes: Record<string, string>;
|
|
2738
2739
|
foreignKeys: Record<string, string>;
|
|
2739
|
-
schema?: string | undefined;
|
|
2740
2740
|
}>;
|
|
2741
2741
|
version: "4";
|
|
2742
2742
|
dialect: "mysql";
|
|
@@ -2770,7 +2770,7 @@ export declare const MySqlSquasher: {
|
|
|
2770
2770
|
};
|
|
2771
2771
|
export declare const squashMysqlSchemeV4: (json: MySqlSchemaV4) => MySqlSchemaSquashedV4;
|
|
2772
2772
|
export declare const squashMysqlScheme: (json: MySqlSchema) => MySqlSchemaSquashed;
|
|
2773
|
-
export declare const mysqlSchema: import("zod").ZodObject<import("zod").
|
|
2773
|
+
export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendShape<{
|
|
2774
2774
|
version: import("zod").ZodLiteral<"5">;
|
|
2775
2775
|
dialect: import("zod").ZodLiteral<"mysql">;
|
|
2776
2776
|
tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
@@ -2784,21 +2784,21 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").objectUt
|
|
|
2784
2784
|
default: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
2785
2785
|
onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
2786
2786
|
}, "strict", import("zod").ZodTypeAny, {
|
|
2787
|
+
default?: any;
|
|
2788
|
+
onUpdate?: any;
|
|
2789
|
+
autoincrement?: boolean | undefined;
|
|
2787
2790
|
name: string;
|
|
2788
2791
|
type: string;
|
|
2789
2792
|
primaryKey: boolean;
|
|
2790
2793
|
notNull: boolean;
|
|
2794
|
+
}, {
|
|
2791
2795
|
default?: any;
|
|
2792
2796
|
onUpdate?: any;
|
|
2793
2797
|
autoincrement?: boolean | undefined;
|
|
2794
|
-
}, {
|
|
2795
2798
|
name: string;
|
|
2796
2799
|
type: string;
|
|
2797
2800
|
primaryKey: boolean;
|
|
2798
2801
|
notNull: boolean;
|
|
2799
|
-
default?: any;
|
|
2800
|
-
onUpdate?: any;
|
|
2801
|
-
autoincrement?: boolean | undefined;
|
|
2802
2802
|
}>>;
|
|
2803
2803
|
indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
2804
2804
|
name: import("zod").ZodString;
|
|
@@ -2808,19 +2808,19 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").objectUt
|
|
|
2808
2808
|
algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
|
|
2809
2809
|
lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
|
|
2810
2810
|
}, "strict", import("zod").ZodTypeAny, {
|
|
2811
|
-
name: string;
|
|
2812
|
-
columns: string[];
|
|
2813
|
-
isUnique: boolean;
|
|
2814
2811
|
using?: "btree" | "hash" | undefined;
|
|
2815
2812
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
2816
2813
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
2817
|
-
}, {
|
|
2818
2814
|
name: string;
|
|
2819
2815
|
columns: string[];
|
|
2820
2816
|
isUnique: boolean;
|
|
2817
|
+
}, {
|
|
2821
2818
|
using?: "btree" | "hash" | undefined;
|
|
2822
2819
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
2823
2820
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
2821
|
+
name: string;
|
|
2822
|
+
columns: string[];
|
|
2823
|
+
isUnique: boolean;
|
|
2824
2824
|
}>>;
|
|
2825
2825
|
foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
2826
2826
|
name: import("zod").ZodString;
|
|
@@ -2831,21 +2831,21 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").objectUt
|
|
|
2831
2831
|
onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
|
|
2832
2832
|
onDelete: import("zod").ZodOptional<import("zod").ZodString>;
|
|
2833
2833
|
}, "strict", import("zod").ZodTypeAny, {
|
|
2834
|
+
onUpdate?: string | undefined;
|
|
2835
|
+
onDelete?: string | undefined;
|
|
2834
2836
|
name: string;
|
|
2835
2837
|
tableFrom: string;
|
|
2836
2838
|
columnsFrom: string[];
|
|
2837
2839
|
tableTo: string;
|
|
2838
2840
|
columnsTo: string[];
|
|
2841
|
+
}, {
|
|
2839
2842
|
onUpdate?: string | undefined;
|
|
2840
2843
|
onDelete?: string | undefined;
|
|
2841
|
-
}, {
|
|
2842
2844
|
name: string;
|
|
2843
2845
|
tableFrom: string;
|
|
2844
2846
|
columnsFrom: string[];
|
|
2845
2847
|
tableTo: string;
|
|
2846
2848
|
columnsTo: string[];
|
|
2847
|
-
onUpdate?: string | undefined;
|
|
2848
|
-
onDelete?: string | undefined;
|
|
2849
2849
|
}>>;
|
|
2850
2850
|
compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
2851
2851
|
name: import("zod").ZodString;
|
|
@@ -2870,30 +2870,30 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").objectUt
|
|
|
2870
2870
|
}, "strict", import("zod").ZodTypeAny, {
|
|
2871
2871
|
name: string;
|
|
2872
2872
|
columns: Record<string, {
|
|
2873
|
+
default?: any;
|
|
2874
|
+
onUpdate?: any;
|
|
2875
|
+
autoincrement?: boolean | undefined;
|
|
2873
2876
|
name: string;
|
|
2874
2877
|
type: string;
|
|
2875
2878
|
primaryKey: boolean;
|
|
2876
2879
|
notNull: boolean;
|
|
2877
|
-
default?: any;
|
|
2878
|
-
onUpdate?: any;
|
|
2879
|
-
autoincrement?: boolean | undefined;
|
|
2880
2880
|
}>;
|
|
2881
2881
|
indexes: Record<string, {
|
|
2882
|
-
name: string;
|
|
2883
|
-
columns: string[];
|
|
2884
|
-
isUnique: boolean;
|
|
2885
2882
|
using?: "btree" | "hash" | undefined;
|
|
2886
2883
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
2887
2884
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
2885
|
+
name: string;
|
|
2886
|
+
columns: string[];
|
|
2887
|
+
isUnique: boolean;
|
|
2888
2888
|
}>;
|
|
2889
2889
|
foreignKeys: Record<string, {
|
|
2890
|
+
onUpdate?: string | undefined;
|
|
2891
|
+
onDelete?: string | undefined;
|
|
2890
2892
|
name: string;
|
|
2891
2893
|
tableFrom: string;
|
|
2892
2894
|
columnsFrom: string[];
|
|
2893
2895
|
tableTo: string;
|
|
2894
2896
|
columnsTo: string[];
|
|
2895
|
-
onUpdate?: string | undefined;
|
|
2896
|
-
onDelete?: string | undefined;
|
|
2897
2897
|
}>;
|
|
2898
2898
|
compositePrimaryKeys: Record<string, {
|
|
2899
2899
|
name: string;
|
|
@@ -2904,41 +2904,41 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").objectUt
|
|
|
2904
2904
|
columns: string[];
|
|
2905
2905
|
}>;
|
|
2906
2906
|
}, {
|
|
2907
|
+
uniqueConstraints?: Record<string, {
|
|
2908
|
+
name: string;
|
|
2909
|
+
columns: string[];
|
|
2910
|
+
}> | undefined;
|
|
2907
2911
|
name: string;
|
|
2908
2912
|
columns: Record<string, {
|
|
2913
|
+
default?: any;
|
|
2914
|
+
onUpdate?: any;
|
|
2915
|
+
autoincrement?: boolean | undefined;
|
|
2909
2916
|
name: string;
|
|
2910
2917
|
type: string;
|
|
2911
2918
|
primaryKey: boolean;
|
|
2912
2919
|
notNull: boolean;
|
|
2913
|
-
default?: any;
|
|
2914
|
-
onUpdate?: any;
|
|
2915
|
-
autoincrement?: boolean | undefined;
|
|
2916
2920
|
}>;
|
|
2917
2921
|
indexes: Record<string, {
|
|
2918
|
-
name: string;
|
|
2919
|
-
columns: string[];
|
|
2920
|
-
isUnique: boolean;
|
|
2921
2922
|
using?: "btree" | "hash" | undefined;
|
|
2922
2923
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
2923
2924
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
2925
|
+
name: string;
|
|
2926
|
+
columns: string[];
|
|
2927
|
+
isUnique: boolean;
|
|
2924
2928
|
}>;
|
|
2925
2929
|
foreignKeys: Record<string, {
|
|
2930
|
+
onUpdate?: string | undefined;
|
|
2931
|
+
onDelete?: string | undefined;
|
|
2926
2932
|
name: string;
|
|
2927
2933
|
tableFrom: string;
|
|
2928
2934
|
columnsFrom: string[];
|
|
2929
2935
|
tableTo: string;
|
|
2930
2936
|
columnsTo: string[];
|
|
2931
|
-
onUpdate?: string | undefined;
|
|
2932
|
-
onDelete?: string | undefined;
|
|
2933
2937
|
}>;
|
|
2934
2938
|
compositePrimaryKeys: Record<string, {
|
|
2935
2939
|
name: string;
|
|
2936
2940
|
columns: string[];
|
|
2937
2941
|
}>;
|
|
2938
|
-
uniqueConstraints?: Record<string, {
|
|
2939
|
-
name: string;
|
|
2940
|
-
columns: string[];
|
|
2941
|
-
}> | undefined;
|
|
2942
2942
|
}>>;
|
|
2943
2943
|
_meta: import("zod").ZodObject<{
|
|
2944
2944
|
tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
|
|
@@ -2985,33 +2985,40 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").objectUt
|
|
|
2985
2985
|
id: import("zod").ZodString;
|
|
2986
2986
|
prevId: import("zod").ZodString;
|
|
2987
2987
|
}>, "strip", import("zod").ZodTypeAny, {
|
|
2988
|
+
internal?: {
|
|
2989
|
+
tables: Record<string, {
|
|
2990
|
+
columns: Record<string, {
|
|
2991
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
2992
|
+
} | undefined>;
|
|
2993
|
+
} | undefined>;
|
|
2994
|
+
} | undefined;
|
|
2988
2995
|
tables: Record<string, {
|
|
2989
2996
|
name: string;
|
|
2990
2997
|
columns: Record<string, {
|
|
2998
|
+
default?: any;
|
|
2999
|
+
onUpdate?: any;
|
|
3000
|
+
autoincrement?: boolean | undefined;
|
|
2991
3001
|
name: string;
|
|
2992
3002
|
type: string;
|
|
2993
3003
|
primaryKey: boolean;
|
|
2994
3004
|
notNull: boolean;
|
|
2995
|
-
default?: any;
|
|
2996
|
-
onUpdate?: any;
|
|
2997
|
-
autoincrement?: boolean | undefined;
|
|
2998
3005
|
}>;
|
|
2999
3006
|
indexes: Record<string, {
|
|
3000
|
-
name: string;
|
|
3001
|
-
columns: string[];
|
|
3002
|
-
isUnique: boolean;
|
|
3003
3007
|
using?: "btree" | "hash" | undefined;
|
|
3004
3008
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
3005
3009
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
3010
|
+
name: string;
|
|
3011
|
+
columns: string[];
|
|
3012
|
+
isUnique: boolean;
|
|
3006
3013
|
}>;
|
|
3007
3014
|
foreignKeys: Record<string, {
|
|
3015
|
+
onUpdate?: string | undefined;
|
|
3016
|
+
onDelete?: string | undefined;
|
|
3008
3017
|
name: string;
|
|
3009
3018
|
tableFrom: string;
|
|
3010
3019
|
columnsFrom: string[];
|
|
3011
3020
|
tableTo: string;
|
|
3012
3021
|
columnsTo: string[];
|
|
3013
|
-
onUpdate?: string | undefined;
|
|
3014
|
-
onDelete?: string | undefined;
|
|
3015
3022
|
}>;
|
|
3016
3023
|
compositePrimaryKeys: Record<string, {
|
|
3017
3024
|
name: string;
|
|
@@ -3030,6 +3037,7 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").objectUt
|
|
|
3030
3037
|
columns: Record<string, string>;
|
|
3031
3038
|
tables: Record<string, string>;
|
|
3032
3039
|
};
|
|
3040
|
+
}, {
|
|
3033
3041
|
internal?: {
|
|
3034
3042
|
tables: Record<string, {
|
|
3035
3043
|
columns: Record<string, {
|
|
@@ -3037,43 +3045,42 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").objectUt
|
|
|
3037
3045
|
} | undefined>;
|
|
3038
3046
|
} | undefined>;
|
|
3039
3047
|
} | undefined;
|
|
3040
|
-
}, {
|
|
3041
3048
|
tables: Record<string, {
|
|
3049
|
+
uniqueConstraints?: Record<string, {
|
|
3050
|
+
name: string;
|
|
3051
|
+
columns: string[];
|
|
3052
|
+
}> | undefined;
|
|
3042
3053
|
name: string;
|
|
3043
3054
|
columns: Record<string, {
|
|
3055
|
+
default?: any;
|
|
3056
|
+
onUpdate?: any;
|
|
3057
|
+
autoincrement?: boolean | undefined;
|
|
3044
3058
|
name: string;
|
|
3045
3059
|
type: string;
|
|
3046
3060
|
primaryKey: boolean;
|
|
3047
3061
|
notNull: boolean;
|
|
3048
|
-
default?: any;
|
|
3049
|
-
onUpdate?: any;
|
|
3050
|
-
autoincrement?: boolean | undefined;
|
|
3051
3062
|
}>;
|
|
3052
3063
|
indexes: Record<string, {
|
|
3053
|
-
name: string;
|
|
3054
|
-
columns: string[];
|
|
3055
|
-
isUnique: boolean;
|
|
3056
3064
|
using?: "btree" | "hash" | undefined;
|
|
3057
3065
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
3058
3066
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
3067
|
+
name: string;
|
|
3068
|
+
columns: string[];
|
|
3069
|
+
isUnique: boolean;
|
|
3059
3070
|
}>;
|
|
3060
3071
|
foreignKeys: Record<string, {
|
|
3072
|
+
onUpdate?: string | undefined;
|
|
3073
|
+
onDelete?: string | undefined;
|
|
3061
3074
|
name: string;
|
|
3062
3075
|
tableFrom: string;
|
|
3063
3076
|
columnsFrom: string[];
|
|
3064
3077
|
tableTo: string;
|
|
3065
3078
|
columnsTo: string[];
|
|
3066
|
-
onUpdate?: string | undefined;
|
|
3067
|
-
onDelete?: string | undefined;
|
|
3068
3079
|
}>;
|
|
3069
3080
|
compositePrimaryKeys: Record<string, {
|
|
3070
3081
|
name: string;
|
|
3071
3082
|
columns: string[];
|
|
3072
3083
|
}>;
|
|
3073
|
-
uniqueConstraints?: Record<string, {
|
|
3074
|
-
name: string;
|
|
3075
|
-
columns: string[];
|
|
3076
|
-
}> | undefined;
|
|
3077
3084
|
}>;
|
|
3078
3085
|
id: string;
|
|
3079
3086
|
prevId: string;
|
|
@@ -3083,15 +3090,8 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").objectUt
|
|
|
3083
3090
|
columns: Record<string, string>;
|
|
3084
3091
|
tables: Record<string, string>;
|
|
3085
3092
|
};
|
|
3086
|
-
internal?: {
|
|
3087
|
-
tables: Record<string, {
|
|
3088
|
-
columns: Record<string, {
|
|
3089
|
-
isDefaultAnExpression?: boolean | undefined;
|
|
3090
|
-
} | undefined>;
|
|
3091
|
-
} | undefined>;
|
|
3092
|
-
} | undefined;
|
|
3093
3093
|
}>;
|
|
3094
|
-
export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").
|
|
3094
|
+
export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extendShape<{
|
|
3095
3095
|
version: import("zod").ZodLiteral<"3">;
|
|
3096
3096
|
dialect: import("zod").ZodLiteral<"mysql">;
|
|
3097
3097
|
tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
@@ -3105,21 +3105,21 @@ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").object
|
|
|
3105
3105
|
default: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
3106
3106
|
onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
3107
3107
|
}, "strict", import("zod").ZodTypeAny, {
|
|
3108
|
+
default?: any;
|
|
3109
|
+
onUpdate?: any;
|
|
3110
|
+
autoincrement?: boolean | undefined;
|
|
3108
3111
|
name: string;
|
|
3109
3112
|
type: string;
|
|
3110
3113
|
primaryKey: boolean;
|
|
3111
3114
|
notNull: boolean;
|
|
3115
|
+
}, {
|
|
3112
3116
|
default?: any;
|
|
3113
3117
|
onUpdate?: any;
|
|
3114
3118
|
autoincrement?: boolean | undefined;
|
|
3115
|
-
}, {
|
|
3116
3119
|
name: string;
|
|
3117
3120
|
type: string;
|
|
3118
3121
|
primaryKey: boolean;
|
|
3119
3122
|
notNull: boolean;
|
|
3120
|
-
default?: any;
|
|
3121
|
-
onUpdate?: any;
|
|
3122
|
-
autoincrement?: boolean | undefined;
|
|
3123
3123
|
}>>;
|
|
3124
3124
|
indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
3125
3125
|
name: import("zod").ZodString;
|
|
@@ -3129,19 +3129,19 @@ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").object
|
|
|
3129
3129
|
algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
|
|
3130
3130
|
lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
|
|
3131
3131
|
}, "strict", import("zod").ZodTypeAny, {
|
|
3132
|
-
name: string;
|
|
3133
|
-
columns: string[];
|
|
3134
|
-
isUnique: boolean;
|
|
3135
3132
|
using?: "btree" | "hash" | undefined;
|
|
3136
3133
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
3137
3134
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
3138
|
-
}, {
|
|
3139
3135
|
name: string;
|
|
3140
3136
|
columns: string[];
|
|
3141
3137
|
isUnique: boolean;
|
|
3138
|
+
}, {
|
|
3142
3139
|
using?: "btree" | "hash" | undefined;
|
|
3143
3140
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
3144
3141
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
3142
|
+
name: string;
|
|
3143
|
+
columns: string[];
|
|
3144
|
+
isUnique: boolean;
|
|
3145
3145
|
}>>;
|
|
3146
3146
|
foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
3147
3147
|
name: import("zod").ZodString;
|
|
@@ -3152,77 +3152,77 @@ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").object
|
|
|
3152
3152
|
onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
|
|
3153
3153
|
onDelete: import("zod").ZodOptional<import("zod").ZodString>;
|
|
3154
3154
|
}, "strict", import("zod").ZodTypeAny, {
|
|
3155
|
+
onUpdate?: string | undefined;
|
|
3156
|
+
onDelete?: string | undefined;
|
|
3155
3157
|
name: string;
|
|
3156
3158
|
tableFrom: string;
|
|
3157
3159
|
columnsFrom: string[];
|
|
3158
3160
|
tableTo: string;
|
|
3159
3161
|
columnsTo: string[];
|
|
3162
|
+
}, {
|
|
3160
3163
|
onUpdate?: string | undefined;
|
|
3161
3164
|
onDelete?: string | undefined;
|
|
3162
|
-
}, {
|
|
3163
3165
|
name: string;
|
|
3164
3166
|
tableFrom: string;
|
|
3165
3167
|
columnsFrom: string[];
|
|
3166
3168
|
tableTo: string;
|
|
3167
3169
|
columnsTo: string[];
|
|
3168
|
-
onUpdate?: string | undefined;
|
|
3169
|
-
onDelete?: string | undefined;
|
|
3170
3170
|
}>>;
|
|
3171
3171
|
}, "strict", import("zod").ZodTypeAny, {
|
|
3172
3172
|
name: string;
|
|
3173
3173
|
columns: Record<string, {
|
|
3174
|
+
default?: any;
|
|
3175
|
+
onUpdate?: any;
|
|
3176
|
+
autoincrement?: boolean | undefined;
|
|
3174
3177
|
name: string;
|
|
3175
3178
|
type: string;
|
|
3176
3179
|
primaryKey: boolean;
|
|
3177
3180
|
notNull: boolean;
|
|
3178
|
-
default?: any;
|
|
3179
|
-
onUpdate?: any;
|
|
3180
|
-
autoincrement?: boolean | undefined;
|
|
3181
3181
|
}>;
|
|
3182
3182
|
indexes: Record<string, {
|
|
3183
|
-
name: string;
|
|
3184
|
-
columns: string[];
|
|
3185
|
-
isUnique: boolean;
|
|
3186
3183
|
using?: "btree" | "hash" | undefined;
|
|
3187
3184
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
3188
3185
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
3186
|
+
name: string;
|
|
3187
|
+
columns: string[];
|
|
3188
|
+
isUnique: boolean;
|
|
3189
3189
|
}>;
|
|
3190
3190
|
foreignKeys: Record<string, {
|
|
3191
|
+
onUpdate?: string | undefined;
|
|
3192
|
+
onDelete?: string | undefined;
|
|
3191
3193
|
name: string;
|
|
3192
3194
|
tableFrom: string;
|
|
3193
3195
|
columnsFrom: string[];
|
|
3194
3196
|
tableTo: string;
|
|
3195
3197
|
columnsTo: string[];
|
|
3196
|
-
onUpdate?: string | undefined;
|
|
3197
|
-
onDelete?: string | undefined;
|
|
3198
3198
|
}>;
|
|
3199
3199
|
}, {
|
|
3200
3200
|
name: string;
|
|
3201
3201
|
columns: Record<string, {
|
|
3202
|
+
default?: any;
|
|
3203
|
+
onUpdate?: any;
|
|
3204
|
+
autoincrement?: boolean | undefined;
|
|
3202
3205
|
name: string;
|
|
3203
3206
|
type: string;
|
|
3204
3207
|
primaryKey: boolean;
|
|
3205
3208
|
notNull: boolean;
|
|
3206
|
-
default?: any;
|
|
3207
|
-
onUpdate?: any;
|
|
3208
|
-
autoincrement?: boolean | undefined;
|
|
3209
3209
|
}>;
|
|
3210
3210
|
indexes: Record<string, {
|
|
3211
|
-
name: string;
|
|
3212
|
-
columns: string[];
|
|
3213
|
-
isUnique: boolean;
|
|
3214
3211
|
using?: "btree" | "hash" | undefined;
|
|
3215
3212
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
3216
3213
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
3214
|
+
name: string;
|
|
3215
|
+
columns: string[];
|
|
3216
|
+
isUnique: boolean;
|
|
3217
3217
|
}>;
|
|
3218
3218
|
foreignKeys: Record<string, {
|
|
3219
|
+
onUpdate?: string | undefined;
|
|
3220
|
+
onDelete?: string | undefined;
|
|
3219
3221
|
name: string;
|
|
3220
3222
|
tableFrom: string;
|
|
3221
3223
|
columnsFrom: string[];
|
|
3222
3224
|
tableTo: string;
|
|
3223
3225
|
columnsTo: string[];
|
|
3224
|
-
onUpdate?: string | undefined;
|
|
3225
|
-
onDelete?: string | undefined;
|
|
3226
3226
|
}>;
|
|
3227
3227
|
}>>;
|
|
3228
3228
|
}, {
|
|
@@ -3232,30 +3232,30 @@ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").object
|
|
|
3232
3232
|
tables: Record<string, {
|
|
3233
3233
|
name: string;
|
|
3234
3234
|
columns: Record<string, {
|
|
3235
|
+
default?: any;
|
|
3236
|
+
onUpdate?: any;
|
|
3237
|
+
autoincrement?: boolean | undefined;
|
|
3235
3238
|
name: string;
|
|
3236
3239
|
type: string;
|
|
3237
3240
|
primaryKey: boolean;
|
|
3238
3241
|
notNull: boolean;
|
|
3239
|
-
default?: any;
|
|
3240
|
-
onUpdate?: any;
|
|
3241
|
-
autoincrement?: boolean | undefined;
|
|
3242
3242
|
}>;
|
|
3243
3243
|
indexes: Record<string, {
|
|
3244
|
-
name: string;
|
|
3245
|
-
columns: string[];
|
|
3246
|
-
isUnique: boolean;
|
|
3247
3244
|
using?: "btree" | "hash" | undefined;
|
|
3248
3245
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
3249
3246
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
3247
|
+
name: string;
|
|
3248
|
+
columns: string[];
|
|
3249
|
+
isUnique: boolean;
|
|
3250
3250
|
}>;
|
|
3251
3251
|
foreignKeys: Record<string, {
|
|
3252
|
+
onUpdate?: string | undefined;
|
|
3253
|
+
onDelete?: string | undefined;
|
|
3252
3254
|
name: string;
|
|
3253
3255
|
tableFrom: string;
|
|
3254
3256
|
columnsFrom: string[];
|
|
3255
3257
|
tableTo: string;
|
|
3256
3258
|
columnsTo: string[];
|
|
3257
|
-
onUpdate?: string | undefined;
|
|
3258
|
-
onDelete?: string | undefined;
|
|
3259
3259
|
}>;
|
|
3260
3260
|
}>;
|
|
3261
3261
|
id: string;
|
|
@@ -3266,30 +3266,30 @@ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").object
|
|
|
3266
3266
|
tables: Record<string, {
|
|
3267
3267
|
name: string;
|
|
3268
3268
|
columns: Record<string, {
|
|
3269
|
+
default?: any;
|
|
3270
|
+
onUpdate?: any;
|
|
3271
|
+
autoincrement?: boolean | undefined;
|
|
3269
3272
|
name: string;
|
|
3270
3273
|
type: string;
|
|
3271
3274
|
primaryKey: boolean;
|
|
3272
3275
|
notNull: boolean;
|
|
3273
|
-
default?: any;
|
|
3274
|
-
onUpdate?: any;
|
|
3275
|
-
autoincrement?: boolean | undefined;
|
|
3276
3276
|
}>;
|
|
3277
|
-
indexes: Record<string, {
|
|
3278
|
-
name: string;
|
|
3279
|
-
columns: string[];
|
|
3280
|
-
isUnique: boolean;
|
|
3277
|
+
indexes: Record<string, {
|
|
3281
3278
|
using?: "btree" | "hash" | undefined;
|
|
3282
3279
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
3283
3280
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
3281
|
+
name: string;
|
|
3282
|
+
columns: string[];
|
|
3283
|
+
isUnique: boolean;
|
|
3284
3284
|
}>;
|
|
3285
3285
|
foreignKeys: Record<string, {
|
|
3286
|
+
onUpdate?: string | undefined;
|
|
3287
|
+
onDelete?: string | undefined;
|
|
3286
3288
|
name: string;
|
|
3287
3289
|
tableFrom: string;
|
|
3288
3290
|
columnsFrom: string[];
|
|
3289
3291
|
tableTo: string;
|
|
3290
3292
|
columnsTo: string[];
|
|
3291
|
-
onUpdate?: string | undefined;
|
|
3292
|
-
onDelete?: string | undefined;
|
|
3293
3293
|
}>;
|
|
3294
3294
|
}>;
|
|
3295
3295
|
id: string;
|
|
@@ -3297,7 +3297,7 @@ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").object
|
|
|
3297
3297
|
version: "3";
|
|
3298
3298
|
dialect: "mysql";
|
|
3299
3299
|
}>;
|
|
3300
|
-
export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").
|
|
3300
|
+
export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extendShape<{
|
|
3301
3301
|
version: import("zod").ZodLiteral<"4">;
|
|
3302
3302
|
dialect: import("zod").ZodLiteral<"mysql">;
|
|
3303
3303
|
tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
@@ -3312,21 +3312,21 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").object
|
|
|
3312
3312
|
default: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
3313
3313
|
onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
3314
3314
|
}, "strict", import("zod").ZodTypeAny, {
|
|
3315
|
+
default?: any;
|
|
3316
|
+
onUpdate?: any;
|
|
3317
|
+
autoincrement?: boolean | undefined;
|
|
3315
3318
|
name: string;
|
|
3316
3319
|
type: string;
|
|
3317
3320
|
primaryKey: boolean;
|
|
3318
3321
|
notNull: boolean;
|
|
3322
|
+
}, {
|
|
3319
3323
|
default?: any;
|
|
3320
3324
|
onUpdate?: any;
|
|
3321
3325
|
autoincrement?: boolean | undefined;
|
|
3322
|
-
}, {
|
|
3323
3326
|
name: string;
|
|
3324
3327
|
type: string;
|
|
3325
3328
|
primaryKey: boolean;
|
|
3326
3329
|
notNull: boolean;
|
|
3327
|
-
default?: any;
|
|
3328
|
-
onUpdate?: any;
|
|
3329
|
-
autoincrement?: boolean | undefined;
|
|
3330
3330
|
}>>;
|
|
3331
3331
|
indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
3332
3332
|
name: import("zod").ZodString;
|
|
@@ -3336,19 +3336,19 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").object
|
|
|
3336
3336
|
algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
|
|
3337
3337
|
lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
|
|
3338
3338
|
}, "strict", import("zod").ZodTypeAny, {
|
|
3339
|
-
name: string;
|
|
3340
|
-
columns: string[];
|
|
3341
|
-
isUnique: boolean;
|
|
3342
3339
|
using?: "btree" | "hash" | undefined;
|
|
3343
3340
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
3344
3341
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
3345
|
-
}, {
|
|
3346
3342
|
name: string;
|
|
3347
3343
|
columns: string[];
|
|
3348
3344
|
isUnique: boolean;
|
|
3345
|
+
}, {
|
|
3349
3346
|
using?: "btree" | "hash" | undefined;
|
|
3350
3347
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
3351
3348
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
3349
|
+
name: string;
|
|
3350
|
+
columns: string[];
|
|
3351
|
+
isUnique: boolean;
|
|
3352
3352
|
}>>;
|
|
3353
3353
|
foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
3354
3354
|
name: import("zod").ZodString;
|
|
@@ -3359,80 +3359,80 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").object
|
|
|
3359
3359
|
onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
|
|
3360
3360
|
onDelete: import("zod").ZodOptional<import("zod").ZodString>;
|
|
3361
3361
|
}, "strict", import("zod").ZodTypeAny, {
|
|
3362
|
+
onUpdate?: string | undefined;
|
|
3363
|
+
onDelete?: string | undefined;
|
|
3362
3364
|
name: string;
|
|
3363
3365
|
tableFrom: string;
|
|
3364
3366
|
columnsFrom: string[];
|
|
3365
3367
|
tableTo: string;
|
|
3366
3368
|
columnsTo: string[];
|
|
3369
|
+
}, {
|
|
3367
3370
|
onUpdate?: string | undefined;
|
|
3368
3371
|
onDelete?: string | undefined;
|
|
3369
|
-
}, {
|
|
3370
3372
|
name: string;
|
|
3371
3373
|
tableFrom: string;
|
|
3372
3374
|
columnsFrom: string[];
|
|
3373
3375
|
tableTo: string;
|
|
3374
3376
|
columnsTo: string[];
|
|
3375
|
-
onUpdate?: string | undefined;
|
|
3376
|
-
onDelete?: string | undefined;
|
|
3377
3377
|
}>>;
|
|
3378
3378
|
}, "strict", import("zod").ZodTypeAny, {
|
|
3379
|
+
schema?: string | undefined;
|
|
3379
3380
|
name: string;
|
|
3380
3381
|
columns: Record<string, {
|
|
3382
|
+
default?: any;
|
|
3383
|
+
onUpdate?: any;
|
|
3384
|
+
autoincrement?: boolean | undefined;
|
|
3381
3385
|
name: string;
|
|
3382
3386
|
type: string;
|
|
3383
3387
|
primaryKey: boolean;
|
|
3384
3388
|
notNull: boolean;
|
|
3385
|
-
default?: any;
|
|
3386
|
-
onUpdate?: any;
|
|
3387
|
-
autoincrement?: boolean | undefined;
|
|
3388
3389
|
}>;
|
|
3389
3390
|
indexes: Record<string, {
|
|
3390
|
-
name: string;
|
|
3391
|
-
columns: string[];
|
|
3392
|
-
isUnique: boolean;
|
|
3393
3391
|
using?: "btree" | "hash" | undefined;
|
|
3394
3392
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
3395
3393
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
3394
|
+
name: string;
|
|
3395
|
+
columns: string[];
|
|
3396
|
+
isUnique: boolean;
|
|
3396
3397
|
}>;
|
|
3397
3398
|
foreignKeys: Record<string, {
|
|
3399
|
+
onUpdate?: string | undefined;
|
|
3400
|
+
onDelete?: string | undefined;
|
|
3398
3401
|
name: string;
|
|
3399
3402
|
tableFrom: string;
|
|
3400
3403
|
columnsFrom: string[];
|
|
3401
3404
|
tableTo: string;
|
|
3402
3405
|
columnsTo: string[];
|
|
3403
|
-
onUpdate?: string | undefined;
|
|
3404
|
-
onDelete?: string | undefined;
|
|
3405
3406
|
}>;
|
|
3406
|
-
schema?: string | undefined;
|
|
3407
3407
|
}, {
|
|
3408
|
+
schema?: string | undefined;
|
|
3408
3409
|
name: string;
|
|
3409
3410
|
columns: Record<string, {
|
|
3411
|
+
default?: any;
|
|
3412
|
+
onUpdate?: any;
|
|
3413
|
+
autoincrement?: boolean | undefined;
|
|
3410
3414
|
name: string;
|
|
3411
3415
|
type: string;
|
|
3412
3416
|
primaryKey: boolean;
|
|
3413
3417
|
notNull: boolean;
|
|
3414
|
-
default?: any;
|
|
3415
|
-
onUpdate?: any;
|
|
3416
|
-
autoincrement?: boolean | undefined;
|
|
3417
3418
|
}>;
|
|
3418
3419
|
indexes: Record<string, {
|
|
3419
|
-
name: string;
|
|
3420
|
-
columns: string[];
|
|
3421
|
-
isUnique: boolean;
|
|
3422
3420
|
using?: "btree" | "hash" | undefined;
|
|
3423
3421
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
3424
3422
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
3423
|
+
name: string;
|
|
3424
|
+
columns: string[];
|
|
3425
|
+
isUnique: boolean;
|
|
3425
3426
|
}>;
|
|
3426
3427
|
foreignKeys: Record<string, {
|
|
3428
|
+
onUpdate?: string | undefined;
|
|
3429
|
+
onDelete?: string | undefined;
|
|
3427
3430
|
name: string;
|
|
3428
3431
|
tableFrom: string;
|
|
3429
3432
|
columnsFrom: string[];
|
|
3430
3433
|
tableTo: string;
|
|
3431
3434
|
columnsTo: string[];
|
|
3432
|
-
onUpdate?: string | undefined;
|
|
3433
|
-
onDelete?: string | undefined;
|
|
3434
3435
|
}>;
|
|
3435
|
-
schema?: string | undefined;
|
|
3436
3436
|
}>>;
|
|
3437
3437
|
schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
|
|
3438
3438
|
}, {
|
|
@@ -3440,34 +3440,34 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").object
|
|
|
3440
3440
|
prevId: import("zod").ZodString;
|
|
3441
3441
|
}>, "strip", import("zod").ZodTypeAny, {
|
|
3442
3442
|
tables: Record<string, {
|
|
3443
|
+
schema?: string | undefined;
|
|
3443
3444
|
name: string;
|
|
3444
3445
|
columns: Record<string, {
|
|
3446
|
+
default?: any;
|
|
3447
|
+
onUpdate?: any;
|
|
3448
|
+
autoincrement?: boolean | undefined;
|
|
3445
3449
|
name: string;
|
|
3446
3450
|
type: string;
|
|
3447
3451
|
primaryKey: boolean;
|
|
3448
3452
|
notNull: boolean;
|
|
3449
|
-
default?: any;
|
|
3450
|
-
onUpdate?: any;
|
|
3451
|
-
autoincrement?: boolean | undefined;
|
|
3452
3453
|
}>;
|
|
3453
3454
|
indexes: Record<string, {
|
|
3454
|
-
name: string;
|
|
3455
|
-
columns: string[];
|
|
3456
|
-
isUnique: boolean;
|
|
3457
3455
|
using?: "btree" | "hash" | undefined;
|
|
3458
3456
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
3459
3457
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
3458
|
+
name: string;
|
|
3459
|
+
columns: string[];
|
|
3460
|
+
isUnique: boolean;
|
|
3460
3461
|
}>;
|
|
3461
3462
|
foreignKeys: Record<string, {
|
|
3463
|
+
onUpdate?: string | undefined;
|
|
3464
|
+
onDelete?: string | undefined;
|
|
3462
3465
|
name: string;
|
|
3463
3466
|
tableFrom: string;
|
|
3464
3467
|
columnsFrom: string[];
|
|
3465
3468
|
tableTo: string;
|
|
3466
3469
|
columnsTo: string[];
|
|
3467
|
-
onUpdate?: string | undefined;
|
|
3468
|
-
onDelete?: string | undefined;
|
|
3469
3470
|
}>;
|
|
3470
|
-
schema?: string | undefined;
|
|
3471
3471
|
}>;
|
|
3472
3472
|
id: string;
|
|
3473
3473
|
prevId: string;
|
|
@@ -3476,34 +3476,34 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").object
|
|
|
3476
3476
|
schemas: Record<string, string>;
|
|
3477
3477
|
}, {
|
|
3478
3478
|
tables: Record<string, {
|
|
3479
|
+
schema?: string | undefined;
|
|
3479
3480
|
name: string;
|
|
3480
3481
|
columns: Record<string, {
|
|
3482
|
+
default?: any;
|
|
3483
|
+
onUpdate?: any;
|
|
3484
|
+
autoincrement?: boolean | undefined;
|
|
3481
3485
|
name: string;
|
|
3482
3486
|
type: string;
|
|
3483
3487
|
primaryKey: boolean;
|
|
3484
3488
|
notNull: boolean;
|
|
3485
|
-
default?: any;
|
|
3486
|
-
onUpdate?: any;
|
|
3487
|
-
autoincrement?: boolean | undefined;
|
|
3488
3489
|
}>;
|
|
3489
3490
|
indexes: Record<string, {
|
|
3490
|
-
name: string;
|
|
3491
|
-
columns: string[];
|
|
3492
|
-
isUnique: boolean;
|
|
3493
3491
|
using?: "btree" | "hash" | undefined;
|
|
3494
3492
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
3495
3493
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
3494
|
+
name: string;
|
|
3495
|
+
columns: string[];
|
|
3496
|
+
isUnique: boolean;
|
|
3496
3497
|
}>;
|
|
3497
3498
|
foreignKeys: Record<string, {
|
|
3499
|
+
onUpdate?: string | undefined;
|
|
3500
|
+
onDelete?: string | undefined;
|
|
3498
3501
|
name: string;
|
|
3499
3502
|
tableFrom: string;
|
|
3500
3503
|
columnsFrom: string[];
|
|
3501
3504
|
tableTo: string;
|
|
3502
3505
|
columnsTo: string[];
|
|
3503
|
-
onUpdate?: string | undefined;
|
|
3504
|
-
onDelete?: string | undefined;
|
|
3505
3506
|
}>;
|
|
3506
|
-
schema?: string | undefined;
|
|
3507
3507
|
}>;
|
|
3508
3508
|
id: string;
|
|
3509
3509
|
prevId: string;
|
|
@@ -3511,7 +3511,7 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").object
|
|
|
3511
3511
|
dialect: "mysql";
|
|
3512
3512
|
schemas: Record<string, string>;
|
|
3513
3513
|
}>;
|
|
3514
|
-
export declare const mysqlSchemaV5: import("zod").ZodObject<import("zod").
|
|
3514
|
+
export declare const mysqlSchemaV5: import("zod").ZodObject<import("zod").extendShape<{
|
|
3515
3515
|
version: import("zod").ZodLiteral<"5">;
|
|
3516
3516
|
dialect: import("zod").ZodLiteral<"mysql">;
|
|
3517
3517
|
tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
@@ -3525,21 +3525,21 @@ export declare const mysqlSchemaV5: import("zod").ZodObject<import("zod").object
|
|
|
3525
3525
|
default: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
3526
3526
|
onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
3527
3527
|
}, "strict", import("zod").ZodTypeAny, {
|
|
3528
|
+
default?: any;
|
|
3529
|
+
onUpdate?: any;
|
|
3530
|
+
autoincrement?: boolean | undefined;
|
|
3528
3531
|
name: string;
|
|
3529
3532
|
type: string;
|
|
3530
3533
|
primaryKey: boolean;
|
|
3531
3534
|
notNull: boolean;
|
|
3535
|
+
}, {
|
|
3532
3536
|
default?: any;
|
|
3533
3537
|
onUpdate?: any;
|
|
3534
3538
|
autoincrement?: boolean | undefined;
|
|
3535
|
-
}, {
|
|
3536
3539
|
name: string;
|
|
3537
3540
|
type: string;
|
|
3538
3541
|
primaryKey: boolean;
|
|
3539
3542
|
notNull: boolean;
|
|
3540
|
-
default?: any;
|
|
3541
|
-
onUpdate?: any;
|
|
3542
|
-
autoincrement?: boolean | undefined;
|
|
3543
3543
|
}>>;
|
|
3544
3544
|
indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
3545
3545
|
name: import("zod").ZodString;
|
|
@@ -3549,19 +3549,19 @@ export declare const mysqlSchemaV5: import("zod").ZodObject<import("zod").object
|
|
|
3549
3549
|
algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
|
|
3550
3550
|
lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
|
|
3551
3551
|
}, "strict", import("zod").ZodTypeAny, {
|
|
3552
|
-
name: string;
|
|
3553
|
-
columns: string[];
|
|
3554
|
-
isUnique: boolean;
|
|
3555
3552
|
using?: "btree" | "hash" | undefined;
|
|
3556
3553
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
3557
3554
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
3558
|
-
}, {
|
|
3559
3555
|
name: string;
|
|
3560
3556
|
columns: string[];
|
|
3561
3557
|
isUnique: boolean;
|
|
3558
|
+
}, {
|
|
3562
3559
|
using?: "btree" | "hash" | undefined;
|
|
3563
3560
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
3564
3561
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
3562
|
+
name: string;
|
|
3563
|
+
columns: string[];
|
|
3564
|
+
isUnique: boolean;
|
|
3565
3565
|
}>>;
|
|
3566
3566
|
foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
3567
3567
|
name: import("zod").ZodString;
|
|
@@ -3572,21 +3572,21 @@ export declare const mysqlSchemaV5: import("zod").ZodObject<import("zod").object
|
|
|
3572
3572
|
onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
|
|
3573
3573
|
onDelete: import("zod").ZodOptional<import("zod").ZodString>;
|
|
3574
3574
|
}, "strict", import("zod").ZodTypeAny, {
|
|
3575
|
+
onUpdate?: string | undefined;
|
|
3576
|
+
onDelete?: string | undefined;
|
|
3575
3577
|
name: string;
|
|
3576
3578
|
tableFrom: string;
|
|
3577
3579
|
columnsFrom: string[];
|
|
3578
3580
|
tableTo: string;
|
|
3579
3581
|
columnsTo: string[];
|
|
3582
|
+
}, {
|
|
3580
3583
|
onUpdate?: string | undefined;
|
|
3581
3584
|
onDelete?: string | undefined;
|
|
3582
|
-
}, {
|
|
3583
3585
|
name: string;
|
|
3584
3586
|
tableFrom: string;
|
|
3585
3587
|
columnsFrom: string[];
|
|
3586
3588
|
tableTo: string;
|
|
3587
3589
|
columnsTo: string[];
|
|
3588
|
-
onUpdate?: string | undefined;
|
|
3589
|
-
onDelete?: string | undefined;
|
|
3590
3590
|
}>>;
|
|
3591
3591
|
compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
3592
3592
|
name: import("zod").ZodString;
|
|
@@ -3611,30 +3611,30 @@ export declare const mysqlSchemaV5: import("zod").ZodObject<import("zod").object
|
|
|
3611
3611
|
}, "strict", import("zod").ZodTypeAny, {
|
|
3612
3612
|
name: string;
|
|
3613
3613
|
columns: Record<string, {
|
|
3614
|
+
default?: any;
|
|
3615
|
+
onUpdate?: any;
|
|
3616
|
+
autoincrement?: boolean | undefined;
|
|
3614
3617
|
name: string;
|
|
3615
3618
|
type: string;
|
|
3616
3619
|
primaryKey: boolean;
|
|
3617
3620
|
notNull: boolean;
|
|
3618
|
-
default?: any;
|
|
3619
|
-
onUpdate?: any;
|
|
3620
|
-
autoincrement?: boolean | undefined;
|
|
3621
3621
|
}>;
|
|
3622
3622
|
indexes: Record<string, {
|
|
3623
|
-
name: string;
|
|
3624
|
-
columns: string[];
|
|
3625
|
-
isUnique: boolean;
|
|
3626
3623
|
using?: "btree" | "hash" | undefined;
|
|
3627
3624
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
3628
3625
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
3626
|
+
name: string;
|
|
3627
|
+
columns: string[];
|
|
3628
|
+
isUnique: boolean;
|
|
3629
3629
|
}>;
|
|
3630
3630
|
foreignKeys: Record<string, {
|
|
3631
|
+
onUpdate?: string | undefined;
|
|
3632
|
+
onDelete?: string | undefined;
|
|
3631
3633
|
name: string;
|
|
3632
3634
|
tableFrom: string;
|
|
3633
3635
|
columnsFrom: string[];
|
|
3634
3636
|
tableTo: string;
|
|
3635
3637
|
columnsTo: string[];
|
|
3636
|
-
onUpdate?: string | undefined;
|
|
3637
|
-
onDelete?: string | undefined;
|
|
3638
3638
|
}>;
|
|
3639
3639
|
compositePrimaryKeys: Record<string, {
|
|
3640
3640
|
name: string;
|
|
@@ -3645,41 +3645,41 @@ export declare const mysqlSchemaV5: import("zod").ZodObject<import("zod").object
|
|
|
3645
3645
|
columns: string[];
|
|
3646
3646
|
}>;
|
|
3647
3647
|
}, {
|
|
3648
|
+
uniqueConstraints?: Record<string, {
|
|
3649
|
+
name: string;
|
|
3650
|
+
columns: string[];
|
|
3651
|
+
}> | undefined;
|
|
3648
3652
|
name: string;
|
|
3649
3653
|
columns: Record<string, {
|
|
3654
|
+
default?: any;
|
|
3655
|
+
onUpdate?: any;
|
|
3656
|
+
autoincrement?: boolean | undefined;
|
|
3650
3657
|
name: string;
|
|
3651
3658
|
type: string;
|
|
3652
3659
|
primaryKey: boolean;
|
|
3653
3660
|
notNull: boolean;
|
|
3654
|
-
default?: any;
|
|
3655
|
-
onUpdate?: any;
|
|
3656
|
-
autoincrement?: boolean | undefined;
|
|
3657
3661
|
}>;
|
|
3658
3662
|
indexes: Record<string, {
|
|
3659
|
-
name: string;
|
|
3660
|
-
columns: string[];
|
|
3661
|
-
isUnique: boolean;
|
|
3662
3663
|
using?: "btree" | "hash" | undefined;
|
|
3663
3664
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
3664
3665
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
3666
|
+
name: string;
|
|
3667
|
+
columns: string[];
|
|
3668
|
+
isUnique: boolean;
|
|
3665
3669
|
}>;
|
|
3666
3670
|
foreignKeys: Record<string, {
|
|
3671
|
+
onUpdate?: string | undefined;
|
|
3672
|
+
onDelete?: string | undefined;
|
|
3667
3673
|
name: string;
|
|
3668
3674
|
tableFrom: string;
|
|
3669
3675
|
columnsFrom: string[];
|
|
3670
3676
|
tableTo: string;
|
|
3671
3677
|
columnsTo: string[];
|
|
3672
|
-
onUpdate?: string | undefined;
|
|
3673
|
-
onDelete?: string | undefined;
|
|
3674
3678
|
}>;
|
|
3675
3679
|
compositePrimaryKeys: Record<string, {
|
|
3676
3680
|
name: string;
|
|
3677
3681
|
columns: string[];
|
|
3678
3682
|
}>;
|
|
3679
|
-
uniqueConstraints?: Record<string, {
|
|
3680
|
-
name: string;
|
|
3681
|
-
columns: string[];
|
|
3682
|
-
}> | undefined;
|
|
3683
3683
|
}>>;
|
|
3684
3684
|
schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
|
|
3685
3685
|
_meta: import("zod").ZodObject<{
|
|
@@ -3730,33 +3730,40 @@ export declare const mysqlSchemaV5: import("zod").ZodObject<import("zod").object
|
|
|
3730
3730
|
id: import("zod").ZodString;
|
|
3731
3731
|
prevId: import("zod").ZodString;
|
|
3732
3732
|
}>, "strip", import("zod").ZodTypeAny, {
|
|
3733
|
+
internal?: {
|
|
3734
|
+
tables: Record<string, {
|
|
3735
|
+
columns: Record<string, {
|
|
3736
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
3737
|
+
} | undefined>;
|
|
3738
|
+
} | undefined>;
|
|
3739
|
+
} | undefined;
|
|
3733
3740
|
tables: Record<string, {
|
|
3734
3741
|
name: string;
|
|
3735
3742
|
columns: Record<string, {
|
|
3743
|
+
default?: any;
|
|
3744
|
+
onUpdate?: any;
|
|
3745
|
+
autoincrement?: boolean | undefined;
|
|
3736
3746
|
name: string;
|
|
3737
3747
|
type: string;
|
|
3738
3748
|
primaryKey: boolean;
|
|
3739
3749
|
notNull: boolean;
|
|
3740
|
-
default?: any;
|
|
3741
|
-
onUpdate?: any;
|
|
3742
|
-
autoincrement?: boolean | undefined;
|
|
3743
3750
|
}>;
|
|
3744
3751
|
indexes: Record<string, {
|
|
3745
|
-
name: string;
|
|
3746
|
-
columns: string[];
|
|
3747
|
-
isUnique: boolean;
|
|
3748
3752
|
using?: "btree" | "hash" | undefined;
|
|
3749
3753
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
3750
3754
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
3755
|
+
name: string;
|
|
3756
|
+
columns: string[];
|
|
3757
|
+
isUnique: boolean;
|
|
3751
3758
|
}>;
|
|
3752
3759
|
foreignKeys: Record<string, {
|
|
3760
|
+
onUpdate?: string | undefined;
|
|
3761
|
+
onDelete?: string | undefined;
|
|
3753
3762
|
name: string;
|
|
3754
3763
|
tableFrom: string;
|
|
3755
3764
|
columnsFrom: string[];
|
|
3756
3765
|
tableTo: string;
|
|
3757
3766
|
columnsTo: string[];
|
|
3758
|
-
onUpdate?: string | undefined;
|
|
3759
|
-
onDelete?: string | undefined;
|
|
3760
3767
|
}>;
|
|
3761
3768
|
compositePrimaryKeys: Record<string, {
|
|
3762
3769
|
name: string;
|
|
@@ -3777,6 +3784,7 @@ export declare const mysqlSchemaV5: import("zod").ZodObject<import("zod").object
|
|
|
3777
3784
|
tables: Record<string, string>;
|
|
3778
3785
|
schemas: Record<string, string>;
|
|
3779
3786
|
};
|
|
3787
|
+
}, {
|
|
3780
3788
|
internal?: {
|
|
3781
3789
|
tables: Record<string, {
|
|
3782
3790
|
columns: Record<string, {
|
|
@@ -3784,43 +3792,42 @@ export declare const mysqlSchemaV5: import("zod").ZodObject<import("zod").object
|
|
|
3784
3792
|
} | undefined>;
|
|
3785
3793
|
} | undefined>;
|
|
3786
3794
|
} | undefined;
|
|
3787
|
-
}, {
|
|
3788
3795
|
tables: Record<string, {
|
|
3796
|
+
uniqueConstraints?: Record<string, {
|
|
3797
|
+
name: string;
|
|
3798
|
+
columns: string[];
|
|
3799
|
+
}> | undefined;
|
|
3789
3800
|
name: string;
|
|
3790
3801
|
columns: Record<string, {
|
|
3802
|
+
default?: any;
|
|
3803
|
+
onUpdate?: any;
|
|
3804
|
+
autoincrement?: boolean | undefined;
|
|
3791
3805
|
name: string;
|
|
3792
3806
|
type: string;
|
|
3793
3807
|
primaryKey: boolean;
|
|
3794
3808
|
notNull: boolean;
|
|
3795
|
-
default?: any;
|
|
3796
|
-
onUpdate?: any;
|
|
3797
|
-
autoincrement?: boolean | undefined;
|
|
3798
3809
|
}>;
|
|
3799
3810
|
indexes: Record<string, {
|
|
3800
|
-
name: string;
|
|
3801
|
-
columns: string[];
|
|
3802
|
-
isUnique: boolean;
|
|
3803
3811
|
using?: "btree" | "hash" | undefined;
|
|
3804
3812
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
3805
3813
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
3814
|
+
name: string;
|
|
3815
|
+
columns: string[];
|
|
3816
|
+
isUnique: boolean;
|
|
3806
3817
|
}>;
|
|
3807
3818
|
foreignKeys: Record<string, {
|
|
3819
|
+
onUpdate?: string | undefined;
|
|
3820
|
+
onDelete?: string | undefined;
|
|
3808
3821
|
name: string;
|
|
3809
3822
|
tableFrom: string;
|
|
3810
3823
|
columnsFrom: string[];
|
|
3811
3824
|
tableTo: string;
|
|
3812
3825
|
columnsTo: string[];
|
|
3813
|
-
onUpdate?: string | undefined;
|
|
3814
|
-
onDelete?: string | undefined;
|
|
3815
3826
|
}>;
|
|
3816
3827
|
compositePrimaryKeys: Record<string, {
|
|
3817
3828
|
name: string;
|
|
3818
3829
|
columns: string[];
|
|
3819
3830
|
}>;
|
|
3820
|
-
uniqueConstraints?: Record<string, {
|
|
3821
|
-
name: string;
|
|
3822
|
-
columns: string[];
|
|
3823
|
-
}> | undefined;
|
|
3824
3831
|
}>;
|
|
3825
3832
|
id: string;
|
|
3826
3833
|
prevId: string;
|
|
@@ -3832,13 +3839,6 @@ export declare const mysqlSchemaV5: import("zod").ZodObject<import("zod").object
|
|
|
3832
3839
|
tables: Record<string, string>;
|
|
3833
3840
|
schemas: Record<string, string>;
|
|
3834
3841
|
};
|
|
3835
|
-
internal?: {
|
|
3836
|
-
tables: Record<string, {
|
|
3837
|
-
columns: Record<string, {
|
|
3838
|
-
isDefaultAnExpression?: boolean | undefined;
|
|
3839
|
-
} | undefined>;
|
|
3840
|
-
} | undefined>;
|
|
3841
|
-
} | undefined;
|
|
3842
3842
|
}>;
|
|
3843
3843
|
export declare const mysqlSchemaSquashed: import("zod").ZodObject<{
|
|
3844
3844
|
version: import("zod").ZodLiteral<"5">;
|
|
@@ -3854,21 +3854,21 @@ export declare const mysqlSchemaSquashed: import("zod").ZodObject<{
|
|
|
3854
3854
|
default: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
3855
3855
|
onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
3856
3856
|
}, "strict", import("zod").ZodTypeAny, {
|
|
3857
|
+
default?: any;
|
|
3858
|
+
onUpdate?: any;
|
|
3859
|
+
autoincrement?: boolean | undefined;
|
|
3857
3860
|
name: string;
|
|
3858
3861
|
type: string;
|
|
3859
3862
|
primaryKey: boolean;
|
|
3860
3863
|
notNull: boolean;
|
|
3864
|
+
}, {
|
|
3861
3865
|
default?: any;
|
|
3862
3866
|
onUpdate?: any;
|
|
3863
3867
|
autoincrement?: boolean | undefined;
|
|
3864
|
-
}, {
|
|
3865
3868
|
name: string;
|
|
3866
3869
|
type: string;
|
|
3867
3870
|
primaryKey: boolean;
|
|
3868
3871
|
notNull: boolean;
|
|
3869
|
-
default?: any;
|
|
3870
|
-
onUpdate?: any;
|
|
3871
|
-
autoincrement?: boolean | undefined;
|
|
3872
3872
|
}>>;
|
|
3873
3873
|
indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
|
|
3874
3874
|
foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
|
|
@@ -3877,45 +3877,45 @@ export declare const mysqlSchemaSquashed: import("zod").ZodObject<{
|
|
|
3877
3877
|
}, "strict", import("zod").ZodTypeAny, {
|
|
3878
3878
|
name: string;
|
|
3879
3879
|
columns: Record<string, {
|
|
3880
|
+
default?: any;
|
|
3881
|
+
onUpdate?: any;
|
|
3882
|
+
autoincrement?: boolean | undefined;
|
|
3880
3883
|
name: string;
|
|
3881
3884
|
type: string;
|
|
3882
3885
|
primaryKey: boolean;
|
|
3883
3886
|
notNull: boolean;
|
|
3884
|
-
default?: any;
|
|
3885
|
-
onUpdate?: any;
|
|
3886
|
-
autoincrement?: boolean | undefined;
|
|
3887
3887
|
}>;
|
|
3888
3888
|
indexes: Record<string, string>;
|
|
3889
3889
|
foreignKeys: Record<string, string>;
|
|
3890
3890
|
compositePrimaryKeys: Record<string, string>;
|
|
3891
3891
|
uniqueConstraints: Record<string, string>;
|
|
3892
3892
|
}, {
|
|
3893
|
+
uniqueConstraints?: Record<string, string> | undefined;
|
|
3893
3894
|
name: string;
|
|
3894
3895
|
columns: Record<string, {
|
|
3896
|
+
default?: any;
|
|
3897
|
+
onUpdate?: any;
|
|
3898
|
+
autoincrement?: boolean | undefined;
|
|
3895
3899
|
name: string;
|
|
3896
3900
|
type: string;
|
|
3897
3901
|
primaryKey: boolean;
|
|
3898
3902
|
notNull: boolean;
|
|
3899
|
-
default?: any;
|
|
3900
|
-
onUpdate?: any;
|
|
3901
|
-
autoincrement?: boolean | undefined;
|
|
3902
3903
|
}>;
|
|
3903
3904
|
indexes: Record<string, string>;
|
|
3904
3905
|
foreignKeys: Record<string, string>;
|
|
3905
3906
|
compositePrimaryKeys: Record<string, string>;
|
|
3906
|
-
uniqueConstraints?: Record<string, string> | undefined;
|
|
3907
3907
|
}>>;
|
|
3908
3908
|
}, "strict", import("zod").ZodTypeAny, {
|
|
3909
3909
|
tables: Record<string, {
|
|
3910
3910
|
name: string;
|
|
3911
3911
|
columns: Record<string, {
|
|
3912
|
+
default?: any;
|
|
3913
|
+
onUpdate?: any;
|
|
3914
|
+
autoincrement?: boolean | undefined;
|
|
3912
3915
|
name: string;
|
|
3913
3916
|
type: string;
|
|
3914
3917
|
primaryKey: boolean;
|
|
3915
3918
|
notNull: boolean;
|
|
3916
|
-
default?: any;
|
|
3917
|
-
onUpdate?: any;
|
|
3918
|
-
autoincrement?: boolean | undefined;
|
|
3919
3919
|
}>;
|
|
3920
3920
|
indexes: Record<string, string>;
|
|
3921
3921
|
foreignKeys: Record<string, string>;
|
|
@@ -3926,25 +3926,25 @@ export declare const mysqlSchemaSquashed: import("zod").ZodObject<{
|
|
|
3926
3926
|
dialect: "mysql";
|
|
3927
3927
|
}, {
|
|
3928
3928
|
tables: Record<string, {
|
|
3929
|
+
uniqueConstraints?: Record<string, string> | undefined;
|
|
3929
3930
|
name: string;
|
|
3930
3931
|
columns: Record<string, {
|
|
3932
|
+
default?: any;
|
|
3933
|
+
onUpdate?: any;
|
|
3934
|
+
autoincrement?: boolean | undefined;
|
|
3931
3935
|
name: string;
|
|
3932
3936
|
type: string;
|
|
3933
3937
|
primaryKey: boolean;
|
|
3934
3938
|
notNull: boolean;
|
|
3935
|
-
default?: any;
|
|
3936
|
-
onUpdate?: any;
|
|
3937
|
-
autoincrement?: boolean | undefined;
|
|
3938
3939
|
}>;
|
|
3939
3940
|
indexes: Record<string, string>;
|
|
3940
3941
|
foreignKeys: Record<string, string>;
|
|
3941
3942
|
compositePrimaryKeys: Record<string, string>;
|
|
3942
|
-
uniqueConstraints?: Record<string, string> | undefined;
|
|
3943
3943
|
}>;
|
|
3944
3944
|
version: "5";
|
|
3945
3945
|
dialect: "mysql";
|
|
3946
3946
|
}>;
|
|
3947
|
-
export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").
|
|
3947
|
+
export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").extendShape<{
|
|
3948
3948
|
version: import("zod").ZodLiteral<"5">;
|
|
3949
3949
|
dialect: import("zod").ZodLiteral<"mysql">;
|
|
3950
3950
|
tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
@@ -3958,21 +3958,21 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
|
|
|
3958
3958
|
default: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
3959
3959
|
onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
3960
3960
|
}, "strict", import("zod").ZodTypeAny, {
|
|
3961
|
+
default?: any;
|
|
3962
|
+
onUpdate?: any;
|
|
3963
|
+
autoincrement?: boolean | undefined;
|
|
3961
3964
|
name: string;
|
|
3962
3965
|
type: string;
|
|
3963
3966
|
primaryKey: boolean;
|
|
3964
3967
|
notNull: boolean;
|
|
3968
|
+
}, {
|
|
3965
3969
|
default?: any;
|
|
3966
3970
|
onUpdate?: any;
|
|
3967
3971
|
autoincrement?: boolean | undefined;
|
|
3968
|
-
}, {
|
|
3969
3972
|
name: string;
|
|
3970
3973
|
type: string;
|
|
3971
3974
|
primaryKey: boolean;
|
|
3972
3975
|
notNull: boolean;
|
|
3973
|
-
default?: any;
|
|
3974
|
-
onUpdate?: any;
|
|
3975
|
-
autoincrement?: boolean | undefined;
|
|
3976
3976
|
}>>;
|
|
3977
3977
|
indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
3978
3978
|
name: import("zod").ZodString;
|
|
@@ -3982,19 +3982,19 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
|
|
|
3982
3982
|
algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
|
|
3983
3983
|
lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
|
|
3984
3984
|
}, "strict", import("zod").ZodTypeAny, {
|
|
3985
|
-
name: string;
|
|
3986
|
-
columns: string[];
|
|
3987
|
-
isUnique: boolean;
|
|
3988
3985
|
using?: "btree" | "hash" | undefined;
|
|
3989
3986
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
3990
3987
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
3991
|
-
}, {
|
|
3992
3988
|
name: string;
|
|
3993
3989
|
columns: string[];
|
|
3994
3990
|
isUnique: boolean;
|
|
3991
|
+
}, {
|
|
3995
3992
|
using?: "btree" | "hash" | undefined;
|
|
3996
3993
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
3997
3994
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
3995
|
+
name: string;
|
|
3996
|
+
columns: string[];
|
|
3997
|
+
isUnique: boolean;
|
|
3998
3998
|
}>>;
|
|
3999
3999
|
foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
4000
4000
|
name: import("zod").ZodString;
|
|
@@ -4005,21 +4005,21 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
|
|
|
4005
4005
|
onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
|
|
4006
4006
|
onDelete: import("zod").ZodOptional<import("zod").ZodString>;
|
|
4007
4007
|
}, "strict", import("zod").ZodTypeAny, {
|
|
4008
|
+
onUpdate?: string | undefined;
|
|
4009
|
+
onDelete?: string | undefined;
|
|
4008
4010
|
name: string;
|
|
4009
4011
|
tableFrom: string;
|
|
4010
4012
|
columnsFrom: string[];
|
|
4011
4013
|
tableTo: string;
|
|
4012
4014
|
columnsTo: string[];
|
|
4015
|
+
}, {
|
|
4013
4016
|
onUpdate?: string | undefined;
|
|
4014
4017
|
onDelete?: string | undefined;
|
|
4015
|
-
}, {
|
|
4016
4018
|
name: string;
|
|
4017
4019
|
tableFrom: string;
|
|
4018
4020
|
columnsFrom: string[];
|
|
4019
4021
|
tableTo: string;
|
|
4020
4022
|
columnsTo: string[];
|
|
4021
|
-
onUpdate?: string | undefined;
|
|
4022
|
-
onDelete?: string | undefined;
|
|
4023
4023
|
}>>;
|
|
4024
4024
|
compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
4025
4025
|
name: import("zod").ZodString;
|
|
@@ -4044,30 +4044,30 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
|
|
|
4044
4044
|
}, "strict", import("zod").ZodTypeAny, {
|
|
4045
4045
|
name: string;
|
|
4046
4046
|
columns: Record<string, {
|
|
4047
|
+
default?: any;
|
|
4048
|
+
onUpdate?: any;
|
|
4049
|
+
autoincrement?: boolean | undefined;
|
|
4047
4050
|
name: string;
|
|
4048
4051
|
type: string;
|
|
4049
4052
|
primaryKey: boolean;
|
|
4050
4053
|
notNull: boolean;
|
|
4051
|
-
default?: any;
|
|
4052
|
-
onUpdate?: any;
|
|
4053
|
-
autoincrement?: boolean | undefined;
|
|
4054
4054
|
}>;
|
|
4055
4055
|
indexes: Record<string, {
|
|
4056
|
-
name: string;
|
|
4057
|
-
columns: string[];
|
|
4058
|
-
isUnique: boolean;
|
|
4059
4056
|
using?: "btree" | "hash" | undefined;
|
|
4060
4057
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
4061
4058
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
4059
|
+
name: string;
|
|
4060
|
+
columns: string[];
|
|
4061
|
+
isUnique: boolean;
|
|
4062
4062
|
}>;
|
|
4063
4063
|
foreignKeys: Record<string, {
|
|
4064
|
+
onUpdate?: string | undefined;
|
|
4065
|
+
onDelete?: string | undefined;
|
|
4064
4066
|
name: string;
|
|
4065
4067
|
tableFrom: string;
|
|
4066
4068
|
columnsFrom: string[];
|
|
4067
4069
|
tableTo: string;
|
|
4068
4070
|
columnsTo: string[];
|
|
4069
|
-
onUpdate?: string | undefined;
|
|
4070
|
-
onDelete?: string | undefined;
|
|
4071
4071
|
}>;
|
|
4072
4072
|
compositePrimaryKeys: Record<string, {
|
|
4073
4073
|
name: string;
|
|
@@ -4078,41 +4078,41 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
|
|
|
4078
4078
|
columns: string[];
|
|
4079
4079
|
}>;
|
|
4080
4080
|
}, {
|
|
4081
|
+
uniqueConstraints?: Record<string, {
|
|
4082
|
+
name: string;
|
|
4083
|
+
columns: string[];
|
|
4084
|
+
}> | undefined;
|
|
4081
4085
|
name: string;
|
|
4082
4086
|
columns: Record<string, {
|
|
4087
|
+
default?: any;
|
|
4088
|
+
onUpdate?: any;
|
|
4089
|
+
autoincrement?: boolean | undefined;
|
|
4083
4090
|
name: string;
|
|
4084
4091
|
type: string;
|
|
4085
4092
|
primaryKey: boolean;
|
|
4086
4093
|
notNull: boolean;
|
|
4087
|
-
default?: any;
|
|
4088
|
-
onUpdate?: any;
|
|
4089
|
-
autoincrement?: boolean | undefined;
|
|
4090
4094
|
}>;
|
|
4091
4095
|
indexes: Record<string, {
|
|
4092
|
-
name: string;
|
|
4093
|
-
columns: string[];
|
|
4094
|
-
isUnique: boolean;
|
|
4095
4096
|
using?: "btree" | "hash" | undefined;
|
|
4096
4097
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
4097
4098
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
4099
|
+
name: string;
|
|
4100
|
+
columns: string[];
|
|
4101
|
+
isUnique: boolean;
|
|
4098
4102
|
}>;
|
|
4099
4103
|
foreignKeys: Record<string, {
|
|
4104
|
+
onUpdate?: string | undefined;
|
|
4105
|
+
onDelete?: string | undefined;
|
|
4100
4106
|
name: string;
|
|
4101
4107
|
tableFrom: string;
|
|
4102
4108
|
columnsFrom: string[];
|
|
4103
4109
|
tableTo: string;
|
|
4104
4110
|
columnsTo: string[];
|
|
4105
|
-
onUpdate?: string | undefined;
|
|
4106
|
-
onDelete?: string | undefined;
|
|
4107
4111
|
}>;
|
|
4108
4112
|
compositePrimaryKeys: Record<string, {
|
|
4109
4113
|
name: string;
|
|
4110
4114
|
columns: string[];
|
|
4111
4115
|
}>;
|
|
4112
|
-
uniqueConstraints?: Record<string, {
|
|
4113
|
-
name: string;
|
|
4114
|
-
columns: string[];
|
|
4115
|
-
}> | undefined;
|
|
4116
4116
|
}>>;
|
|
4117
4117
|
schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
|
|
4118
4118
|
_meta: import("zod").ZodObject<{
|
|
@@ -4163,33 +4163,40 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
|
|
|
4163
4163
|
id: import("zod").ZodString;
|
|
4164
4164
|
prevId: import("zod").ZodString;
|
|
4165
4165
|
}>, "strip", import("zod").ZodTypeAny, {
|
|
4166
|
+
internal?: {
|
|
4167
|
+
tables: Record<string, {
|
|
4168
|
+
columns: Record<string, {
|
|
4169
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
4170
|
+
} | undefined>;
|
|
4171
|
+
} | undefined>;
|
|
4172
|
+
} | undefined;
|
|
4166
4173
|
tables: Record<string, {
|
|
4167
4174
|
name: string;
|
|
4168
4175
|
columns: Record<string, {
|
|
4176
|
+
default?: any;
|
|
4177
|
+
onUpdate?: any;
|
|
4178
|
+
autoincrement?: boolean | undefined;
|
|
4169
4179
|
name: string;
|
|
4170
4180
|
type: string;
|
|
4171
4181
|
primaryKey: boolean;
|
|
4172
4182
|
notNull: boolean;
|
|
4173
|
-
default?: any;
|
|
4174
|
-
onUpdate?: any;
|
|
4175
|
-
autoincrement?: boolean | undefined;
|
|
4176
4183
|
}>;
|
|
4177
4184
|
indexes: Record<string, {
|
|
4178
|
-
name: string;
|
|
4179
|
-
columns: string[];
|
|
4180
|
-
isUnique: boolean;
|
|
4181
4185
|
using?: "btree" | "hash" | undefined;
|
|
4182
4186
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
4183
4187
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
4188
|
+
name: string;
|
|
4189
|
+
columns: string[];
|
|
4190
|
+
isUnique: boolean;
|
|
4184
4191
|
}>;
|
|
4185
4192
|
foreignKeys: Record<string, {
|
|
4193
|
+
onUpdate?: string | undefined;
|
|
4194
|
+
onDelete?: string | undefined;
|
|
4186
4195
|
name: string;
|
|
4187
4196
|
tableFrom: string;
|
|
4188
4197
|
columnsFrom: string[];
|
|
4189
4198
|
tableTo: string;
|
|
4190
4199
|
columnsTo: string[];
|
|
4191
|
-
onUpdate?: string | undefined;
|
|
4192
|
-
onDelete?: string | undefined;
|
|
4193
4200
|
}>;
|
|
4194
4201
|
compositePrimaryKeys: Record<string, {
|
|
4195
4202
|
name: string;
|
|
@@ -4210,6 +4217,7 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
|
|
|
4210
4217
|
tables: Record<string, string>;
|
|
4211
4218
|
schemas: Record<string, string>;
|
|
4212
4219
|
};
|
|
4220
|
+
}, {
|
|
4213
4221
|
internal?: {
|
|
4214
4222
|
tables: Record<string, {
|
|
4215
4223
|
columns: Record<string, {
|
|
@@ -4217,43 +4225,42 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
|
|
|
4217
4225
|
} | undefined>;
|
|
4218
4226
|
} | undefined>;
|
|
4219
4227
|
} | undefined;
|
|
4220
|
-
}, {
|
|
4221
4228
|
tables: Record<string, {
|
|
4229
|
+
uniqueConstraints?: Record<string, {
|
|
4230
|
+
name: string;
|
|
4231
|
+
columns: string[];
|
|
4232
|
+
}> | undefined;
|
|
4222
4233
|
name: string;
|
|
4223
4234
|
columns: Record<string, {
|
|
4235
|
+
default?: any;
|
|
4236
|
+
onUpdate?: any;
|
|
4237
|
+
autoincrement?: boolean | undefined;
|
|
4224
4238
|
name: string;
|
|
4225
4239
|
type: string;
|
|
4226
4240
|
primaryKey: boolean;
|
|
4227
4241
|
notNull: boolean;
|
|
4228
|
-
default?: any;
|
|
4229
|
-
onUpdate?: any;
|
|
4230
|
-
autoincrement?: boolean | undefined;
|
|
4231
4242
|
}>;
|
|
4232
4243
|
indexes: Record<string, {
|
|
4233
|
-
name: string;
|
|
4234
|
-
columns: string[];
|
|
4235
|
-
isUnique: boolean;
|
|
4236
4244
|
using?: "btree" | "hash" | undefined;
|
|
4237
4245
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
4238
4246
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
4247
|
+
name: string;
|
|
4248
|
+
columns: string[];
|
|
4249
|
+
isUnique: boolean;
|
|
4239
4250
|
}>;
|
|
4240
4251
|
foreignKeys: Record<string, {
|
|
4252
|
+
onUpdate?: string | undefined;
|
|
4253
|
+
onDelete?: string | undefined;
|
|
4241
4254
|
name: string;
|
|
4242
4255
|
tableFrom: string;
|
|
4243
4256
|
columnsFrom: string[];
|
|
4244
4257
|
tableTo: string;
|
|
4245
4258
|
columnsTo: string[];
|
|
4246
|
-
onUpdate?: string | undefined;
|
|
4247
|
-
onDelete?: string | undefined;
|
|
4248
4259
|
}>;
|
|
4249
4260
|
compositePrimaryKeys: Record<string, {
|
|
4250
4261
|
name: string;
|
|
4251
4262
|
columns: string[];
|
|
4252
4263
|
}>;
|
|
4253
|
-
uniqueConstraints?: Record<string, {
|
|
4254
|
-
name: string;
|
|
4255
|
-
columns: string[];
|
|
4256
|
-
}> | undefined;
|
|
4257
4264
|
}>;
|
|
4258
4265
|
id: string;
|
|
4259
4266
|
prevId: string;
|
|
@@ -4265,14 +4272,7 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
|
|
|
4265
4272
|
tables: Record<string, string>;
|
|
4266
4273
|
schemas: Record<string, string>;
|
|
4267
4274
|
};
|
|
4268
|
-
|
|
4269
|
-
tables: Record<string, {
|
|
4270
|
-
columns: Record<string, {
|
|
4271
|
-
isDefaultAnExpression?: boolean | undefined;
|
|
4272
|
-
} | undefined>;
|
|
4273
|
-
} | undefined>;
|
|
4274
|
-
} | undefined;
|
|
4275
|
-
}>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
|
|
4275
|
+
}>, import("zod").ZodObject<import("zod").extendShape<{
|
|
4276
4276
|
version: import("zod").ZodLiteral<"5">;
|
|
4277
4277
|
dialect: import("zod").ZodLiteral<"mysql">;
|
|
4278
4278
|
tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
@@ -4286,21 +4286,21 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
|
|
|
4286
4286
|
default: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
4287
4287
|
onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
|
|
4288
4288
|
}, "strict", import("zod").ZodTypeAny, {
|
|
4289
|
+
default?: any;
|
|
4290
|
+
onUpdate?: any;
|
|
4291
|
+
autoincrement?: boolean | undefined;
|
|
4289
4292
|
name: string;
|
|
4290
4293
|
type: string;
|
|
4291
4294
|
primaryKey: boolean;
|
|
4292
4295
|
notNull: boolean;
|
|
4296
|
+
}, {
|
|
4293
4297
|
default?: any;
|
|
4294
4298
|
onUpdate?: any;
|
|
4295
4299
|
autoincrement?: boolean | undefined;
|
|
4296
|
-
}, {
|
|
4297
4300
|
name: string;
|
|
4298
4301
|
type: string;
|
|
4299
4302
|
primaryKey: boolean;
|
|
4300
4303
|
notNull: boolean;
|
|
4301
|
-
default?: any;
|
|
4302
|
-
onUpdate?: any;
|
|
4303
|
-
autoincrement?: boolean | undefined;
|
|
4304
4304
|
}>>;
|
|
4305
4305
|
indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
4306
4306
|
name: import("zod").ZodString;
|
|
@@ -4310,19 +4310,19 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
|
|
|
4310
4310
|
algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
|
|
4311
4311
|
lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
|
|
4312
4312
|
}, "strict", import("zod").ZodTypeAny, {
|
|
4313
|
-
name: string;
|
|
4314
|
-
columns: string[];
|
|
4315
|
-
isUnique: boolean;
|
|
4316
4313
|
using?: "btree" | "hash" | undefined;
|
|
4317
4314
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
4318
4315
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
4319
|
-
}, {
|
|
4320
4316
|
name: string;
|
|
4321
4317
|
columns: string[];
|
|
4322
4318
|
isUnique: boolean;
|
|
4319
|
+
}, {
|
|
4323
4320
|
using?: "btree" | "hash" | undefined;
|
|
4324
4321
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
4325
4322
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
4323
|
+
name: string;
|
|
4324
|
+
columns: string[];
|
|
4325
|
+
isUnique: boolean;
|
|
4326
4326
|
}>>;
|
|
4327
4327
|
foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
4328
4328
|
name: import("zod").ZodString;
|
|
@@ -4333,21 +4333,21 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
|
|
|
4333
4333
|
onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
|
|
4334
4334
|
onDelete: import("zod").ZodOptional<import("zod").ZodString>;
|
|
4335
4335
|
}, "strict", import("zod").ZodTypeAny, {
|
|
4336
|
+
onUpdate?: string | undefined;
|
|
4337
|
+
onDelete?: string | undefined;
|
|
4336
4338
|
name: string;
|
|
4337
4339
|
tableFrom: string;
|
|
4338
4340
|
columnsFrom: string[];
|
|
4339
4341
|
tableTo: string;
|
|
4340
4342
|
columnsTo: string[];
|
|
4343
|
+
}, {
|
|
4341
4344
|
onUpdate?: string | undefined;
|
|
4342
4345
|
onDelete?: string | undefined;
|
|
4343
|
-
}, {
|
|
4344
4346
|
name: string;
|
|
4345
4347
|
tableFrom: string;
|
|
4346
4348
|
columnsFrom: string[];
|
|
4347
4349
|
tableTo: string;
|
|
4348
4350
|
columnsTo: string[];
|
|
4349
|
-
onUpdate?: string | undefined;
|
|
4350
|
-
onDelete?: string | undefined;
|
|
4351
4351
|
}>>;
|
|
4352
4352
|
compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
|
|
4353
4353
|
name: import("zod").ZodString;
|
|
@@ -4372,30 +4372,30 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
|
|
|
4372
4372
|
}, "strict", import("zod").ZodTypeAny, {
|
|
4373
4373
|
name: string;
|
|
4374
4374
|
columns: Record<string, {
|
|
4375
|
+
default?: any;
|
|
4376
|
+
onUpdate?: any;
|
|
4377
|
+
autoincrement?: boolean | undefined;
|
|
4375
4378
|
name: string;
|
|
4376
4379
|
type: string;
|
|
4377
4380
|
primaryKey: boolean;
|
|
4378
4381
|
notNull: boolean;
|
|
4379
|
-
default?: any;
|
|
4380
|
-
onUpdate?: any;
|
|
4381
|
-
autoincrement?: boolean | undefined;
|
|
4382
4382
|
}>;
|
|
4383
4383
|
indexes: Record<string, {
|
|
4384
|
-
name: string;
|
|
4385
|
-
columns: string[];
|
|
4386
|
-
isUnique: boolean;
|
|
4387
4384
|
using?: "btree" | "hash" | undefined;
|
|
4388
4385
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
4389
4386
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
4387
|
+
name: string;
|
|
4388
|
+
columns: string[];
|
|
4389
|
+
isUnique: boolean;
|
|
4390
4390
|
}>;
|
|
4391
4391
|
foreignKeys: Record<string, {
|
|
4392
|
+
onUpdate?: string | undefined;
|
|
4393
|
+
onDelete?: string | undefined;
|
|
4392
4394
|
name: string;
|
|
4393
4395
|
tableFrom: string;
|
|
4394
4396
|
columnsFrom: string[];
|
|
4395
4397
|
tableTo: string;
|
|
4396
4398
|
columnsTo: string[];
|
|
4397
|
-
onUpdate?: string | undefined;
|
|
4398
|
-
onDelete?: string | undefined;
|
|
4399
4399
|
}>;
|
|
4400
4400
|
compositePrimaryKeys: Record<string, {
|
|
4401
4401
|
name: string;
|
|
@@ -4406,41 +4406,41 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
|
|
|
4406
4406
|
columns: string[];
|
|
4407
4407
|
}>;
|
|
4408
4408
|
}, {
|
|
4409
|
+
uniqueConstraints?: Record<string, {
|
|
4410
|
+
name: string;
|
|
4411
|
+
columns: string[];
|
|
4412
|
+
}> | undefined;
|
|
4409
4413
|
name: string;
|
|
4410
4414
|
columns: Record<string, {
|
|
4415
|
+
default?: any;
|
|
4416
|
+
onUpdate?: any;
|
|
4417
|
+
autoincrement?: boolean | undefined;
|
|
4411
4418
|
name: string;
|
|
4412
4419
|
type: string;
|
|
4413
4420
|
primaryKey: boolean;
|
|
4414
4421
|
notNull: boolean;
|
|
4415
|
-
default?: any;
|
|
4416
|
-
onUpdate?: any;
|
|
4417
|
-
autoincrement?: boolean | undefined;
|
|
4418
4422
|
}>;
|
|
4419
4423
|
indexes: Record<string, {
|
|
4420
|
-
name: string;
|
|
4421
|
-
columns: string[];
|
|
4422
|
-
isUnique: boolean;
|
|
4423
4424
|
using?: "btree" | "hash" | undefined;
|
|
4424
4425
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
4425
4426
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
4427
|
+
name: string;
|
|
4428
|
+
columns: string[];
|
|
4429
|
+
isUnique: boolean;
|
|
4426
4430
|
}>;
|
|
4427
4431
|
foreignKeys: Record<string, {
|
|
4432
|
+
onUpdate?: string | undefined;
|
|
4433
|
+
onDelete?: string | undefined;
|
|
4428
4434
|
name: string;
|
|
4429
4435
|
tableFrom: string;
|
|
4430
4436
|
columnsFrom: string[];
|
|
4431
4437
|
tableTo: string;
|
|
4432
4438
|
columnsTo: string[];
|
|
4433
|
-
onUpdate?: string | undefined;
|
|
4434
|
-
onDelete?: string | undefined;
|
|
4435
4439
|
}>;
|
|
4436
4440
|
compositePrimaryKeys: Record<string, {
|
|
4437
4441
|
name: string;
|
|
4438
4442
|
columns: string[];
|
|
4439
4443
|
}>;
|
|
4440
|
-
uniqueConstraints?: Record<string, {
|
|
4441
|
-
name: string;
|
|
4442
|
-
columns: string[];
|
|
4443
|
-
}> | undefined;
|
|
4444
4444
|
}>>;
|
|
4445
4445
|
_meta: import("zod").ZodObject<{
|
|
4446
4446
|
tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
|
|
@@ -4487,33 +4487,40 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
|
|
|
4487
4487
|
id: import("zod").ZodString;
|
|
4488
4488
|
prevId: import("zod").ZodString;
|
|
4489
4489
|
}>, "strip", import("zod").ZodTypeAny, {
|
|
4490
|
+
internal?: {
|
|
4491
|
+
tables: Record<string, {
|
|
4492
|
+
columns: Record<string, {
|
|
4493
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
4494
|
+
} | undefined>;
|
|
4495
|
+
} | undefined>;
|
|
4496
|
+
} | undefined;
|
|
4490
4497
|
tables: Record<string, {
|
|
4491
4498
|
name: string;
|
|
4492
4499
|
columns: Record<string, {
|
|
4500
|
+
default?: any;
|
|
4501
|
+
onUpdate?: any;
|
|
4502
|
+
autoincrement?: boolean | undefined;
|
|
4493
4503
|
name: string;
|
|
4494
4504
|
type: string;
|
|
4495
4505
|
primaryKey: boolean;
|
|
4496
4506
|
notNull: boolean;
|
|
4497
|
-
default?: any;
|
|
4498
|
-
onUpdate?: any;
|
|
4499
|
-
autoincrement?: boolean | undefined;
|
|
4500
4507
|
}>;
|
|
4501
4508
|
indexes: Record<string, {
|
|
4502
|
-
name: string;
|
|
4503
|
-
columns: string[];
|
|
4504
|
-
isUnique: boolean;
|
|
4505
4509
|
using?: "btree" | "hash" | undefined;
|
|
4506
4510
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
4507
4511
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
4512
|
+
name: string;
|
|
4513
|
+
columns: string[];
|
|
4514
|
+
isUnique: boolean;
|
|
4508
4515
|
}>;
|
|
4509
4516
|
foreignKeys: Record<string, {
|
|
4517
|
+
onUpdate?: string | undefined;
|
|
4518
|
+
onDelete?: string | undefined;
|
|
4510
4519
|
name: string;
|
|
4511
4520
|
tableFrom: string;
|
|
4512
4521
|
columnsFrom: string[];
|
|
4513
4522
|
tableTo: string;
|
|
4514
4523
|
columnsTo: string[];
|
|
4515
|
-
onUpdate?: string | undefined;
|
|
4516
|
-
onDelete?: string | undefined;
|
|
4517
4524
|
}>;
|
|
4518
4525
|
compositePrimaryKeys: Record<string, {
|
|
4519
4526
|
name: string;
|
|
@@ -4532,6 +4539,7 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
|
|
|
4532
4539
|
columns: Record<string, string>;
|
|
4533
4540
|
tables: Record<string, string>;
|
|
4534
4541
|
};
|
|
4542
|
+
}, {
|
|
4535
4543
|
internal?: {
|
|
4536
4544
|
tables: Record<string, {
|
|
4537
4545
|
columns: Record<string, {
|
|
@@ -4539,43 +4547,42 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
|
|
|
4539
4547
|
} | undefined>;
|
|
4540
4548
|
} | undefined>;
|
|
4541
4549
|
} | undefined;
|
|
4542
|
-
}, {
|
|
4543
4550
|
tables: Record<string, {
|
|
4551
|
+
uniqueConstraints?: Record<string, {
|
|
4552
|
+
name: string;
|
|
4553
|
+
columns: string[];
|
|
4554
|
+
}> | undefined;
|
|
4544
4555
|
name: string;
|
|
4545
4556
|
columns: Record<string, {
|
|
4557
|
+
default?: any;
|
|
4558
|
+
onUpdate?: any;
|
|
4559
|
+
autoincrement?: boolean | undefined;
|
|
4546
4560
|
name: string;
|
|
4547
4561
|
type: string;
|
|
4548
4562
|
primaryKey: boolean;
|
|
4549
4563
|
notNull: boolean;
|
|
4550
|
-
default?: any;
|
|
4551
|
-
onUpdate?: any;
|
|
4552
|
-
autoincrement?: boolean | undefined;
|
|
4553
4564
|
}>;
|
|
4554
4565
|
indexes: Record<string, {
|
|
4555
|
-
name: string;
|
|
4556
|
-
columns: string[];
|
|
4557
|
-
isUnique: boolean;
|
|
4558
4566
|
using?: "btree" | "hash" | undefined;
|
|
4559
4567
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
4560
4568
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
4569
|
+
name: string;
|
|
4570
|
+
columns: string[];
|
|
4571
|
+
isUnique: boolean;
|
|
4561
4572
|
}>;
|
|
4562
4573
|
foreignKeys: Record<string, {
|
|
4574
|
+
onUpdate?: string | undefined;
|
|
4575
|
+
onDelete?: string | undefined;
|
|
4563
4576
|
name: string;
|
|
4564
4577
|
tableFrom: string;
|
|
4565
4578
|
columnsFrom: string[];
|
|
4566
4579
|
tableTo: string;
|
|
4567
4580
|
columnsTo: string[];
|
|
4568
|
-
onUpdate?: string | undefined;
|
|
4569
|
-
onDelete?: string | undefined;
|
|
4570
4581
|
}>;
|
|
4571
4582
|
compositePrimaryKeys: Record<string, {
|
|
4572
4583
|
name: string;
|
|
4573
4584
|
columns: string[];
|
|
4574
4585
|
}>;
|
|
4575
|
-
uniqueConstraints?: Record<string, {
|
|
4576
|
-
name: string;
|
|
4577
|
-
columns: string[];
|
|
4578
|
-
}> | undefined;
|
|
4579
4586
|
}>;
|
|
4580
4587
|
id: string;
|
|
4581
4588
|
prevId: string;
|
|
@@ -4585,6 +4592,8 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
|
|
|
4585
4592
|
columns: Record<string, string>;
|
|
4586
4593
|
tables: Record<string, string>;
|
|
4587
4594
|
};
|
|
4595
|
+
}>]>;
|
|
4596
|
+
export declare const dryMySql: {
|
|
4588
4597
|
internal?: {
|
|
4589
4598
|
tables: Record<string, {
|
|
4590
4599
|
columns: Record<string, {
|
|
@@ -4592,35 +4601,33 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
|
|
|
4592
4601
|
} | undefined>;
|
|
4593
4602
|
} | undefined>;
|
|
4594
4603
|
} | undefined;
|
|
4595
|
-
}>]>;
|
|
4596
|
-
export declare const dryMySql: {
|
|
4597
4604
|
tables: Record<string, {
|
|
4598
4605
|
name: string;
|
|
4599
4606
|
columns: Record<string, {
|
|
4607
|
+
default?: any;
|
|
4608
|
+
onUpdate?: any;
|
|
4609
|
+
autoincrement?: boolean | undefined;
|
|
4600
4610
|
name: string;
|
|
4601
4611
|
type: string;
|
|
4602
4612
|
primaryKey: boolean;
|
|
4603
4613
|
notNull: boolean;
|
|
4604
|
-
default?: any;
|
|
4605
|
-
onUpdate?: any;
|
|
4606
|
-
autoincrement?: boolean | undefined;
|
|
4607
4614
|
}>;
|
|
4608
4615
|
indexes: Record<string, {
|
|
4609
|
-
name: string;
|
|
4610
|
-
columns: string[];
|
|
4611
|
-
isUnique: boolean;
|
|
4612
4616
|
using?: "btree" | "hash" | undefined;
|
|
4613
4617
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
4614
4618
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
4619
|
+
name: string;
|
|
4620
|
+
columns: string[];
|
|
4621
|
+
isUnique: boolean;
|
|
4615
4622
|
}>;
|
|
4616
4623
|
foreignKeys: Record<string, {
|
|
4624
|
+
onUpdate?: string | undefined;
|
|
4625
|
+
onDelete?: string | undefined;
|
|
4617
4626
|
name: string;
|
|
4618
4627
|
tableFrom: string;
|
|
4619
4628
|
columnsFrom: string[];
|
|
4620
4629
|
tableTo: string;
|
|
4621
4630
|
columnsTo: string[];
|
|
4622
|
-
onUpdate?: string | undefined;
|
|
4623
|
-
onDelete?: string | undefined;
|
|
4624
4631
|
}>;
|
|
4625
4632
|
compositePrimaryKeys: Record<string, {
|
|
4626
4633
|
name: string;
|
|
@@ -4639,12 +4646,5 @@ export declare const dryMySql: {
|
|
|
4639
4646
|
columns: Record<string, string>;
|
|
4640
4647
|
tables: Record<string, string>;
|
|
4641
4648
|
};
|
|
4642
|
-
internal?: {
|
|
4643
|
-
tables: Record<string, {
|
|
4644
|
-
columns: Record<string, {
|
|
4645
|
-
isDefaultAnExpression?: boolean | undefined;
|
|
4646
|
-
} | undefined>;
|
|
4647
|
-
} | undefined>;
|
|
4648
|
-
} | undefined;
|
|
4649
4649
|
};
|
|
4650
4650
|
export {};
|