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