drizzle-kit 1.0.0-beta.1 → 1.0.0-beta.1-dfa4db3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (14) hide show
  1. package/api.d.mts +3336 -0
  2. package/api.d.ts +3336 -0
  3. package/api.js +169529 -0
  4. package/api.mjs +169507 -0
  5. package/bin.cjs +76545 -159209
  6. package/index.d.mts +1 -28
  7. package/index.d.ts +1 -28
  8. package/package.json +29 -27
  9. package/utils.js +6408 -0
  10. package/utils.mjs +6383 -0
  11. package/api-postgres.d.mts +0 -12370
  12. package/api-postgres.d.ts +0 -12370
  13. package/api-postgres.js +0 -33441
  14. package/api-postgres.mjs +0 -33434
package/api.d.ts ADDED
@@ -0,0 +1,3336 @@
1
+ import { PGlite } from '@electric-sql/pglite';
2
+ import { LibSQLDatabase } from 'drizzle-orm/libsql';
3
+ import { MySql2Database } from 'drizzle-orm/mysql2';
4
+ import { PgDatabase } from 'drizzle-orm/pg-core';
5
+ import { SingleStoreDriverDatabase } from 'drizzle-orm/singlestore';
6
+ import * as zod from 'zod';
7
+ import { TypeOf } from 'zod';
8
+ import { ConnectionOptions } from 'tls';
9
+
10
+ declare const prefixes: readonly ["index", "timestamp", "supabase", "unix", "none"];
11
+ type Prefix = (typeof prefixes)[number];
12
+ declare const casingTypes: readonly ["snake_case", "camelCase"];
13
+ type CasingType = (typeof casingTypes)[number];
14
+ declare const drivers: readonly ["d1-http", "expo", "aws-data-api", "pglite", "durable-sqlite"];
15
+ type Driver = (typeof drivers)[number];
16
+
17
+ declare const mysqlCredentials: zod.ZodUnion<[zod.ZodObject<{
18
+ host: zod.ZodString;
19
+ port: zod.ZodOptional<zod.ZodNumber>;
20
+ user: zod.ZodOptional<zod.ZodString>;
21
+ password: zod.ZodOptional<zod.ZodString>;
22
+ database: zod.ZodString;
23
+ ssl: zod.ZodOptional<zod.ZodUnion<[zod.ZodString, zod.ZodObject<{
24
+ pfx: zod.ZodOptional<zod.ZodString>;
25
+ key: zod.ZodOptional<zod.ZodString>;
26
+ passphrase: zod.ZodOptional<zod.ZodString>;
27
+ cert: zod.ZodOptional<zod.ZodString>;
28
+ ca: zod.ZodOptional<zod.ZodUnion<[zod.ZodString, zod.ZodArray<zod.ZodString, "many">]>>;
29
+ crl: zod.ZodOptional<zod.ZodUnion<[zod.ZodString, zod.ZodArray<zod.ZodString, "many">]>>;
30
+ ciphers: zod.ZodOptional<zod.ZodString>;
31
+ rejectUnauthorized: zod.ZodOptional<zod.ZodBoolean>;
32
+ }, "strip", zod.ZodTypeAny, {
33
+ pfx?: string | undefined;
34
+ key?: string | undefined;
35
+ passphrase?: string | undefined;
36
+ cert?: string | undefined;
37
+ ca?: string | string[] | undefined;
38
+ crl?: string | string[] | undefined;
39
+ ciphers?: string | undefined;
40
+ rejectUnauthorized?: boolean | undefined;
41
+ }, {
42
+ pfx?: string | undefined;
43
+ key?: string | undefined;
44
+ passphrase?: string | undefined;
45
+ cert?: string | undefined;
46
+ ca?: string | string[] | undefined;
47
+ crl?: string | string[] | undefined;
48
+ ciphers?: string | undefined;
49
+ rejectUnauthorized?: boolean | undefined;
50
+ }>]>>;
51
+ }, "strip", zod.ZodTypeAny, {
52
+ host: string;
53
+ database: string;
54
+ port?: number | undefined;
55
+ user?: string | undefined;
56
+ password?: string | undefined;
57
+ ssl?: string | {
58
+ pfx?: string | undefined;
59
+ key?: string | undefined;
60
+ passphrase?: string | undefined;
61
+ cert?: string | undefined;
62
+ ca?: string | string[] | undefined;
63
+ crl?: string | string[] | undefined;
64
+ ciphers?: string | undefined;
65
+ rejectUnauthorized?: boolean | undefined;
66
+ } | undefined;
67
+ }, {
68
+ host: string;
69
+ database: string;
70
+ port?: number | undefined;
71
+ user?: string | undefined;
72
+ password?: string | undefined;
73
+ ssl?: string | {
74
+ pfx?: string | undefined;
75
+ key?: string | undefined;
76
+ passphrase?: string | undefined;
77
+ cert?: string | undefined;
78
+ ca?: string | string[] | undefined;
79
+ crl?: string | string[] | undefined;
80
+ ciphers?: string | undefined;
81
+ rejectUnauthorized?: boolean | undefined;
82
+ } | undefined;
83
+ }>, zod.ZodObject<{
84
+ url: zod.ZodString;
85
+ }, "strip", zod.ZodTypeAny, {
86
+ url: string;
87
+ }, {
88
+ url: string;
89
+ }>]>;
90
+ type MysqlCredentials = TypeOf<typeof mysqlCredentials>;
91
+
92
+ declare const postgresCredentials: zod.ZodUnion<[zod.ZodEffects<zod.ZodObject<{
93
+ driver: zod.ZodUndefined;
94
+ host: zod.ZodString;
95
+ port: zod.ZodOptional<zod.ZodNumber>;
96
+ user: zod.ZodOptional<zod.ZodString>;
97
+ password: zod.ZodOptional<zod.ZodString>;
98
+ database: zod.ZodString;
99
+ ssl: zod.ZodOptional<zod.ZodUnion<[zod.ZodLiteral<"require">, zod.ZodLiteral<"allow">, zod.ZodLiteral<"prefer">, zod.ZodLiteral<"verify-full">, zod.ZodBoolean, zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>]>>;
100
+ }, "strip", zod.ZodTypeAny, {
101
+ host: string;
102
+ database: string;
103
+ driver?: undefined;
104
+ port?: number | undefined;
105
+ user?: string | undefined;
106
+ password?: string | undefined;
107
+ ssl?: boolean | "require" | "allow" | "prefer" | "verify-full" | zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough"> | undefined;
108
+ }, {
109
+ host: string;
110
+ database: string;
111
+ driver?: undefined;
112
+ port?: number | undefined;
113
+ user?: string | undefined;
114
+ password?: string | undefined;
115
+ ssl?: boolean | "require" | "allow" | "prefer" | "verify-full" | zod.objectInputType<{}, zod.ZodTypeAny, "passthrough"> | undefined;
116
+ }>, Omit<{
117
+ host: string;
118
+ database: string;
119
+ driver?: undefined;
120
+ port?: number | undefined;
121
+ user?: string | undefined;
122
+ password?: string | undefined;
123
+ ssl?: boolean | "require" | "allow" | "prefer" | "verify-full" | zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough"> | undefined;
124
+ }, "driver">, {
125
+ host: string;
126
+ database: string;
127
+ driver?: undefined;
128
+ port?: number | undefined;
129
+ user?: string | undefined;
130
+ password?: string | undefined;
131
+ ssl?: boolean | "require" | "allow" | "prefer" | "verify-full" | zod.objectInputType<{}, zod.ZodTypeAny, "passthrough"> | undefined;
132
+ }>, zod.ZodEffects<zod.ZodObject<{
133
+ driver: zod.ZodUndefined;
134
+ url: zod.ZodString;
135
+ }, "strip", zod.ZodTypeAny, {
136
+ url: string;
137
+ driver?: undefined;
138
+ }, {
139
+ url: string;
140
+ driver?: undefined;
141
+ }>, {
142
+ url: string;
143
+ }, {
144
+ url: string;
145
+ driver?: undefined;
146
+ }>, zod.ZodObject<{
147
+ driver: zod.ZodLiteral<"aws-data-api">;
148
+ database: zod.ZodString;
149
+ secretArn: zod.ZodString;
150
+ resourceArn: zod.ZodString;
151
+ }, "strip", zod.ZodTypeAny, {
152
+ driver: "aws-data-api";
153
+ database: string;
154
+ secretArn: string;
155
+ resourceArn: string;
156
+ }, {
157
+ driver: "aws-data-api";
158
+ database: string;
159
+ secretArn: string;
160
+ resourceArn: string;
161
+ }>, zod.ZodObject<{
162
+ driver: zod.ZodLiteral<"pglite">;
163
+ url: zod.ZodString;
164
+ }, "strip", zod.ZodTypeAny, {
165
+ url: string;
166
+ driver: "pglite";
167
+ }, {
168
+ url: string;
169
+ driver: "pglite";
170
+ }>]>;
171
+ type PostgresCredentials = TypeOf<typeof postgresCredentials>;
172
+
173
+ declare const singlestoreCredentials: zod.ZodUnion<[zod.ZodObject<{
174
+ host: zod.ZodString;
175
+ port: zod.ZodOptional<zod.ZodNumber>;
176
+ user: zod.ZodOptional<zod.ZodString>;
177
+ password: zod.ZodOptional<zod.ZodString>;
178
+ database: zod.ZodString;
179
+ ssl: zod.ZodOptional<zod.ZodUnion<[zod.ZodString, zod.ZodObject<{
180
+ pfx: zod.ZodOptional<zod.ZodString>;
181
+ key: zod.ZodOptional<zod.ZodString>;
182
+ passphrase: zod.ZodOptional<zod.ZodString>;
183
+ cert: zod.ZodOptional<zod.ZodString>;
184
+ ca: zod.ZodOptional<zod.ZodUnion<[zod.ZodString, zod.ZodArray<zod.ZodString, "many">]>>;
185
+ crl: zod.ZodOptional<zod.ZodUnion<[zod.ZodString, zod.ZodArray<zod.ZodString, "many">]>>;
186
+ ciphers: zod.ZodOptional<zod.ZodString>;
187
+ rejectUnauthorized: zod.ZodOptional<zod.ZodBoolean>;
188
+ }, "strip", zod.ZodTypeAny, {
189
+ pfx?: string | undefined;
190
+ key?: string | undefined;
191
+ passphrase?: string | undefined;
192
+ cert?: string | undefined;
193
+ ca?: string | string[] | undefined;
194
+ crl?: string | string[] | undefined;
195
+ ciphers?: string | undefined;
196
+ rejectUnauthorized?: boolean | undefined;
197
+ }, {
198
+ pfx?: string | undefined;
199
+ key?: string | undefined;
200
+ passphrase?: string | undefined;
201
+ cert?: string | undefined;
202
+ ca?: string | string[] | undefined;
203
+ crl?: string | string[] | undefined;
204
+ ciphers?: string | undefined;
205
+ rejectUnauthorized?: boolean | undefined;
206
+ }>]>>;
207
+ }, "strip", zod.ZodTypeAny, {
208
+ host: string;
209
+ database: string;
210
+ port?: number | undefined;
211
+ user?: string | undefined;
212
+ password?: string | undefined;
213
+ ssl?: string | {
214
+ pfx?: string | undefined;
215
+ key?: string | undefined;
216
+ passphrase?: string | undefined;
217
+ cert?: string | undefined;
218
+ ca?: string | string[] | undefined;
219
+ crl?: string | string[] | undefined;
220
+ ciphers?: string | undefined;
221
+ rejectUnauthorized?: boolean | undefined;
222
+ } | undefined;
223
+ }, {
224
+ host: string;
225
+ database: string;
226
+ port?: number | undefined;
227
+ user?: string | undefined;
228
+ password?: string | undefined;
229
+ ssl?: string | {
230
+ pfx?: string | undefined;
231
+ key?: string | undefined;
232
+ passphrase?: string | undefined;
233
+ cert?: string | undefined;
234
+ ca?: string | string[] | undefined;
235
+ crl?: string | string[] | undefined;
236
+ ciphers?: string | undefined;
237
+ rejectUnauthorized?: boolean | undefined;
238
+ } | undefined;
239
+ }>, zod.ZodObject<{
240
+ url: zod.ZodString;
241
+ }, "strip", zod.ZodTypeAny, {
242
+ url: string;
243
+ }, {
244
+ url: string;
245
+ }>]>;
246
+ type SingleStoreCredentials = TypeOf<typeof singlestoreCredentials>;
247
+
248
+ type SqliteCredentials = {
249
+ driver: 'd1-http';
250
+ accountId: string;
251
+ databaseId: string;
252
+ token: string;
253
+ } | {
254
+ url: string;
255
+ };
256
+
257
+ declare const dialects: readonly ["postgresql", "mysql", "sqlite", "turso", "singlestore", "gel"];
258
+ type Dialect = (typeof dialects)[number];
259
+
260
+ type SslOptions = {
261
+ pfx?: string;
262
+ key?: string;
263
+ passphrase?: string;
264
+ cert?: string;
265
+ ca?: string | string[];
266
+ crl?: string | string[];
267
+ ciphers?: string;
268
+ rejectUnauthorized?: boolean;
269
+ };
270
+ type Verify<T, U extends T> = U;
271
+ /**
272
+ * **You are currently using version 0.21.0+ of drizzle-kit. If you have just upgraded to this version, please make sure to read the changelog to understand what changes have been made and what
273
+ * adjustments may be necessary for you. See https://orm.drizzle.team/kit-docs/upgrade-21#how-to-migrate-to-0210**
274
+ *
275
+ * **Config** usage:
276
+ *
277
+ * `dialect` - mandatory and is responsible for explicitly providing a databse dialect you are using for all the commands
278
+ * *Possible values*: `postgresql`, `mysql`, `sqlite`, `singlestore
279
+ *
280
+ * See https://orm.drizzle.team/kit-docs/config-reference#dialect
281
+ *
282
+ * ---
283
+ * `schema` - param lets you define where your schema file/files live.
284
+ * You can have as many separate schema files as you want and define paths to them using glob or array of globs syntax.
285
+ *
286
+ * See https://orm.drizzle.team/kit-docs/config-reference#schema
287
+ *
288
+ * ---
289
+ * `out` - allows you to define the folder for your migrations and a folder, where drizzle will introspect the schema and relations
290
+ *
291
+ * See https://orm.drizzle.team/kit-docs/config-reference#out
292
+ *
293
+ * ---
294
+ * `driver` - optional param that is responsible for explicitly providing a driver to use when accessing a database
295
+ * *Possible values*: `aws-data-api`, `d1-http`, `expo`, `turso`, `pglite`
296
+ * If you don't use AWS Data API, D1, Turso or Expo - ypu don't need this driver. You can check a driver strategy choice here: https://orm.drizzle.team/kit-docs/upgrade-21
297
+ *
298
+ * See https://orm.drizzle.team/kit-docs/config-reference#driver
299
+ *
300
+ * ---
301
+ *
302
+ * `dbCredentials` - an object to define your connection to the database. For more info please check the docs
303
+ *
304
+ * See https://orm.drizzle.team/kit-docs/config-reference#dbcredentials
305
+ *
306
+ * ---
307
+ *
308
+ * `migrations` - param let’s use specify custom table and schema(PostgreSQL only) for migrations.
309
+ * By default, all information about executed migrations will be stored in the database inside
310
+ * the `__drizzle_migrations` table, and for PostgreSQL, inside the drizzle schema.
311
+ * However, you can configure where to store those records.
312
+ *
313
+ * See https://orm.drizzle.team/kit-docs/config-reference#migrations
314
+ *
315
+ * ---
316
+ *
317
+ * `breakpoints` - param lets you enable/disable SQL statement breakpoints in generated migrations.
318
+ * It’s optional and true by default, it’s necessary to properly apply migrations on databases,
319
+ * that do not support multiple DDL alternation statements in one transaction(MySQL, SQLite, SingleStore) and
320
+ * Drizzle ORM has to apply them sequentially one by one.
321
+ *
322
+ * See https://orm.drizzle.team/kit-docs/config-reference#breakpoints
323
+ *
324
+ * ---
325
+ *
326
+ * `tablesFilters` - param lets you filter tables with glob syntax for db push command.
327
+ * It’s useful when you have only one database avaialable for several separate projects with separate sql schemas.
328
+ *
329
+ * How to define multi-project tables with Drizzle ORM — see https://orm.drizzle.team/docs/goodies#multi-project-schema
330
+ *
331
+ * See https://orm.drizzle.team/kit-docs/config-reference#tablesfilters
332
+ *
333
+ * ---
334
+ *
335
+ * `schemaFilter` - parameter allows you to define which schema in PostgreSQL should be used for either introspect or push commands.
336
+ * This parameter accepts a single schema as a string or an array of schemas as strings.
337
+ * No glob pattern is supported here. By default, drizzle will use the public schema for both commands,
338
+ * but you can add any schema you need.
339
+ *
340
+ * For example, having schemaFilter: ["my_schema"] will only look for tables in both the database and
341
+ * drizzle schema that are a part of the my_schema schema.
342
+ *
343
+ * See https://orm.drizzle.team/kit-docs/config-reference#schemafilter
344
+ *
345
+ * ---
346
+ *
347
+ * `verbose` - command is used for drizzle-kit push commands and prints all statements that will be executed.
348
+ *
349
+ * > Note: This command will only print the statements that should be executed.
350
+ * To approve them before applying, please refer to the `strict` command.
351
+ *
352
+ * See https://orm.drizzle.team/kit-docs/config-reference#verbose
353
+ *
354
+ * ---
355
+ *
356
+ * `strict` - command is used for drizzle-kit push commands and will always ask for your confirmation,
357
+ * either to execute all statements needed to sync your schema with the database or not.
358
+ *
359
+ * See https://orm.drizzle.team/kit-docs/config-reference#strict
360
+ */
361
+ type Config = {
362
+ dialect: Dialect;
363
+ out?: string;
364
+ breakpoints?: boolean;
365
+ tablesFilter?: string | string[];
366
+ extensionsFilters?: 'postgis'[];
367
+ schemaFilter?: string | string[];
368
+ schema?: string | string[];
369
+ verbose?: boolean;
370
+ strict?: boolean;
371
+ casing?: 'camelCase' | 'snake_case';
372
+ migrations?: {
373
+ table?: string;
374
+ schema?: string;
375
+ prefix?: Prefix;
376
+ };
377
+ introspect?: {
378
+ casing: 'camel' | 'preserve';
379
+ };
380
+ entities?: {
381
+ roles?: boolean | {
382
+ provider?: 'supabase' | 'neon' | string & {};
383
+ exclude?: string[];
384
+ include?: string[];
385
+ };
386
+ };
387
+ } & ({
388
+ dialect: Verify<Dialect, 'turso'>;
389
+ dbCredentials: {
390
+ url: string;
391
+ authToken?: string;
392
+ };
393
+ } | {
394
+ dialect: Verify<Dialect, 'sqlite'>;
395
+ dbCredentials: {
396
+ url: string;
397
+ };
398
+ } | {
399
+ dialect: Verify<Dialect, 'postgresql'>;
400
+ dbCredentials: ({
401
+ host: string;
402
+ port?: number;
403
+ user?: string;
404
+ password?: string;
405
+ database: string;
406
+ ssl?: boolean | 'require' | 'allow' | 'prefer' | 'verify-full' | ConnectionOptions;
407
+ } & {}) | {
408
+ url: string;
409
+ };
410
+ } | {
411
+ dialect: Verify<Dialect, 'postgresql'>;
412
+ driver: Verify<Driver, 'aws-data-api'>;
413
+ dbCredentials: {
414
+ database: string;
415
+ secretArn: string;
416
+ resourceArn: string;
417
+ };
418
+ } | {
419
+ dialect: Verify<Dialect, 'postgresql'>;
420
+ driver: Verify<Driver, 'pglite'>;
421
+ dbCredentials: {
422
+ url: string;
423
+ };
424
+ } | {
425
+ dialect: Verify<Dialect, 'mysql'>;
426
+ dbCredentials: {
427
+ host: string;
428
+ port?: number;
429
+ user?: string;
430
+ password?: string;
431
+ database: string;
432
+ ssl?: string | SslOptions;
433
+ } | {
434
+ url: string;
435
+ };
436
+ } | {
437
+ dialect: Verify<Dialect, 'sqlite'>;
438
+ driver: Verify<Driver, 'd1-http'>;
439
+ dbCredentials: {
440
+ accountId: string;
441
+ databaseId: string;
442
+ token: string;
443
+ };
444
+ } | {
445
+ dialect: Verify<Dialect, 'sqlite'>;
446
+ driver: Verify<Driver, 'expo'>;
447
+ } | {
448
+ dialect: Verify<Dialect, 'sqlite'>;
449
+ driver: Verify<Driver, 'durable-sqlite'>;
450
+ } | {} | {
451
+ dialect: Verify<Dialect, 'singlestore'>;
452
+ dbCredentials: {
453
+ host: string;
454
+ port?: number;
455
+ user?: string;
456
+ password?: string;
457
+ database: string;
458
+ ssl?: string | SslOptions;
459
+ } | {
460
+ url: string;
461
+ };
462
+ } | {
463
+ dialect: Verify<Dialect, 'gel'>;
464
+ dbCredentials?: {
465
+ tlsSecurity?: 'insecure' | 'no_host_verification' | 'strict' | 'default';
466
+ } & ({
467
+ url: string;
468
+ } | ({
469
+ host: string;
470
+ port?: number;
471
+ user?: string;
472
+ password?: string;
473
+ database: string;
474
+ }));
475
+ });
476
+
477
+ declare const schema$2: zod.ZodObject<{
478
+ version: zod.ZodLiteral<"5">;
479
+ dialect: zod.ZodLiteral<"mysql">;
480
+ tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
481
+ name: zod.ZodString;
482
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
483
+ name: zod.ZodString;
484
+ type: zod.ZodString;
485
+ primaryKey: zod.ZodBoolean;
486
+ notNull: zod.ZodBoolean;
487
+ autoincrement: zod.ZodOptional<zod.ZodBoolean>;
488
+ default: zod.ZodOptional<zod.ZodAny>;
489
+ onUpdate: zod.ZodOptional<zod.ZodAny>;
490
+ generated: zod.ZodOptional<zod.ZodObject<{
491
+ type: zod.ZodEnum<["stored", "virtual"]>;
492
+ as: zod.ZodString;
493
+ }, "strip", zod.ZodTypeAny, {
494
+ type: "stored" | "virtual";
495
+ as: string;
496
+ }, {
497
+ type: "stored" | "virtual";
498
+ as: string;
499
+ }>>;
500
+ }, "strict", zod.ZodTypeAny, {
501
+ type: string;
502
+ name: string;
503
+ primaryKey: boolean;
504
+ notNull: boolean;
505
+ default?: any;
506
+ generated?: {
507
+ type: "stored" | "virtual";
508
+ as: string;
509
+ } | undefined;
510
+ onUpdate?: any;
511
+ autoincrement?: boolean | undefined;
512
+ }, {
513
+ type: string;
514
+ name: string;
515
+ primaryKey: boolean;
516
+ notNull: boolean;
517
+ default?: any;
518
+ generated?: {
519
+ type: "stored" | "virtual";
520
+ as: string;
521
+ } | undefined;
522
+ onUpdate?: any;
523
+ autoincrement?: boolean | undefined;
524
+ }>>;
525
+ indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
526
+ name: zod.ZodString;
527
+ columns: zod.ZodArray<zod.ZodString, "many">;
528
+ isUnique: zod.ZodBoolean;
529
+ using: zod.ZodOptional<zod.ZodEnum<["btree", "hash"]>>;
530
+ algorithm: zod.ZodOptional<zod.ZodEnum<["default", "inplace", "copy"]>>;
531
+ lock: zod.ZodOptional<zod.ZodEnum<["default", "none", "shared", "exclusive"]>>;
532
+ }, "strict", zod.ZodTypeAny, {
533
+ name: string;
534
+ columns: string[];
535
+ isUnique: boolean;
536
+ using?: "btree" | "hash" | undefined;
537
+ algorithm?: "default" | "inplace" | "copy" | undefined;
538
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
539
+ }, {
540
+ name: string;
541
+ columns: string[];
542
+ isUnique: boolean;
543
+ using?: "btree" | "hash" | undefined;
544
+ algorithm?: "default" | "inplace" | "copy" | undefined;
545
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
546
+ }>>;
547
+ foreignKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
548
+ name: zod.ZodString;
549
+ tableFrom: zod.ZodString;
550
+ columnsFrom: zod.ZodArray<zod.ZodString, "many">;
551
+ tableTo: zod.ZodString;
552
+ columnsTo: zod.ZodArray<zod.ZodString, "many">;
553
+ onUpdate: zod.ZodOptional<zod.ZodString>;
554
+ onDelete: zod.ZodOptional<zod.ZodString>;
555
+ }, "strict", zod.ZodTypeAny, {
556
+ name: string;
557
+ tableFrom: string;
558
+ columnsFrom: string[];
559
+ tableTo: string;
560
+ columnsTo: string[];
561
+ onUpdate?: string | undefined;
562
+ onDelete?: string | undefined;
563
+ }, {
564
+ name: string;
565
+ tableFrom: string;
566
+ columnsFrom: string[];
567
+ tableTo: string;
568
+ columnsTo: string[];
569
+ onUpdate?: string | undefined;
570
+ onDelete?: string | undefined;
571
+ }>>;
572
+ compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
573
+ name: zod.ZodString;
574
+ columns: zod.ZodArray<zod.ZodString, "many">;
575
+ }, "strict", zod.ZodTypeAny, {
576
+ name: string;
577
+ columns: string[];
578
+ }, {
579
+ name: string;
580
+ columns: string[];
581
+ }>>;
582
+ uniqueConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
583
+ name: zod.ZodString;
584
+ columns: zod.ZodArray<zod.ZodString, "many">;
585
+ }, "strict", zod.ZodTypeAny, {
586
+ name: string;
587
+ columns: string[];
588
+ }, {
589
+ name: string;
590
+ columns: string[];
591
+ }>>>;
592
+ checkConstraint: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
593
+ name: zod.ZodString;
594
+ value: zod.ZodString;
595
+ }, "strict", zod.ZodTypeAny, {
596
+ value: string;
597
+ name: string;
598
+ }, {
599
+ value: string;
600
+ name: string;
601
+ }>>>;
602
+ }, "strict", zod.ZodTypeAny, {
603
+ name: string;
604
+ columns: Record<string, {
605
+ type: string;
606
+ name: string;
607
+ primaryKey: boolean;
608
+ notNull: boolean;
609
+ default?: any;
610
+ generated?: {
611
+ type: "stored" | "virtual";
612
+ as: string;
613
+ } | undefined;
614
+ onUpdate?: any;
615
+ autoincrement?: boolean | undefined;
616
+ }>;
617
+ indexes: Record<string, {
618
+ name: string;
619
+ columns: string[];
620
+ isUnique: boolean;
621
+ using?: "btree" | "hash" | undefined;
622
+ algorithm?: "default" | "inplace" | "copy" | undefined;
623
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
624
+ }>;
625
+ foreignKeys: Record<string, {
626
+ name: string;
627
+ tableFrom: string;
628
+ columnsFrom: string[];
629
+ tableTo: string;
630
+ columnsTo: string[];
631
+ onUpdate?: string | undefined;
632
+ onDelete?: string | undefined;
633
+ }>;
634
+ compositePrimaryKeys: Record<string, {
635
+ name: string;
636
+ columns: string[];
637
+ }>;
638
+ uniqueConstraints: Record<string, {
639
+ name: string;
640
+ columns: string[];
641
+ }>;
642
+ checkConstraint: Record<string, {
643
+ value: string;
644
+ name: string;
645
+ }>;
646
+ }, {
647
+ name: string;
648
+ columns: Record<string, {
649
+ type: string;
650
+ name: string;
651
+ primaryKey: boolean;
652
+ notNull: boolean;
653
+ default?: any;
654
+ generated?: {
655
+ type: "stored" | "virtual";
656
+ as: string;
657
+ } | undefined;
658
+ onUpdate?: any;
659
+ autoincrement?: boolean | undefined;
660
+ }>;
661
+ indexes: Record<string, {
662
+ name: string;
663
+ columns: string[];
664
+ isUnique: boolean;
665
+ using?: "btree" | "hash" | undefined;
666
+ algorithm?: "default" | "inplace" | "copy" | undefined;
667
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
668
+ }>;
669
+ foreignKeys: Record<string, {
670
+ name: string;
671
+ tableFrom: string;
672
+ columnsFrom: string[];
673
+ tableTo: string;
674
+ columnsTo: string[];
675
+ onUpdate?: string | undefined;
676
+ onDelete?: string | undefined;
677
+ }>;
678
+ compositePrimaryKeys: Record<string, {
679
+ name: string;
680
+ columns: string[];
681
+ }>;
682
+ uniqueConstraints?: Record<string, {
683
+ name: string;
684
+ columns: string[];
685
+ }> | undefined;
686
+ checkConstraint?: Record<string, {
687
+ value: string;
688
+ name: string;
689
+ }> | undefined;
690
+ }>>;
691
+ views: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
692
+ name: zod.ZodString;
693
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
694
+ name: zod.ZodString;
695
+ type: zod.ZodString;
696
+ primaryKey: zod.ZodBoolean;
697
+ notNull: zod.ZodBoolean;
698
+ autoincrement: zod.ZodOptional<zod.ZodBoolean>;
699
+ default: zod.ZodOptional<zod.ZodAny>;
700
+ onUpdate: zod.ZodOptional<zod.ZodAny>;
701
+ generated: zod.ZodOptional<zod.ZodObject<{
702
+ type: zod.ZodEnum<["stored", "virtual"]>;
703
+ as: zod.ZodString;
704
+ }, "strip", zod.ZodTypeAny, {
705
+ type: "stored" | "virtual";
706
+ as: string;
707
+ }, {
708
+ type: "stored" | "virtual";
709
+ as: string;
710
+ }>>;
711
+ }, "strict", zod.ZodTypeAny, {
712
+ type: string;
713
+ name: string;
714
+ primaryKey: boolean;
715
+ notNull: boolean;
716
+ default?: any;
717
+ generated?: {
718
+ type: "stored" | "virtual";
719
+ as: string;
720
+ } | undefined;
721
+ onUpdate?: any;
722
+ autoincrement?: boolean | undefined;
723
+ }, {
724
+ type: string;
725
+ name: string;
726
+ primaryKey: boolean;
727
+ notNull: boolean;
728
+ default?: any;
729
+ generated?: {
730
+ type: "stored" | "virtual";
731
+ as: string;
732
+ } | undefined;
733
+ onUpdate?: any;
734
+ autoincrement?: boolean | undefined;
735
+ }>>;
736
+ definition: zod.ZodOptional<zod.ZodString>;
737
+ isExisting: zod.ZodBoolean;
738
+ } & {
739
+ algorithm: zod.ZodEnum<["undefined", "merge", "temptable"]>;
740
+ sqlSecurity: zod.ZodEnum<["definer", "invoker"]>;
741
+ withCheckOption: zod.ZodOptional<zod.ZodEnum<["local", "cascaded"]>>;
742
+ }, "strict", zod.ZodTypeAny, {
743
+ name: string;
744
+ columns: Record<string, {
745
+ type: string;
746
+ name: string;
747
+ primaryKey: boolean;
748
+ notNull: boolean;
749
+ default?: any;
750
+ generated?: {
751
+ type: "stored" | "virtual";
752
+ as: string;
753
+ } | undefined;
754
+ onUpdate?: any;
755
+ autoincrement?: boolean | undefined;
756
+ }>;
757
+ isExisting: boolean;
758
+ algorithm: "undefined" | "merge" | "temptable";
759
+ sqlSecurity: "definer" | "invoker";
760
+ definition?: string | undefined;
761
+ withCheckOption?: "local" | "cascaded" | undefined;
762
+ }, {
763
+ name: string;
764
+ columns: Record<string, {
765
+ type: string;
766
+ name: string;
767
+ primaryKey: boolean;
768
+ notNull: boolean;
769
+ default?: any;
770
+ generated?: {
771
+ type: "stored" | "virtual";
772
+ as: string;
773
+ } | undefined;
774
+ onUpdate?: any;
775
+ autoincrement?: boolean | undefined;
776
+ }>;
777
+ isExisting: boolean;
778
+ algorithm: "undefined" | "merge" | "temptable";
779
+ sqlSecurity: "definer" | "invoker";
780
+ definition?: string | undefined;
781
+ withCheckOption?: "local" | "cascaded" | undefined;
782
+ }>>>;
783
+ _meta: zod.ZodObject<{
784
+ tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
785
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
786
+ }, "strip", zod.ZodTypeAny, {
787
+ tables: Record<string, string>;
788
+ columns: Record<string, string>;
789
+ }, {
790
+ tables: Record<string, string>;
791
+ columns: Record<string, string>;
792
+ }>;
793
+ internal: zod.ZodOptional<zod.ZodObject<{
794
+ tables: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
795
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
796
+ isDefaultAnExpression: zod.ZodOptional<zod.ZodBoolean>;
797
+ }, "strip", zod.ZodTypeAny, {
798
+ isDefaultAnExpression?: boolean | undefined;
799
+ }, {
800
+ isDefaultAnExpression?: boolean | undefined;
801
+ }>>>;
802
+ }, "strip", zod.ZodTypeAny, {
803
+ columns: Record<string, {
804
+ isDefaultAnExpression?: boolean | undefined;
805
+ } | undefined>;
806
+ }, {
807
+ columns: Record<string, {
808
+ isDefaultAnExpression?: boolean | undefined;
809
+ } | undefined>;
810
+ }>>>>;
811
+ indexes: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
812
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
813
+ isExpression: zod.ZodOptional<zod.ZodBoolean>;
814
+ }, "strip", zod.ZodTypeAny, {
815
+ isExpression?: boolean | undefined;
816
+ }, {
817
+ isExpression?: boolean | undefined;
818
+ }>>>;
819
+ }, "strip", zod.ZodTypeAny, {
820
+ columns: Record<string, {
821
+ isExpression?: boolean | undefined;
822
+ } | undefined>;
823
+ }, {
824
+ columns: Record<string, {
825
+ isExpression?: boolean | undefined;
826
+ } | undefined>;
827
+ }>>>>;
828
+ }, "strip", zod.ZodTypeAny, {
829
+ tables?: Record<string, {
830
+ columns: Record<string, {
831
+ isDefaultAnExpression?: boolean | undefined;
832
+ } | undefined>;
833
+ } | undefined> | undefined;
834
+ indexes?: Record<string, {
835
+ columns: Record<string, {
836
+ isExpression?: boolean | undefined;
837
+ } | undefined>;
838
+ } | undefined> | undefined;
839
+ }, {
840
+ tables?: Record<string, {
841
+ columns: Record<string, {
842
+ isDefaultAnExpression?: boolean | undefined;
843
+ } | undefined>;
844
+ } | undefined> | undefined;
845
+ indexes?: Record<string, {
846
+ columns: Record<string, {
847
+ isExpression?: boolean | undefined;
848
+ } | undefined>;
849
+ } | undefined> | undefined;
850
+ }>>;
851
+ } & {
852
+ id: zod.ZodString;
853
+ prevId: zod.ZodString;
854
+ }, "strip", zod.ZodTypeAny, {
855
+ version: "5";
856
+ dialect: "mysql";
857
+ tables: Record<string, {
858
+ name: string;
859
+ columns: Record<string, {
860
+ type: string;
861
+ name: string;
862
+ primaryKey: boolean;
863
+ notNull: boolean;
864
+ default?: any;
865
+ generated?: {
866
+ type: "stored" | "virtual";
867
+ as: string;
868
+ } | undefined;
869
+ onUpdate?: any;
870
+ autoincrement?: boolean | undefined;
871
+ }>;
872
+ indexes: Record<string, {
873
+ name: string;
874
+ columns: string[];
875
+ isUnique: boolean;
876
+ using?: "btree" | "hash" | undefined;
877
+ algorithm?: "default" | "inplace" | "copy" | undefined;
878
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
879
+ }>;
880
+ foreignKeys: Record<string, {
881
+ name: string;
882
+ tableFrom: string;
883
+ columnsFrom: string[];
884
+ tableTo: string;
885
+ columnsTo: string[];
886
+ onUpdate?: string | undefined;
887
+ onDelete?: string | undefined;
888
+ }>;
889
+ compositePrimaryKeys: Record<string, {
890
+ name: string;
891
+ columns: string[];
892
+ }>;
893
+ uniqueConstraints: Record<string, {
894
+ name: string;
895
+ columns: string[];
896
+ }>;
897
+ checkConstraint: Record<string, {
898
+ value: string;
899
+ name: string;
900
+ }>;
901
+ }>;
902
+ views: Record<string, {
903
+ name: string;
904
+ columns: Record<string, {
905
+ type: string;
906
+ name: string;
907
+ primaryKey: boolean;
908
+ notNull: boolean;
909
+ default?: any;
910
+ generated?: {
911
+ type: "stored" | "virtual";
912
+ as: string;
913
+ } | undefined;
914
+ onUpdate?: any;
915
+ autoincrement?: boolean | undefined;
916
+ }>;
917
+ isExisting: boolean;
918
+ algorithm: "undefined" | "merge" | "temptable";
919
+ sqlSecurity: "definer" | "invoker";
920
+ definition?: string | undefined;
921
+ withCheckOption?: "local" | "cascaded" | undefined;
922
+ }>;
923
+ _meta: {
924
+ tables: Record<string, string>;
925
+ columns: Record<string, string>;
926
+ };
927
+ id: string;
928
+ prevId: string;
929
+ internal?: {
930
+ tables?: Record<string, {
931
+ columns: Record<string, {
932
+ isDefaultAnExpression?: boolean | undefined;
933
+ } | undefined>;
934
+ } | undefined> | undefined;
935
+ indexes?: Record<string, {
936
+ columns: Record<string, {
937
+ isExpression?: boolean | undefined;
938
+ } | undefined>;
939
+ } | undefined> | undefined;
940
+ } | undefined;
941
+ }, {
942
+ version: "5";
943
+ dialect: "mysql";
944
+ tables: Record<string, {
945
+ name: string;
946
+ columns: Record<string, {
947
+ type: string;
948
+ name: string;
949
+ primaryKey: boolean;
950
+ notNull: boolean;
951
+ default?: any;
952
+ generated?: {
953
+ type: "stored" | "virtual";
954
+ as: string;
955
+ } | undefined;
956
+ onUpdate?: any;
957
+ autoincrement?: boolean | undefined;
958
+ }>;
959
+ indexes: Record<string, {
960
+ name: string;
961
+ columns: string[];
962
+ isUnique: boolean;
963
+ using?: "btree" | "hash" | undefined;
964
+ algorithm?: "default" | "inplace" | "copy" | undefined;
965
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
966
+ }>;
967
+ foreignKeys: Record<string, {
968
+ name: string;
969
+ tableFrom: string;
970
+ columnsFrom: string[];
971
+ tableTo: string;
972
+ columnsTo: string[];
973
+ onUpdate?: string | undefined;
974
+ onDelete?: string | undefined;
975
+ }>;
976
+ compositePrimaryKeys: Record<string, {
977
+ name: string;
978
+ columns: string[];
979
+ }>;
980
+ uniqueConstraints?: Record<string, {
981
+ name: string;
982
+ columns: string[];
983
+ }> | undefined;
984
+ checkConstraint?: Record<string, {
985
+ value: string;
986
+ name: string;
987
+ }> | undefined;
988
+ }>;
989
+ _meta: {
990
+ tables: Record<string, string>;
991
+ columns: Record<string, string>;
992
+ };
993
+ id: string;
994
+ prevId: string;
995
+ views?: Record<string, {
996
+ name: string;
997
+ columns: Record<string, {
998
+ type: string;
999
+ name: string;
1000
+ primaryKey: boolean;
1001
+ notNull: boolean;
1002
+ default?: any;
1003
+ generated?: {
1004
+ type: "stored" | "virtual";
1005
+ as: string;
1006
+ } | undefined;
1007
+ onUpdate?: any;
1008
+ autoincrement?: boolean | undefined;
1009
+ }>;
1010
+ isExisting: boolean;
1011
+ algorithm: "undefined" | "merge" | "temptable";
1012
+ sqlSecurity: "definer" | "invoker";
1013
+ definition?: string | undefined;
1014
+ withCheckOption?: "local" | "cascaded" | undefined;
1015
+ }> | undefined;
1016
+ internal?: {
1017
+ tables?: Record<string, {
1018
+ columns: Record<string, {
1019
+ isDefaultAnExpression?: boolean | undefined;
1020
+ } | undefined>;
1021
+ } | undefined> | undefined;
1022
+ indexes?: Record<string, {
1023
+ columns: Record<string, {
1024
+ isExpression?: boolean | undefined;
1025
+ } | undefined>;
1026
+ } | undefined> | undefined;
1027
+ } | undefined;
1028
+ }>;
1029
+ type MySqlSchema = TypeOf<typeof schema$2>;
1030
+
1031
+ declare const pgSchema: zod.ZodObject<{
1032
+ version: zod.ZodLiteral<"7">;
1033
+ dialect: zod.ZodLiteral<"postgresql">;
1034
+ tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1035
+ name: zod.ZodString;
1036
+ schema: zod.ZodString;
1037
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1038
+ name: zod.ZodString;
1039
+ type: zod.ZodString;
1040
+ typeSchema: zod.ZodOptional<zod.ZodString>;
1041
+ primaryKey: zod.ZodBoolean;
1042
+ notNull: zod.ZodBoolean;
1043
+ default: zod.ZodOptional<zod.ZodAny>;
1044
+ isUnique: zod.ZodOptional<zod.ZodAny>;
1045
+ uniqueName: zod.ZodOptional<zod.ZodString>;
1046
+ nullsNotDistinct: zod.ZodOptional<zod.ZodBoolean>;
1047
+ generated: zod.ZodOptional<zod.ZodObject<{
1048
+ type: zod.ZodLiteral<"stored">;
1049
+ as: zod.ZodString;
1050
+ }, "strip", zod.ZodTypeAny, {
1051
+ type: "stored";
1052
+ as: string;
1053
+ }, {
1054
+ type: "stored";
1055
+ as: string;
1056
+ }>>;
1057
+ identity: zod.ZodOptional<zod.ZodObject<{
1058
+ name: zod.ZodString;
1059
+ increment: zod.ZodOptional<zod.ZodString>;
1060
+ minValue: zod.ZodOptional<zod.ZodString>;
1061
+ maxValue: zod.ZodOptional<zod.ZodString>;
1062
+ startWith: zod.ZodOptional<zod.ZodString>;
1063
+ cache: zod.ZodOptional<zod.ZodString>;
1064
+ cycle: zod.ZodOptional<zod.ZodBoolean>;
1065
+ schema: zod.ZodString;
1066
+ } & {
1067
+ type: zod.ZodEnum<["always", "byDefault"]>;
1068
+ }, "strip", zod.ZodTypeAny, {
1069
+ type: "always" | "byDefault";
1070
+ name: string;
1071
+ schema: string;
1072
+ increment?: string | undefined;
1073
+ minValue?: string | undefined;
1074
+ maxValue?: string | undefined;
1075
+ startWith?: string | undefined;
1076
+ cache?: string | undefined;
1077
+ cycle?: boolean | undefined;
1078
+ }, {
1079
+ type: "always" | "byDefault";
1080
+ name: string;
1081
+ schema: string;
1082
+ increment?: string | undefined;
1083
+ minValue?: string | undefined;
1084
+ maxValue?: string | undefined;
1085
+ startWith?: string | undefined;
1086
+ cache?: string | undefined;
1087
+ cycle?: boolean | undefined;
1088
+ }>>;
1089
+ }, "strict", zod.ZodTypeAny, {
1090
+ type: string;
1091
+ name: string;
1092
+ primaryKey: boolean;
1093
+ notNull: boolean;
1094
+ typeSchema?: string | undefined;
1095
+ default?: any;
1096
+ isUnique?: any;
1097
+ uniqueName?: string | undefined;
1098
+ nullsNotDistinct?: boolean | undefined;
1099
+ generated?: {
1100
+ type: "stored";
1101
+ as: string;
1102
+ } | undefined;
1103
+ identity?: {
1104
+ type: "always" | "byDefault";
1105
+ name: string;
1106
+ schema: string;
1107
+ increment?: string | undefined;
1108
+ minValue?: string | undefined;
1109
+ maxValue?: string | undefined;
1110
+ startWith?: string | undefined;
1111
+ cache?: string | undefined;
1112
+ cycle?: boolean | undefined;
1113
+ } | undefined;
1114
+ }, {
1115
+ type: string;
1116
+ name: string;
1117
+ primaryKey: boolean;
1118
+ notNull: boolean;
1119
+ typeSchema?: string | undefined;
1120
+ default?: any;
1121
+ isUnique?: any;
1122
+ uniqueName?: string | undefined;
1123
+ nullsNotDistinct?: boolean | undefined;
1124
+ generated?: {
1125
+ type: "stored";
1126
+ as: string;
1127
+ } | undefined;
1128
+ identity?: {
1129
+ type: "always" | "byDefault";
1130
+ name: string;
1131
+ schema: string;
1132
+ increment?: string | undefined;
1133
+ minValue?: string | undefined;
1134
+ maxValue?: string | undefined;
1135
+ startWith?: string | undefined;
1136
+ cache?: string | undefined;
1137
+ cycle?: boolean | undefined;
1138
+ } | undefined;
1139
+ }>>;
1140
+ indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1141
+ name: zod.ZodString;
1142
+ columns: zod.ZodArray<zod.ZodObject<{
1143
+ expression: zod.ZodString;
1144
+ isExpression: zod.ZodBoolean;
1145
+ asc: zod.ZodBoolean;
1146
+ nulls: zod.ZodOptional<zod.ZodString>;
1147
+ opclass: zod.ZodOptional<zod.ZodString>;
1148
+ }, "strip", zod.ZodTypeAny, {
1149
+ expression: string;
1150
+ isExpression: boolean;
1151
+ asc: boolean;
1152
+ nulls?: string | undefined;
1153
+ opclass?: string | undefined;
1154
+ }, {
1155
+ expression: string;
1156
+ isExpression: boolean;
1157
+ asc: boolean;
1158
+ nulls?: string | undefined;
1159
+ opclass?: string | undefined;
1160
+ }>, "many">;
1161
+ isUnique: zod.ZodBoolean;
1162
+ with: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodAny>>;
1163
+ method: zod.ZodDefault<zod.ZodString>;
1164
+ where: zod.ZodOptional<zod.ZodString>;
1165
+ concurrently: zod.ZodDefault<zod.ZodBoolean>;
1166
+ }, "strict", zod.ZodTypeAny, {
1167
+ name: string;
1168
+ columns: {
1169
+ expression: string;
1170
+ isExpression: boolean;
1171
+ asc: boolean;
1172
+ nulls?: string | undefined;
1173
+ opclass?: string | undefined;
1174
+ }[];
1175
+ isUnique: boolean;
1176
+ method: string;
1177
+ concurrently: boolean;
1178
+ with?: Record<string, any> | undefined;
1179
+ where?: string | undefined;
1180
+ }, {
1181
+ name: string;
1182
+ columns: {
1183
+ expression: string;
1184
+ isExpression: boolean;
1185
+ asc: boolean;
1186
+ nulls?: string | undefined;
1187
+ opclass?: string | undefined;
1188
+ }[];
1189
+ isUnique: boolean;
1190
+ with?: Record<string, any> | undefined;
1191
+ method?: string | undefined;
1192
+ where?: string | undefined;
1193
+ concurrently?: boolean | undefined;
1194
+ }>>;
1195
+ foreignKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1196
+ name: zod.ZodString;
1197
+ tableFrom: zod.ZodString;
1198
+ columnsFrom: zod.ZodArray<zod.ZodString, "many">;
1199
+ tableTo: zod.ZodString;
1200
+ schemaTo: zod.ZodOptional<zod.ZodString>;
1201
+ columnsTo: zod.ZodArray<zod.ZodString, "many">;
1202
+ onUpdate: zod.ZodOptional<zod.ZodString>;
1203
+ onDelete: zod.ZodOptional<zod.ZodString>;
1204
+ }, "strict", zod.ZodTypeAny, {
1205
+ name: string;
1206
+ tableFrom: string;
1207
+ columnsFrom: string[];
1208
+ tableTo: string;
1209
+ columnsTo: string[];
1210
+ schemaTo?: string | undefined;
1211
+ onUpdate?: string | undefined;
1212
+ onDelete?: string | undefined;
1213
+ }, {
1214
+ name: string;
1215
+ tableFrom: string;
1216
+ columnsFrom: string[];
1217
+ tableTo: string;
1218
+ columnsTo: string[];
1219
+ schemaTo?: string | undefined;
1220
+ onUpdate?: string | undefined;
1221
+ onDelete?: string | undefined;
1222
+ }>>;
1223
+ compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1224
+ name: zod.ZodString;
1225
+ columns: zod.ZodArray<zod.ZodString, "many">;
1226
+ }, "strict", zod.ZodTypeAny, {
1227
+ name: string;
1228
+ columns: string[];
1229
+ }, {
1230
+ name: string;
1231
+ columns: string[];
1232
+ }>>;
1233
+ uniqueConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1234
+ name: zod.ZodString;
1235
+ columns: zod.ZodArray<zod.ZodString, "many">;
1236
+ nullsNotDistinct: zod.ZodBoolean;
1237
+ }, "strict", zod.ZodTypeAny, {
1238
+ name: string;
1239
+ columns: string[];
1240
+ nullsNotDistinct: boolean;
1241
+ }, {
1242
+ name: string;
1243
+ columns: string[];
1244
+ nullsNotDistinct: boolean;
1245
+ }>>>;
1246
+ policies: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1247
+ name: zod.ZodString;
1248
+ as: zod.ZodOptional<zod.ZodEnum<["PERMISSIVE", "RESTRICTIVE"]>>;
1249
+ for: zod.ZodOptional<zod.ZodEnum<["ALL", "SELECT", "INSERT", "UPDATE", "DELETE"]>>;
1250
+ to: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
1251
+ using: zod.ZodOptional<zod.ZodString>;
1252
+ withCheck: zod.ZodOptional<zod.ZodString>;
1253
+ on: zod.ZodOptional<zod.ZodString>;
1254
+ schema: zod.ZodOptional<zod.ZodString>;
1255
+ }, "strict", zod.ZodTypeAny, {
1256
+ name: string;
1257
+ schema?: string | undefined;
1258
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1259
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1260
+ to?: string[] | undefined;
1261
+ using?: string | undefined;
1262
+ withCheck?: string | undefined;
1263
+ on?: string | undefined;
1264
+ }, {
1265
+ name: string;
1266
+ schema?: string | undefined;
1267
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1268
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1269
+ to?: string[] | undefined;
1270
+ using?: string | undefined;
1271
+ withCheck?: string | undefined;
1272
+ on?: string | undefined;
1273
+ }>>>;
1274
+ checkConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1275
+ name: zod.ZodString;
1276
+ value: zod.ZodString;
1277
+ }, "strict", zod.ZodTypeAny, {
1278
+ value: string;
1279
+ name: string;
1280
+ }, {
1281
+ value: string;
1282
+ name: string;
1283
+ }>>>;
1284
+ isRLSEnabled: zod.ZodDefault<zod.ZodBoolean>;
1285
+ }, "strict", zod.ZodTypeAny, {
1286
+ name: string;
1287
+ schema: string;
1288
+ columns: Record<string, {
1289
+ type: string;
1290
+ name: string;
1291
+ primaryKey: boolean;
1292
+ notNull: boolean;
1293
+ typeSchema?: string | undefined;
1294
+ default?: any;
1295
+ isUnique?: any;
1296
+ uniqueName?: string | undefined;
1297
+ nullsNotDistinct?: boolean | undefined;
1298
+ generated?: {
1299
+ type: "stored";
1300
+ as: string;
1301
+ } | undefined;
1302
+ identity?: {
1303
+ type: "always" | "byDefault";
1304
+ name: string;
1305
+ schema: string;
1306
+ increment?: string | undefined;
1307
+ minValue?: string | undefined;
1308
+ maxValue?: string | undefined;
1309
+ startWith?: string | undefined;
1310
+ cache?: string | undefined;
1311
+ cycle?: boolean | undefined;
1312
+ } | undefined;
1313
+ }>;
1314
+ indexes: Record<string, {
1315
+ name: string;
1316
+ columns: {
1317
+ expression: string;
1318
+ isExpression: boolean;
1319
+ asc: boolean;
1320
+ nulls?: string | undefined;
1321
+ opclass?: string | undefined;
1322
+ }[];
1323
+ isUnique: boolean;
1324
+ method: string;
1325
+ concurrently: boolean;
1326
+ with?: Record<string, any> | undefined;
1327
+ where?: string | undefined;
1328
+ }>;
1329
+ foreignKeys: Record<string, {
1330
+ name: string;
1331
+ tableFrom: string;
1332
+ columnsFrom: string[];
1333
+ tableTo: string;
1334
+ columnsTo: string[];
1335
+ schemaTo?: string | undefined;
1336
+ onUpdate?: string | undefined;
1337
+ onDelete?: string | undefined;
1338
+ }>;
1339
+ compositePrimaryKeys: Record<string, {
1340
+ name: string;
1341
+ columns: string[];
1342
+ }>;
1343
+ uniqueConstraints: Record<string, {
1344
+ name: string;
1345
+ columns: string[];
1346
+ nullsNotDistinct: boolean;
1347
+ }>;
1348
+ policies: Record<string, {
1349
+ name: string;
1350
+ schema?: string | undefined;
1351
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1352
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1353
+ to?: string[] | undefined;
1354
+ using?: string | undefined;
1355
+ withCheck?: string | undefined;
1356
+ on?: string | undefined;
1357
+ }>;
1358
+ checkConstraints: Record<string, {
1359
+ value: string;
1360
+ name: string;
1361
+ }>;
1362
+ isRLSEnabled: boolean;
1363
+ }, {
1364
+ name: string;
1365
+ schema: string;
1366
+ columns: Record<string, {
1367
+ type: string;
1368
+ name: string;
1369
+ primaryKey: boolean;
1370
+ notNull: boolean;
1371
+ typeSchema?: string | undefined;
1372
+ default?: any;
1373
+ isUnique?: any;
1374
+ uniqueName?: string | undefined;
1375
+ nullsNotDistinct?: boolean | undefined;
1376
+ generated?: {
1377
+ type: "stored";
1378
+ as: string;
1379
+ } | undefined;
1380
+ identity?: {
1381
+ type: "always" | "byDefault";
1382
+ name: string;
1383
+ schema: string;
1384
+ increment?: string | undefined;
1385
+ minValue?: string | undefined;
1386
+ maxValue?: string | undefined;
1387
+ startWith?: string | undefined;
1388
+ cache?: string | undefined;
1389
+ cycle?: boolean | undefined;
1390
+ } | undefined;
1391
+ }>;
1392
+ indexes: Record<string, {
1393
+ name: string;
1394
+ columns: {
1395
+ expression: string;
1396
+ isExpression: boolean;
1397
+ asc: boolean;
1398
+ nulls?: string | undefined;
1399
+ opclass?: string | undefined;
1400
+ }[];
1401
+ isUnique: boolean;
1402
+ with?: Record<string, any> | undefined;
1403
+ method?: string | undefined;
1404
+ where?: string | undefined;
1405
+ concurrently?: boolean | undefined;
1406
+ }>;
1407
+ foreignKeys: Record<string, {
1408
+ name: string;
1409
+ tableFrom: string;
1410
+ columnsFrom: string[];
1411
+ tableTo: string;
1412
+ columnsTo: string[];
1413
+ schemaTo?: string | undefined;
1414
+ onUpdate?: string | undefined;
1415
+ onDelete?: string | undefined;
1416
+ }>;
1417
+ compositePrimaryKeys: Record<string, {
1418
+ name: string;
1419
+ columns: string[];
1420
+ }>;
1421
+ uniqueConstraints?: Record<string, {
1422
+ name: string;
1423
+ columns: string[];
1424
+ nullsNotDistinct: boolean;
1425
+ }> | undefined;
1426
+ policies?: Record<string, {
1427
+ name: string;
1428
+ schema?: string | undefined;
1429
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1430
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1431
+ to?: string[] | undefined;
1432
+ using?: string | undefined;
1433
+ withCheck?: string | undefined;
1434
+ on?: string | undefined;
1435
+ }> | undefined;
1436
+ checkConstraints?: Record<string, {
1437
+ value: string;
1438
+ name: string;
1439
+ }> | undefined;
1440
+ isRLSEnabled?: boolean | undefined;
1441
+ }>>;
1442
+ enums: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1443
+ name: zod.ZodString;
1444
+ schema: zod.ZodString;
1445
+ values: zod.ZodArray<zod.ZodString, "many">;
1446
+ }, "strict", zod.ZodTypeAny, {
1447
+ values: string[];
1448
+ name: string;
1449
+ schema: string;
1450
+ }, {
1451
+ values: string[];
1452
+ name: string;
1453
+ schema: string;
1454
+ }>>;
1455
+ schemas: zod.ZodRecord<zod.ZodString, zod.ZodString>;
1456
+ views: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1457
+ name: zod.ZodString;
1458
+ schema: zod.ZodString;
1459
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1460
+ name: zod.ZodString;
1461
+ type: zod.ZodString;
1462
+ typeSchema: zod.ZodOptional<zod.ZodString>;
1463
+ primaryKey: zod.ZodBoolean;
1464
+ notNull: zod.ZodBoolean;
1465
+ default: zod.ZodOptional<zod.ZodAny>;
1466
+ isUnique: zod.ZodOptional<zod.ZodAny>;
1467
+ uniqueName: zod.ZodOptional<zod.ZodString>;
1468
+ nullsNotDistinct: zod.ZodOptional<zod.ZodBoolean>;
1469
+ generated: zod.ZodOptional<zod.ZodObject<{
1470
+ type: zod.ZodLiteral<"stored">;
1471
+ as: zod.ZodString;
1472
+ }, "strip", zod.ZodTypeAny, {
1473
+ type: "stored";
1474
+ as: string;
1475
+ }, {
1476
+ type: "stored";
1477
+ as: string;
1478
+ }>>;
1479
+ identity: zod.ZodOptional<zod.ZodObject<{
1480
+ name: zod.ZodString;
1481
+ increment: zod.ZodOptional<zod.ZodString>;
1482
+ minValue: zod.ZodOptional<zod.ZodString>;
1483
+ maxValue: zod.ZodOptional<zod.ZodString>;
1484
+ startWith: zod.ZodOptional<zod.ZodString>;
1485
+ cache: zod.ZodOptional<zod.ZodString>;
1486
+ cycle: zod.ZodOptional<zod.ZodBoolean>;
1487
+ schema: zod.ZodString;
1488
+ } & {
1489
+ type: zod.ZodEnum<["always", "byDefault"]>;
1490
+ }, "strip", zod.ZodTypeAny, {
1491
+ type: "always" | "byDefault";
1492
+ name: string;
1493
+ schema: string;
1494
+ increment?: string | undefined;
1495
+ minValue?: string | undefined;
1496
+ maxValue?: string | undefined;
1497
+ startWith?: string | undefined;
1498
+ cache?: string | undefined;
1499
+ cycle?: boolean | undefined;
1500
+ }, {
1501
+ type: "always" | "byDefault";
1502
+ name: string;
1503
+ schema: string;
1504
+ increment?: string | undefined;
1505
+ minValue?: string | undefined;
1506
+ maxValue?: string | undefined;
1507
+ startWith?: string | undefined;
1508
+ cache?: string | undefined;
1509
+ cycle?: boolean | undefined;
1510
+ }>>;
1511
+ }, "strict", zod.ZodTypeAny, {
1512
+ type: string;
1513
+ name: string;
1514
+ primaryKey: boolean;
1515
+ notNull: boolean;
1516
+ typeSchema?: string | undefined;
1517
+ default?: any;
1518
+ isUnique?: any;
1519
+ uniqueName?: string | undefined;
1520
+ nullsNotDistinct?: boolean | undefined;
1521
+ generated?: {
1522
+ type: "stored";
1523
+ as: string;
1524
+ } | undefined;
1525
+ identity?: {
1526
+ type: "always" | "byDefault";
1527
+ name: string;
1528
+ schema: string;
1529
+ increment?: string | undefined;
1530
+ minValue?: string | undefined;
1531
+ maxValue?: string | undefined;
1532
+ startWith?: string | undefined;
1533
+ cache?: string | undefined;
1534
+ cycle?: boolean | undefined;
1535
+ } | undefined;
1536
+ }, {
1537
+ type: string;
1538
+ name: string;
1539
+ primaryKey: boolean;
1540
+ notNull: boolean;
1541
+ typeSchema?: string | undefined;
1542
+ default?: any;
1543
+ isUnique?: any;
1544
+ uniqueName?: string | undefined;
1545
+ nullsNotDistinct?: boolean | undefined;
1546
+ generated?: {
1547
+ type: "stored";
1548
+ as: string;
1549
+ } | undefined;
1550
+ identity?: {
1551
+ type: "always" | "byDefault";
1552
+ name: string;
1553
+ schema: string;
1554
+ increment?: string | undefined;
1555
+ minValue?: string | undefined;
1556
+ maxValue?: string | undefined;
1557
+ startWith?: string | undefined;
1558
+ cache?: string | undefined;
1559
+ cycle?: boolean | undefined;
1560
+ } | undefined;
1561
+ }>>;
1562
+ definition: zod.ZodOptional<zod.ZodString>;
1563
+ materialized: zod.ZodBoolean;
1564
+ with: zod.ZodOptional<zod.ZodObject<{
1565
+ checkOption: zod.ZodOptional<zod.ZodEnum<["local", "cascaded"]>>;
1566
+ securityBarrier: zod.ZodOptional<zod.ZodBoolean>;
1567
+ securityInvoker: zod.ZodOptional<zod.ZodBoolean>;
1568
+ } & {
1569
+ fillfactor: zod.ZodOptional<zod.ZodNumber>;
1570
+ toastTupleTarget: zod.ZodOptional<zod.ZodNumber>;
1571
+ parallelWorkers: zod.ZodOptional<zod.ZodNumber>;
1572
+ autovacuumEnabled: zod.ZodOptional<zod.ZodBoolean>;
1573
+ vacuumIndexCleanup: zod.ZodOptional<zod.ZodEnum<["auto", "off", "on"]>>;
1574
+ vacuumTruncate: zod.ZodOptional<zod.ZodBoolean>;
1575
+ autovacuumVacuumThreshold: zod.ZodOptional<zod.ZodNumber>;
1576
+ autovacuumVacuumScaleFactor: zod.ZodOptional<zod.ZodNumber>;
1577
+ autovacuumVacuumCostDelay: zod.ZodOptional<zod.ZodNumber>;
1578
+ autovacuumVacuumCostLimit: zod.ZodOptional<zod.ZodNumber>;
1579
+ autovacuumFreezeMinAge: zod.ZodOptional<zod.ZodNumber>;
1580
+ autovacuumFreezeMaxAge: zod.ZodOptional<zod.ZodNumber>;
1581
+ autovacuumFreezeTableAge: zod.ZodOptional<zod.ZodNumber>;
1582
+ autovacuumMultixactFreezeMinAge: zod.ZodOptional<zod.ZodNumber>;
1583
+ autovacuumMultixactFreezeMaxAge: zod.ZodOptional<zod.ZodNumber>;
1584
+ autovacuumMultixactFreezeTableAge: zod.ZodOptional<zod.ZodNumber>;
1585
+ logAutovacuumMinDuration: zod.ZodOptional<zod.ZodNumber>;
1586
+ userCatalogTable: zod.ZodOptional<zod.ZodBoolean>;
1587
+ }, "strict", zod.ZodTypeAny, {
1588
+ checkOption?: "local" | "cascaded" | undefined;
1589
+ securityBarrier?: boolean | undefined;
1590
+ securityInvoker?: boolean | undefined;
1591
+ fillfactor?: number | undefined;
1592
+ toastTupleTarget?: number | undefined;
1593
+ parallelWorkers?: number | undefined;
1594
+ autovacuumEnabled?: boolean | undefined;
1595
+ vacuumIndexCleanup?: "on" | "auto" | "off" | undefined;
1596
+ vacuumTruncate?: boolean | undefined;
1597
+ autovacuumVacuumThreshold?: number | undefined;
1598
+ autovacuumVacuumScaleFactor?: number | undefined;
1599
+ autovacuumVacuumCostDelay?: number | undefined;
1600
+ autovacuumVacuumCostLimit?: number | undefined;
1601
+ autovacuumFreezeMinAge?: number | undefined;
1602
+ autovacuumFreezeMaxAge?: number | undefined;
1603
+ autovacuumFreezeTableAge?: number | undefined;
1604
+ autovacuumMultixactFreezeMinAge?: number | undefined;
1605
+ autovacuumMultixactFreezeMaxAge?: number | undefined;
1606
+ autovacuumMultixactFreezeTableAge?: number | undefined;
1607
+ logAutovacuumMinDuration?: number | undefined;
1608
+ userCatalogTable?: boolean | undefined;
1609
+ }, {
1610
+ checkOption?: "local" | "cascaded" | undefined;
1611
+ securityBarrier?: boolean | undefined;
1612
+ securityInvoker?: boolean | undefined;
1613
+ fillfactor?: number | undefined;
1614
+ toastTupleTarget?: number | undefined;
1615
+ parallelWorkers?: number | undefined;
1616
+ autovacuumEnabled?: boolean | undefined;
1617
+ vacuumIndexCleanup?: "on" | "auto" | "off" | undefined;
1618
+ vacuumTruncate?: boolean | undefined;
1619
+ autovacuumVacuumThreshold?: number | undefined;
1620
+ autovacuumVacuumScaleFactor?: number | undefined;
1621
+ autovacuumVacuumCostDelay?: number | undefined;
1622
+ autovacuumVacuumCostLimit?: number | undefined;
1623
+ autovacuumFreezeMinAge?: number | undefined;
1624
+ autovacuumFreezeMaxAge?: number | undefined;
1625
+ autovacuumFreezeTableAge?: number | undefined;
1626
+ autovacuumMultixactFreezeMinAge?: number | undefined;
1627
+ autovacuumMultixactFreezeMaxAge?: number | undefined;
1628
+ autovacuumMultixactFreezeTableAge?: number | undefined;
1629
+ logAutovacuumMinDuration?: number | undefined;
1630
+ userCatalogTable?: boolean | undefined;
1631
+ }>>;
1632
+ isExisting: zod.ZodBoolean;
1633
+ withNoData: zod.ZodOptional<zod.ZodBoolean>;
1634
+ using: zod.ZodOptional<zod.ZodString>;
1635
+ tablespace: zod.ZodOptional<zod.ZodString>;
1636
+ }, "strict", zod.ZodTypeAny, {
1637
+ name: string;
1638
+ schema: string;
1639
+ columns: Record<string, {
1640
+ type: string;
1641
+ name: string;
1642
+ primaryKey: boolean;
1643
+ notNull: boolean;
1644
+ typeSchema?: string | undefined;
1645
+ default?: any;
1646
+ isUnique?: any;
1647
+ uniqueName?: string | undefined;
1648
+ nullsNotDistinct?: boolean | undefined;
1649
+ generated?: {
1650
+ type: "stored";
1651
+ as: string;
1652
+ } | undefined;
1653
+ identity?: {
1654
+ type: "always" | "byDefault";
1655
+ name: string;
1656
+ schema: string;
1657
+ increment?: string | undefined;
1658
+ minValue?: string | undefined;
1659
+ maxValue?: string | undefined;
1660
+ startWith?: string | undefined;
1661
+ cache?: string | undefined;
1662
+ cycle?: boolean | undefined;
1663
+ } | undefined;
1664
+ }>;
1665
+ materialized: boolean;
1666
+ isExisting: boolean;
1667
+ with?: {
1668
+ checkOption?: "local" | "cascaded" | undefined;
1669
+ securityBarrier?: boolean | undefined;
1670
+ securityInvoker?: boolean | undefined;
1671
+ fillfactor?: number | undefined;
1672
+ toastTupleTarget?: number | undefined;
1673
+ parallelWorkers?: number | undefined;
1674
+ autovacuumEnabled?: boolean | undefined;
1675
+ vacuumIndexCleanup?: "on" | "auto" | "off" | undefined;
1676
+ vacuumTruncate?: boolean | undefined;
1677
+ autovacuumVacuumThreshold?: number | undefined;
1678
+ autovacuumVacuumScaleFactor?: number | undefined;
1679
+ autovacuumVacuumCostDelay?: number | undefined;
1680
+ autovacuumVacuumCostLimit?: number | undefined;
1681
+ autovacuumFreezeMinAge?: number | undefined;
1682
+ autovacuumFreezeMaxAge?: number | undefined;
1683
+ autovacuumFreezeTableAge?: number | undefined;
1684
+ autovacuumMultixactFreezeMinAge?: number | undefined;
1685
+ autovacuumMultixactFreezeMaxAge?: number | undefined;
1686
+ autovacuumMultixactFreezeTableAge?: number | undefined;
1687
+ logAutovacuumMinDuration?: number | undefined;
1688
+ userCatalogTable?: boolean | undefined;
1689
+ } | undefined;
1690
+ using?: string | undefined;
1691
+ definition?: string | undefined;
1692
+ withNoData?: boolean | undefined;
1693
+ tablespace?: string | undefined;
1694
+ }, {
1695
+ name: string;
1696
+ schema: string;
1697
+ columns: Record<string, {
1698
+ type: string;
1699
+ name: string;
1700
+ primaryKey: boolean;
1701
+ notNull: boolean;
1702
+ typeSchema?: string | undefined;
1703
+ default?: any;
1704
+ isUnique?: any;
1705
+ uniqueName?: string | undefined;
1706
+ nullsNotDistinct?: boolean | undefined;
1707
+ generated?: {
1708
+ type: "stored";
1709
+ as: string;
1710
+ } | undefined;
1711
+ identity?: {
1712
+ type: "always" | "byDefault";
1713
+ name: string;
1714
+ schema: string;
1715
+ increment?: string | undefined;
1716
+ minValue?: string | undefined;
1717
+ maxValue?: string | undefined;
1718
+ startWith?: string | undefined;
1719
+ cache?: string | undefined;
1720
+ cycle?: boolean | undefined;
1721
+ } | undefined;
1722
+ }>;
1723
+ materialized: boolean;
1724
+ isExisting: boolean;
1725
+ with?: {
1726
+ checkOption?: "local" | "cascaded" | undefined;
1727
+ securityBarrier?: boolean | undefined;
1728
+ securityInvoker?: boolean | undefined;
1729
+ fillfactor?: number | undefined;
1730
+ toastTupleTarget?: number | undefined;
1731
+ parallelWorkers?: number | undefined;
1732
+ autovacuumEnabled?: boolean | undefined;
1733
+ vacuumIndexCleanup?: "on" | "auto" | "off" | undefined;
1734
+ vacuumTruncate?: boolean | undefined;
1735
+ autovacuumVacuumThreshold?: number | undefined;
1736
+ autovacuumVacuumScaleFactor?: number | undefined;
1737
+ autovacuumVacuumCostDelay?: number | undefined;
1738
+ autovacuumVacuumCostLimit?: number | undefined;
1739
+ autovacuumFreezeMinAge?: number | undefined;
1740
+ autovacuumFreezeMaxAge?: number | undefined;
1741
+ autovacuumFreezeTableAge?: number | undefined;
1742
+ autovacuumMultixactFreezeMinAge?: number | undefined;
1743
+ autovacuumMultixactFreezeMaxAge?: number | undefined;
1744
+ autovacuumMultixactFreezeTableAge?: number | undefined;
1745
+ logAutovacuumMinDuration?: number | undefined;
1746
+ userCatalogTable?: boolean | undefined;
1747
+ } | undefined;
1748
+ using?: string | undefined;
1749
+ definition?: string | undefined;
1750
+ withNoData?: boolean | undefined;
1751
+ tablespace?: string | undefined;
1752
+ }>>>;
1753
+ sequences: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1754
+ name: zod.ZodString;
1755
+ increment: zod.ZodOptional<zod.ZodString>;
1756
+ minValue: zod.ZodOptional<zod.ZodString>;
1757
+ maxValue: zod.ZodOptional<zod.ZodString>;
1758
+ startWith: zod.ZodOptional<zod.ZodString>;
1759
+ cache: zod.ZodOptional<zod.ZodString>;
1760
+ cycle: zod.ZodOptional<zod.ZodBoolean>;
1761
+ schema: zod.ZodString;
1762
+ }, "strict", zod.ZodTypeAny, {
1763
+ name: string;
1764
+ schema: string;
1765
+ increment?: string | undefined;
1766
+ minValue?: string | undefined;
1767
+ maxValue?: string | undefined;
1768
+ startWith?: string | undefined;
1769
+ cache?: string | undefined;
1770
+ cycle?: boolean | undefined;
1771
+ }, {
1772
+ name: string;
1773
+ schema: string;
1774
+ increment?: string | undefined;
1775
+ minValue?: string | undefined;
1776
+ maxValue?: string | undefined;
1777
+ startWith?: string | undefined;
1778
+ cache?: string | undefined;
1779
+ cycle?: boolean | undefined;
1780
+ }>>>;
1781
+ roles: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1782
+ name: zod.ZodString;
1783
+ createDb: zod.ZodOptional<zod.ZodBoolean>;
1784
+ createRole: zod.ZodOptional<zod.ZodBoolean>;
1785
+ inherit: zod.ZodOptional<zod.ZodBoolean>;
1786
+ }, "strict", zod.ZodTypeAny, {
1787
+ name: string;
1788
+ createDb?: boolean | undefined;
1789
+ createRole?: boolean | undefined;
1790
+ inherit?: boolean | undefined;
1791
+ }, {
1792
+ name: string;
1793
+ createDb?: boolean | undefined;
1794
+ createRole?: boolean | undefined;
1795
+ inherit?: boolean | undefined;
1796
+ }>>>;
1797
+ policies: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1798
+ name: zod.ZodString;
1799
+ as: zod.ZodOptional<zod.ZodEnum<["PERMISSIVE", "RESTRICTIVE"]>>;
1800
+ for: zod.ZodOptional<zod.ZodEnum<["ALL", "SELECT", "INSERT", "UPDATE", "DELETE"]>>;
1801
+ to: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
1802
+ using: zod.ZodOptional<zod.ZodString>;
1803
+ withCheck: zod.ZodOptional<zod.ZodString>;
1804
+ on: zod.ZodOptional<zod.ZodString>;
1805
+ schema: zod.ZodOptional<zod.ZodString>;
1806
+ }, "strict", zod.ZodTypeAny, {
1807
+ name: string;
1808
+ schema?: string | undefined;
1809
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1810
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1811
+ to?: string[] | undefined;
1812
+ using?: string | undefined;
1813
+ withCheck?: string | undefined;
1814
+ on?: string | undefined;
1815
+ }, {
1816
+ name: string;
1817
+ schema?: string | undefined;
1818
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1819
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1820
+ to?: string[] | undefined;
1821
+ using?: string | undefined;
1822
+ withCheck?: string | undefined;
1823
+ on?: string | undefined;
1824
+ }>>>;
1825
+ _meta: zod.ZodObject<{
1826
+ schemas: zod.ZodRecord<zod.ZodString, zod.ZodString>;
1827
+ tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
1828
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
1829
+ }, "strip", zod.ZodTypeAny, {
1830
+ tables: Record<string, string>;
1831
+ columns: Record<string, string>;
1832
+ schemas: Record<string, string>;
1833
+ }, {
1834
+ tables: Record<string, string>;
1835
+ columns: Record<string, string>;
1836
+ schemas: Record<string, string>;
1837
+ }>;
1838
+ internal: zod.ZodOptional<zod.ZodObject<{
1839
+ tables: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
1840
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
1841
+ isArray: zod.ZodOptional<zod.ZodBoolean>;
1842
+ dimensions: zod.ZodOptional<zod.ZodNumber>;
1843
+ rawType: zod.ZodOptional<zod.ZodString>;
1844
+ isDefaultAnExpression: zod.ZodOptional<zod.ZodBoolean>;
1845
+ }, "strip", zod.ZodTypeAny, {
1846
+ isArray?: boolean | undefined;
1847
+ dimensions?: number | undefined;
1848
+ rawType?: string | undefined;
1849
+ isDefaultAnExpression?: boolean | undefined;
1850
+ }, {
1851
+ isArray?: boolean | undefined;
1852
+ dimensions?: number | undefined;
1853
+ rawType?: string | undefined;
1854
+ isDefaultAnExpression?: boolean | undefined;
1855
+ }>>>;
1856
+ }, "strip", zod.ZodTypeAny, {
1857
+ columns: Record<string, {
1858
+ isArray?: boolean | undefined;
1859
+ dimensions?: number | undefined;
1860
+ rawType?: string | undefined;
1861
+ isDefaultAnExpression?: boolean | undefined;
1862
+ } | undefined>;
1863
+ }, {
1864
+ columns: Record<string, {
1865
+ isArray?: boolean | undefined;
1866
+ dimensions?: number | undefined;
1867
+ rawType?: string | undefined;
1868
+ isDefaultAnExpression?: boolean | undefined;
1869
+ } | undefined>;
1870
+ }>>>;
1871
+ }, "strip", zod.ZodTypeAny, {
1872
+ tables: Record<string, {
1873
+ columns: Record<string, {
1874
+ isArray?: boolean | undefined;
1875
+ dimensions?: number | undefined;
1876
+ rawType?: string | undefined;
1877
+ isDefaultAnExpression?: boolean | undefined;
1878
+ } | undefined>;
1879
+ } | undefined>;
1880
+ }, {
1881
+ tables: Record<string, {
1882
+ columns: Record<string, {
1883
+ isArray?: boolean | undefined;
1884
+ dimensions?: number | undefined;
1885
+ rawType?: string | undefined;
1886
+ isDefaultAnExpression?: boolean | undefined;
1887
+ } | undefined>;
1888
+ } | undefined>;
1889
+ }>>;
1890
+ } & {
1891
+ id: zod.ZodString;
1892
+ prevId: zod.ZodString;
1893
+ }, "strip", zod.ZodTypeAny, {
1894
+ version: "7";
1895
+ dialect: "postgresql";
1896
+ tables: Record<string, {
1897
+ name: string;
1898
+ schema: string;
1899
+ columns: Record<string, {
1900
+ type: string;
1901
+ name: string;
1902
+ primaryKey: boolean;
1903
+ notNull: boolean;
1904
+ typeSchema?: string | undefined;
1905
+ default?: any;
1906
+ isUnique?: any;
1907
+ uniqueName?: string | undefined;
1908
+ nullsNotDistinct?: boolean | undefined;
1909
+ generated?: {
1910
+ type: "stored";
1911
+ as: string;
1912
+ } | undefined;
1913
+ identity?: {
1914
+ type: "always" | "byDefault";
1915
+ name: string;
1916
+ schema: string;
1917
+ increment?: string | undefined;
1918
+ minValue?: string | undefined;
1919
+ maxValue?: string | undefined;
1920
+ startWith?: string | undefined;
1921
+ cache?: string | undefined;
1922
+ cycle?: boolean | undefined;
1923
+ } | undefined;
1924
+ }>;
1925
+ indexes: Record<string, {
1926
+ name: string;
1927
+ columns: {
1928
+ expression: string;
1929
+ isExpression: boolean;
1930
+ asc: boolean;
1931
+ nulls?: string | undefined;
1932
+ opclass?: string | undefined;
1933
+ }[];
1934
+ isUnique: boolean;
1935
+ method: string;
1936
+ concurrently: boolean;
1937
+ with?: Record<string, any> | undefined;
1938
+ where?: string | undefined;
1939
+ }>;
1940
+ foreignKeys: Record<string, {
1941
+ name: string;
1942
+ tableFrom: string;
1943
+ columnsFrom: string[];
1944
+ tableTo: string;
1945
+ columnsTo: string[];
1946
+ schemaTo?: string | undefined;
1947
+ onUpdate?: string | undefined;
1948
+ onDelete?: string | undefined;
1949
+ }>;
1950
+ compositePrimaryKeys: Record<string, {
1951
+ name: string;
1952
+ columns: string[];
1953
+ }>;
1954
+ uniqueConstraints: Record<string, {
1955
+ name: string;
1956
+ columns: string[];
1957
+ nullsNotDistinct: boolean;
1958
+ }>;
1959
+ policies: Record<string, {
1960
+ name: string;
1961
+ schema?: string | undefined;
1962
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1963
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1964
+ to?: string[] | undefined;
1965
+ using?: string | undefined;
1966
+ withCheck?: string | undefined;
1967
+ on?: string | undefined;
1968
+ }>;
1969
+ checkConstraints: Record<string, {
1970
+ value: string;
1971
+ name: string;
1972
+ }>;
1973
+ isRLSEnabled: boolean;
1974
+ }>;
1975
+ policies: Record<string, {
1976
+ name: string;
1977
+ schema?: string | undefined;
1978
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1979
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1980
+ to?: string[] | undefined;
1981
+ using?: string | undefined;
1982
+ withCheck?: string | undefined;
1983
+ on?: string | undefined;
1984
+ }>;
1985
+ enums: Record<string, {
1986
+ values: string[];
1987
+ name: string;
1988
+ schema: string;
1989
+ }>;
1990
+ schemas: Record<string, string>;
1991
+ views: Record<string, {
1992
+ name: string;
1993
+ schema: string;
1994
+ columns: Record<string, {
1995
+ type: string;
1996
+ name: string;
1997
+ primaryKey: boolean;
1998
+ notNull: boolean;
1999
+ typeSchema?: string | undefined;
2000
+ default?: any;
2001
+ isUnique?: any;
2002
+ uniqueName?: string | undefined;
2003
+ nullsNotDistinct?: boolean | undefined;
2004
+ generated?: {
2005
+ type: "stored";
2006
+ as: string;
2007
+ } | undefined;
2008
+ identity?: {
2009
+ type: "always" | "byDefault";
2010
+ name: string;
2011
+ schema: string;
2012
+ increment?: string | undefined;
2013
+ minValue?: string | undefined;
2014
+ maxValue?: string | undefined;
2015
+ startWith?: string | undefined;
2016
+ cache?: string | undefined;
2017
+ cycle?: boolean | undefined;
2018
+ } | undefined;
2019
+ }>;
2020
+ materialized: boolean;
2021
+ isExisting: boolean;
2022
+ with?: {
2023
+ checkOption?: "local" | "cascaded" | undefined;
2024
+ securityBarrier?: boolean | undefined;
2025
+ securityInvoker?: boolean | undefined;
2026
+ fillfactor?: number | undefined;
2027
+ toastTupleTarget?: number | undefined;
2028
+ parallelWorkers?: number | undefined;
2029
+ autovacuumEnabled?: boolean | undefined;
2030
+ vacuumIndexCleanup?: "on" | "auto" | "off" | undefined;
2031
+ vacuumTruncate?: boolean | undefined;
2032
+ autovacuumVacuumThreshold?: number | undefined;
2033
+ autovacuumVacuumScaleFactor?: number | undefined;
2034
+ autovacuumVacuumCostDelay?: number | undefined;
2035
+ autovacuumVacuumCostLimit?: number | undefined;
2036
+ autovacuumFreezeMinAge?: number | undefined;
2037
+ autovacuumFreezeMaxAge?: number | undefined;
2038
+ autovacuumFreezeTableAge?: number | undefined;
2039
+ autovacuumMultixactFreezeMinAge?: number | undefined;
2040
+ autovacuumMultixactFreezeMaxAge?: number | undefined;
2041
+ autovacuumMultixactFreezeTableAge?: number | undefined;
2042
+ logAutovacuumMinDuration?: number | undefined;
2043
+ userCatalogTable?: boolean | undefined;
2044
+ } | undefined;
2045
+ using?: string | undefined;
2046
+ definition?: string | undefined;
2047
+ withNoData?: boolean | undefined;
2048
+ tablespace?: string | undefined;
2049
+ }>;
2050
+ sequences: Record<string, {
2051
+ name: string;
2052
+ schema: string;
2053
+ increment?: string | undefined;
2054
+ minValue?: string | undefined;
2055
+ maxValue?: string | undefined;
2056
+ startWith?: string | undefined;
2057
+ cache?: string | undefined;
2058
+ cycle?: boolean | undefined;
2059
+ }>;
2060
+ roles: Record<string, {
2061
+ name: string;
2062
+ createDb?: boolean | undefined;
2063
+ createRole?: boolean | undefined;
2064
+ inherit?: boolean | undefined;
2065
+ }>;
2066
+ _meta: {
2067
+ tables: Record<string, string>;
2068
+ columns: Record<string, string>;
2069
+ schemas: Record<string, string>;
2070
+ };
2071
+ id: string;
2072
+ prevId: string;
2073
+ internal?: {
2074
+ tables: Record<string, {
2075
+ columns: Record<string, {
2076
+ isArray?: boolean | undefined;
2077
+ dimensions?: number | undefined;
2078
+ rawType?: string | undefined;
2079
+ isDefaultAnExpression?: boolean | undefined;
2080
+ } | undefined>;
2081
+ } | undefined>;
2082
+ } | undefined;
2083
+ }, {
2084
+ version: "7";
2085
+ dialect: "postgresql";
2086
+ tables: Record<string, {
2087
+ name: string;
2088
+ schema: string;
2089
+ columns: Record<string, {
2090
+ type: string;
2091
+ name: string;
2092
+ primaryKey: boolean;
2093
+ notNull: boolean;
2094
+ typeSchema?: string | undefined;
2095
+ default?: any;
2096
+ isUnique?: any;
2097
+ uniqueName?: string | undefined;
2098
+ nullsNotDistinct?: boolean | undefined;
2099
+ generated?: {
2100
+ type: "stored";
2101
+ as: string;
2102
+ } | undefined;
2103
+ identity?: {
2104
+ type: "always" | "byDefault";
2105
+ name: string;
2106
+ schema: string;
2107
+ increment?: string | undefined;
2108
+ minValue?: string | undefined;
2109
+ maxValue?: string | undefined;
2110
+ startWith?: string | undefined;
2111
+ cache?: string | undefined;
2112
+ cycle?: boolean | undefined;
2113
+ } | undefined;
2114
+ }>;
2115
+ indexes: Record<string, {
2116
+ name: string;
2117
+ columns: {
2118
+ expression: string;
2119
+ isExpression: boolean;
2120
+ asc: boolean;
2121
+ nulls?: string | undefined;
2122
+ opclass?: string | undefined;
2123
+ }[];
2124
+ isUnique: boolean;
2125
+ with?: Record<string, any> | undefined;
2126
+ method?: string | undefined;
2127
+ where?: string | undefined;
2128
+ concurrently?: boolean | undefined;
2129
+ }>;
2130
+ foreignKeys: Record<string, {
2131
+ name: string;
2132
+ tableFrom: string;
2133
+ columnsFrom: string[];
2134
+ tableTo: string;
2135
+ columnsTo: string[];
2136
+ schemaTo?: string | undefined;
2137
+ onUpdate?: string | undefined;
2138
+ onDelete?: string | undefined;
2139
+ }>;
2140
+ compositePrimaryKeys: Record<string, {
2141
+ name: string;
2142
+ columns: string[];
2143
+ }>;
2144
+ uniqueConstraints?: Record<string, {
2145
+ name: string;
2146
+ columns: string[];
2147
+ nullsNotDistinct: boolean;
2148
+ }> | undefined;
2149
+ policies?: Record<string, {
2150
+ name: string;
2151
+ schema?: string | undefined;
2152
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
2153
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
2154
+ to?: string[] | undefined;
2155
+ using?: string | undefined;
2156
+ withCheck?: string | undefined;
2157
+ on?: string | undefined;
2158
+ }> | undefined;
2159
+ checkConstraints?: Record<string, {
2160
+ value: string;
2161
+ name: string;
2162
+ }> | undefined;
2163
+ isRLSEnabled?: boolean | undefined;
2164
+ }>;
2165
+ enums: Record<string, {
2166
+ values: string[];
2167
+ name: string;
2168
+ schema: string;
2169
+ }>;
2170
+ schemas: Record<string, string>;
2171
+ _meta: {
2172
+ tables: Record<string, string>;
2173
+ columns: Record<string, string>;
2174
+ schemas: Record<string, string>;
2175
+ };
2176
+ id: string;
2177
+ prevId: string;
2178
+ policies?: Record<string, {
2179
+ name: string;
2180
+ schema?: string | undefined;
2181
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
2182
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
2183
+ to?: string[] | undefined;
2184
+ using?: string | undefined;
2185
+ withCheck?: string | undefined;
2186
+ on?: string | undefined;
2187
+ }> | undefined;
2188
+ views?: Record<string, {
2189
+ name: string;
2190
+ schema: string;
2191
+ columns: Record<string, {
2192
+ type: string;
2193
+ name: string;
2194
+ primaryKey: boolean;
2195
+ notNull: boolean;
2196
+ typeSchema?: string | undefined;
2197
+ default?: any;
2198
+ isUnique?: any;
2199
+ uniqueName?: string | undefined;
2200
+ nullsNotDistinct?: boolean | undefined;
2201
+ generated?: {
2202
+ type: "stored";
2203
+ as: string;
2204
+ } | undefined;
2205
+ identity?: {
2206
+ type: "always" | "byDefault";
2207
+ name: string;
2208
+ schema: string;
2209
+ increment?: string | undefined;
2210
+ minValue?: string | undefined;
2211
+ maxValue?: string | undefined;
2212
+ startWith?: string | undefined;
2213
+ cache?: string | undefined;
2214
+ cycle?: boolean | undefined;
2215
+ } | undefined;
2216
+ }>;
2217
+ materialized: boolean;
2218
+ isExisting: boolean;
2219
+ with?: {
2220
+ checkOption?: "local" | "cascaded" | undefined;
2221
+ securityBarrier?: boolean | undefined;
2222
+ securityInvoker?: boolean | undefined;
2223
+ fillfactor?: number | undefined;
2224
+ toastTupleTarget?: number | undefined;
2225
+ parallelWorkers?: number | undefined;
2226
+ autovacuumEnabled?: boolean | undefined;
2227
+ vacuumIndexCleanup?: "on" | "auto" | "off" | undefined;
2228
+ vacuumTruncate?: boolean | undefined;
2229
+ autovacuumVacuumThreshold?: number | undefined;
2230
+ autovacuumVacuumScaleFactor?: number | undefined;
2231
+ autovacuumVacuumCostDelay?: number | undefined;
2232
+ autovacuumVacuumCostLimit?: number | undefined;
2233
+ autovacuumFreezeMinAge?: number | undefined;
2234
+ autovacuumFreezeMaxAge?: number | undefined;
2235
+ autovacuumFreezeTableAge?: number | undefined;
2236
+ autovacuumMultixactFreezeMinAge?: number | undefined;
2237
+ autovacuumMultixactFreezeMaxAge?: number | undefined;
2238
+ autovacuumMultixactFreezeTableAge?: number | undefined;
2239
+ logAutovacuumMinDuration?: number | undefined;
2240
+ userCatalogTable?: boolean | undefined;
2241
+ } | undefined;
2242
+ using?: string | undefined;
2243
+ definition?: string | undefined;
2244
+ withNoData?: boolean | undefined;
2245
+ tablespace?: string | undefined;
2246
+ }> | undefined;
2247
+ sequences?: Record<string, {
2248
+ name: string;
2249
+ schema: string;
2250
+ increment?: string | undefined;
2251
+ minValue?: string | undefined;
2252
+ maxValue?: string | undefined;
2253
+ startWith?: string | undefined;
2254
+ cache?: string | undefined;
2255
+ cycle?: boolean | undefined;
2256
+ }> | undefined;
2257
+ roles?: Record<string, {
2258
+ name: string;
2259
+ createDb?: boolean | undefined;
2260
+ createRole?: boolean | undefined;
2261
+ inherit?: boolean | undefined;
2262
+ }> | undefined;
2263
+ internal?: {
2264
+ tables: Record<string, {
2265
+ columns: Record<string, {
2266
+ isArray?: boolean | undefined;
2267
+ dimensions?: number | undefined;
2268
+ rawType?: string | undefined;
2269
+ isDefaultAnExpression?: boolean | undefined;
2270
+ } | undefined>;
2271
+ } | undefined>;
2272
+ } | undefined;
2273
+ }>;
2274
+ type PgSchema = TypeOf<typeof pgSchema>;
2275
+
2276
+ declare const schema$1: zod.ZodObject<{
2277
+ version: zod.ZodLiteral<"1">;
2278
+ dialect: zod.ZodLiteral<"singlestore">;
2279
+ tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
2280
+ name: zod.ZodString;
2281
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
2282
+ name: zod.ZodString;
2283
+ type: zod.ZodString;
2284
+ primaryKey: zod.ZodBoolean;
2285
+ notNull: zod.ZodBoolean;
2286
+ autoincrement: zod.ZodOptional<zod.ZodBoolean>;
2287
+ default: zod.ZodOptional<zod.ZodAny>;
2288
+ onUpdate: zod.ZodOptional<zod.ZodAny>;
2289
+ generated: zod.ZodOptional<zod.ZodObject<{
2290
+ type: zod.ZodEnum<["stored", "virtual"]>;
2291
+ as: zod.ZodString;
2292
+ }, "strip", zod.ZodTypeAny, {
2293
+ type: "stored" | "virtual";
2294
+ as: string;
2295
+ }, {
2296
+ type: "stored" | "virtual";
2297
+ as: string;
2298
+ }>>;
2299
+ }, "strict", zod.ZodTypeAny, {
2300
+ type: string;
2301
+ name: string;
2302
+ primaryKey: boolean;
2303
+ notNull: boolean;
2304
+ default?: any;
2305
+ generated?: {
2306
+ type: "stored" | "virtual";
2307
+ as: string;
2308
+ } | undefined;
2309
+ onUpdate?: any;
2310
+ autoincrement?: boolean | undefined;
2311
+ }, {
2312
+ type: string;
2313
+ name: string;
2314
+ primaryKey: boolean;
2315
+ notNull: boolean;
2316
+ default?: any;
2317
+ generated?: {
2318
+ type: "stored" | "virtual";
2319
+ as: string;
2320
+ } | undefined;
2321
+ onUpdate?: any;
2322
+ autoincrement?: boolean | undefined;
2323
+ }>>;
2324
+ indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
2325
+ name: zod.ZodString;
2326
+ columns: zod.ZodArray<zod.ZodString, "many">;
2327
+ isUnique: zod.ZodBoolean;
2328
+ using: zod.ZodOptional<zod.ZodEnum<["btree", "hash"]>>;
2329
+ algorithm: zod.ZodOptional<zod.ZodEnum<["default", "inplace", "copy"]>>;
2330
+ lock: zod.ZodOptional<zod.ZodEnum<["default", "none", "shared", "exclusive"]>>;
2331
+ }, "strict", zod.ZodTypeAny, {
2332
+ name: string;
2333
+ columns: string[];
2334
+ isUnique: boolean;
2335
+ using?: "btree" | "hash" | undefined;
2336
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2337
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2338
+ }, {
2339
+ name: string;
2340
+ columns: string[];
2341
+ isUnique: boolean;
2342
+ using?: "btree" | "hash" | undefined;
2343
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2344
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2345
+ }>>;
2346
+ compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
2347
+ name: zod.ZodString;
2348
+ columns: zod.ZodArray<zod.ZodString, "many">;
2349
+ }, "strict", zod.ZodTypeAny, {
2350
+ name: string;
2351
+ columns: string[];
2352
+ }, {
2353
+ name: string;
2354
+ columns: string[];
2355
+ }>>;
2356
+ uniqueConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
2357
+ name: zod.ZodString;
2358
+ columns: zod.ZodArray<zod.ZodString, "many">;
2359
+ }, "strict", zod.ZodTypeAny, {
2360
+ name: string;
2361
+ columns: string[];
2362
+ }, {
2363
+ name: string;
2364
+ columns: string[];
2365
+ }>>>;
2366
+ }, "strict", zod.ZodTypeAny, {
2367
+ name: string;
2368
+ columns: Record<string, {
2369
+ type: string;
2370
+ name: string;
2371
+ primaryKey: boolean;
2372
+ notNull: boolean;
2373
+ default?: any;
2374
+ generated?: {
2375
+ type: "stored" | "virtual";
2376
+ as: string;
2377
+ } | undefined;
2378
+ onUpdate?: any;
2379
+ autoincrement?: boolean | undefined;
2380
+ }>;
2381
+ indexes: Record<string, {
2382
+ name: string;
2383
+ columns: string[];
2384
+ isUnique: boolean;
2385
+ using?: "btree" | "hash" | undefined;
2386
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2387
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2388
+ }>;
2389
+ compositePrimaryKeys: Record<string, {
2390
+ name: string;
2391
+ columns: string[];
2392
+ }>;
2393
+ uniqueConstraints: Record<string, {
2394
+ name: string;
2395
+ columns: string[];
2396
+ }>;
2397
+ }, {
2398
+ name: string;
2399
+ columns: Record<string, {
2400
+ type: string;
2401
+ name: string;
2402
+ primaryKey: boolean;
2403
+ notNull: boolean;
2404
+ default?: any;
2405
+ generated?: {
2406
+ type: "stored" | "virtual";
2407
+ as: string;
2408
+ } | undefined;
2409
+ onUpdate?: any;
2410
+ autoincrement?: boolean | undefined;
2411
+ }>;
2412
+ indexes: Record<string, {
2413
+ name: string;
2414
+ columns: string[];
2415
+ isUnique: boolean;
2416
+ using?: "btree" | "hash" | undefined;
2417
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2418
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2419
+ }>;
2420
+ compositePrimaryKeys: Record<string, {
2421
+ name: string;
2422
+ columns: string[];
2423
+ }>;
2424
+ uniqueConstraints?: Record<string, {
2425
+ name: string;
2426
+ columns: string[];
2427
+ }> | undefined;
2428
+ }>>;
2429
+ _meta: zod.ZodObject<{
2430
+ tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
2431
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
2432
+ }, "strip", zod.ZodTypeAny, {
2433
+ tables: Record<string, string>;
2434
+ columns: Record<string, string>;
2435
+ }, {
2436
+ tables: Record<string, string>;
2437
+ columns: Record<string, string>;
2438
+ }>;
2439
+ internal: zod.ZodOptional<zod.ZodObject<{
2440
+ tables: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
2441
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
2442
+ isDefaultAnExpression: zod.ZodOptional<zod.ZodBoolean>;
2443
+ }, "strip", zod.ZodTypeAny, {
2444
+ isDefaultAnExpression?: boolean | undefined;
2445
+ }, {
2446
+ isDefaultAnExpression?: boolean | undefined;
2447
+ }>>>;
2448
+ }, "strip", zod.ZodTypeAny, {
2449
+ columns: Record<string, {
2450
+ isDefaultAnExpression?: boolean | undefined;
2451
+ } | undefined>;
2452
+ }, {
2453
+ columns: Record<string, {
2454
+ isDefaultAnExpression?: boolean | undefined;
2455
+ } | undefined>;
2456
+ }>>>>;
2457
+ indexes: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
2458
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
2459
+ isExpression: zod.ZodOptional<zod.ZodBoolean>;
2460
+ }, "strip", zod.ZodTypeAny, {
2461
+ isExpression?: boolean | undefined;
2462
+ }, {
2463
+ isExpression?: boolean | undefined;
2464
+ }>>>;
2465
+ }, "strip", zod.ZodTypeAny, {
2466
+ columns: Record<string, {
2467
+ isExpression?: boolean | undefined;
2468
+ } | undefined>;
2469
+ }, {
2470
+ columns: Record<string, {
2471
+ isExpression?: boolean | undefined;
2472
+ } | undefined>;
2473
+ }>>>>;
2474
+ }, "strip", zod.ZodTypeAny, {
2475
+ tables?: Record<string, {
2476
+ columns: Record<string, {
2477
+ isDefaultAnExpression?: boolean | undefined;
2478
+ } | undefined>;
2479
+ } | undefined> | undefined;
2480
+ indexes?: Record<string, {
2481
+ columns: Record<string, {
2482
+ isExpression?: boolean | undefined;
2483
+ } | undefined>;
2484
+ } | undefined> | undefined;
2485
+ }, {
2486
+ tables?: Record<string, {
2487
+ columns: Record<string, {
2488
+ isDefaultAnExpression?: boolean | undefined;
2489
+ } | undefined>;
2490
+ } | undefined> | undefined;
2491
+ indexes?: Record<string, {
2492
+ columns: Record<string, {
2493
+ isExpression?: boolean | undefined;
2494
+ } | undefined>;
2495
+ } | undefined> | undefined;
2496
+ }>>;
2497
+ } & {
2498
+ id: zod.ZodString;
2499
+ prevId: zod.ZodString;
2500
+ }, "strip", zod.ZodTypeAny, {
2501
+ version: "1";
2502
+ dialect: "singlestore";
2503
+ tables: Record<string, {
2504
+ name: string;
2505
+ columns: Record<string, {
2506
+ type: string;
2507
+ name: string;
2508
+ primaryKey: boolean;
2509
+ notNull: boolean;
2510
+ default?: any;
2511
+ generated?: {
2512
+ type: "stored" | "virtual";
2513
+ as: string;
2514
+ } | undefined;
2515
+ onUpdate?: any;
2516
+ autoincrement?: boolean | undefined;
2517
+ }>;
2518
+ indexes: Record<string, {
2519
+ name: string;
2520
+ columns: string[];
2521
+ isUnique: boolean;
2522
+ using?: "btree" | "hash" | undefined;
2523
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2524
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2525
+ }>;
2526
+ compositePrimaryKeys: Record<string, {
2527
+ name: string;
2528
+ columns: string[];
2529
+ }>;
2530
+ uniqueConstraints: Record<string, {
2531
+ name: string;
2532
+ columns: string[];
2533
+ }>;
2534
+ }>;
2535
+ _meta: {
2536
+ tables: Record<string, string>;
2537
+ columns: Record<string, string>;
2538
+ };
2539
+ id: string;
2540
+ prevId: string;
2541
+ internal?: {
2542
+ tables?: Record<string, {
2543
+ columns: Record<string, {
2544
+ isDefaultAnExpression?: boolean | undefined;
2545
+ } | undefined>;
2546
+ } | undefined> | undefined;
2547
+ indexes?: Record<string, {
2548
+ columns: Record<string, {
2549
+ isExpression?: boolean | undefined;
2550
+ } | undefined>;
2551
+ } | undefined> | undefined;
2552
+ } | undefined;
2553
+ }, {
2554
+ version: "1";
2555
+ dialect: "singlestore";
2556
+ tables: Record<string, {
2557
+ name: string;
2558
+ columns: Record<string, {
2559
+ type: string;
2560
+ name: string;
2561
+ primaryKey: boolean;
2562
+ notNull: boolean;
2563
+ default?: any;
2564
+ generated?: {
2565
+ type: "stored" | "virtual";
2566
+ as: string;
2567
+ } | undefined;
2568
+ onUpdate?: any;
2569
+ autoincrement?: boolean | undefined;
2570
+ }>;
2571
+ indexes: Record<string, {
2572
+ name: string;
2573
+ columns: string[];
2574
+ isUnique: boolean;
2575
+ using?: "btree" | "hash" | undefined;
2576
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2577
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2578
+ }>;
2579
+ compositePrimaryKeys: Record<string, {
2580
+ name: string;
2581
+ columns: string[];
2582
+ }>;
2583
+ uniqueConstraints?: Record<string, {
2584
+ name: string;
2585
+ columns: string[];
2586
+ }> | undefined;
2587
+ }>;
2588
+ _meta: {
2589
+ tables: Record<string, string>;
2590
+ columns: Record<string, string>;
2591
+ };
2592
+ id: string;
2593
+ prevId: string;
2594
+ internal?: {
2595
+ tables?: Record<string, {
2596
+ columns: Record<string, {
2597
+ isDefaultAnExpression?: boolean | undefined;
2598
+ } | undefined>;
2599
+ } | undefined> | undefined;
2600
+ indexes?: Record<string, {
2601
+ columns: Record<string, {
2602
+ isExpression?: boolean | undefined;
2603
+ } | undefined>;
2604
+ } | undefined> | undefined;
2605
+ } | undefined;
2606
+ }>;
2607
+ type SingleStoreSchema = TypeOf<typeof schema$1>;
2608
+
2609
+ declare const schema: zod.ZodObject<{
2610
+ version: zod.ZodLiteral<"6">;
2611
+ dialect: zod.ZodEnum<["sqlite"]>;
2612
+ tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
2613
+ name: zod.ZodString;
2614
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
2615
+ name: zod.ZodString;
2616
+ type: zod.ZodString;
2617
+ primaryKey: zod.ZodBoolean;
2618
+ notNull: zod.ZodBoolean;
2619
+ autoincrement: zod.ZodOptional<zod.ZodBoolean>;
2620
+ default: zod.ZodOptional<zod.ZodAny>;
2621
+ generated: zod.ZodOptional<zod.ZodObject<{
2622
+ type: zod.ZodEnum<["stored", "virtual"]>;
2623
+ as: zod.ZodString;
2624
+ }, "strip", zod.ZodTypeAny, {
2625
+ type: "stored" | "virtual";
2626
+ as: string;
2627
+ }, {
2628
+ type: "stored" | "virtual";
2629
+ as: string;
2630
+ }>>;
2631
+ }, "strict", zod.ZodTypeAny, {
2632
+ type: string;
2633
+ name: string;
2634
+ primaryKey: boolean;
2635
+ notNull: boolean;
2636
+ default?: any;
2637
+ generated?: {
2638
+ type: "stored" | "virtual";
2639
+ as: string;
2640
+ } | undefined;
2641
+ autoincrement?: boolean | undefined;
2642
+ }, {
2643
+ type: string;
2644
+ name: string;
2645
+ primaryKey: boolean;
2646
+ notNull: boolean;
2647
+ default?: any;
2648
+ generated?: {
2649
+ type: "stored" | "virtual";
2650
+ as: string;
2651
+ } | undefined;
2652
+ autoincrement?: boolean | undefined;
2653
+ }>>;
2654
+ indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
2655
+ name: zod.ZodString;
2656
+ columns: zod.ZodArray<zod.ZodString, "many">;
2657
+ where: zod.ZodOptional<zod.ZodString>;
2658
+ isUnique: zod.ZodBoolean;
2659
+ }, "strict", zod.ZodTypeAny, {
2660
+ name: string;
2661
+ columns: string[];
2662
+ isUnique: boolean;
2663
+ where?: string | undefined;
2664
+ }, {
2665
+ name: string;
2666
+ columns: string[];
2667
+ isUnique: boolean;
2668
+ where?: string | undefined;
2669
+ }>>;
2670
+ foreignKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
2671
+ name: zod.ZodString;
2672
+ tableFrom: zod.ZodString;
2673
+ columnsFrom: zod.ZodArray<zod.ZodString, "many">;
2674
+ tableTo: zod.ZodString;
2675
+ columnsTo: zod.ZodArray<zod.ZodString, "many">;
2676
+ onUpdate: zod.ZodOptional<zod.ZodString>;
2677
+ onDelete: zod.ZodOptional<zod.ZodString>;
2678
+ }, "strict", zod.ZodTypeAny, {
2679
+ name: string;
2680
+ tableFrom: string;
2681
+ columnsFrom: string[];
2682
+ tableTo: string;
2683
+ columnsTo: string[];
2684
+ onUpdate?: string | undefined;
2685
+ onDelete?: string | undefined;
2686
+ }, {
2687
+ name: string;
2688
+ tableFrom: string;
2689
+ columnsFrom: string[];
2690
+ tableTo: string;
2691
+ columnsTo: string[];
2692
+ onUpdate?: string | undefined;
2693
+ onDelete?: string | undefined;
2694
+ }>>;
2695
+ compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
2696
+ columns: zod.ZodArray<zod.ZodString, "many">;
2697
+ name: zod.ZodOptional<zod.ZodString>;
2698
+ }, "strict", zod.ZodTypeAny, {
2699
+ columns: string[];
2700
+ name?: string | undefined;
2701
+ }, {
2702
+ columns: string[];
2703
+ name?: string | undefined;
2704
+ }>>;
2705
+ uniqueConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
2706
+ name: zod.ZodString;
2707
+ columns: zod.ZodArray<zod.ZodString, "many">;
2708
+ }, "strict", zod.ZodTypeAny, {
2709
+ name: string;
2710
+ columns: string[];
2711
+ }, {
2712
+ name: string;
2713
+ columns: string[];
2714
+ }>>>;
2715
+ checkConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
2716
+ name: zod.ZodString;
2717
+ value: zod.ZodString;
2718
+ }, "strict", zod.ZodTypeAny, {
2719
+ value: string;
2720
+ name: string;
2721
+ }, {
2722
+ value: string;
2723
+ name: string;
2724
+ }>>>;
2725
+ }, "strict", zod.ZodTypeAny, {
2726
+ name: string;
2727
+ columns: Record<string, {
2728
+ type: string;
2729
+ name: string;
2730
+ primaryKey: boolean;
2731
+ notNull: boolean;
2732
+ default?: any;
2733
+ generated?: {
2734
+ type: "stored" | "virtual";
2735
+ as: string;
2736
+ } | undefined;
2737
+ autoincrement?: boolean | undefined;
2738
+ }>;
2739
+ indexes: Record<string, {
2740
+ name: string;
2741
+ columns: string[];
2742
+ isUnique: boolean;
2743
+ where?: string | undefined;
2744
+ }>;
2745
+ foreignKeys: Record<string, {
2746
+ name: string;
2747
+ tableFrom: string;
2748
+ columnsFrom: string[];
2749
+ tableTo: string;
2750
+ columnsTo: string[];
2751
+ onUpdate?: string | undefined;
2752
+ onDelete?: string | undefined;
2753
+ }>;
2754
+ compositePrimaryKeys: Record<string, {
2755
+ columns: string[];
2756
+ name?: string | undefined;
2757
+ }>;
2758
+ uniqueConstraints: Record<string, {
2759
+ name: string;
2760
+ columns: string[];
2761
+ }>;
2762
+ checkConstraints: Record<string, {
2763
+ value: string;
2764
+ name: string;
2765
+ }>;
2766
+ }, {
2767
+ name: string;
2768
+ columns: Record<string, {
2769
+ type: string;
2770
+ name: string;
2771
+ primaryKey: boolean;
2772
+ notNull: boolean;
2773
+ default?: any;
2774
+ generated?: {
2775
+ type: "stored" | "virtual";
2776
+ as: string;
2777
+ } | undefined;
2778
+ autoincrement?: boolean | undefined;
2779
+ }>;
2780
+ indexes: Record<string, {
2781
+ name: string;
2782
+ columns: string[];
2783
+ isUnique: boolean;
2784
+ where?: string | undefined;
2785
+ }>;
2786
+ foreignKeys: Record<string, {
2787
+ name: string;
2788
+ tableFrom: string;
2789
+ columnsFrom: string[];
2790
+ tableTo: string;
2791
+ columnsTo: string[];
2792
+ onUpdate?: string | undefined;
2793
+ onDelete?: string | undefined;
2794
+ }>;
2795
+ compositePrimaryKeys: Record<string, {
2796
+ columns: string[];
2797
+ name?: string | undefined;
2798
+ }>;
2799
+ uniqueConstraints?: Record<string, {
2800
+ name: string;
2801
+ columns: string[];
2802
+ }> | undefined;
2803
+ checkConstraints?: Record<string, {
2804
+ value: string;
2805
+ name: string;
2806
+ }> | undefined;
2807
+ }>>;
2808
+ views: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
2809
+ name: zod.ZodString;
2810
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
2811
+ name: zod.ZodString;
2812
+ type: zod.ZodString;
2813
+ primaryKey: zod.ZodBoolean;
2814
+ notNull: zod.ZodBoolean;
2815
+ autoincrement: zod.ZodOptional<zod.ZodBoolean>;
2816
+ default: zod.ZodOptional<zod.ZodAny>;
2817
+ generated: zod.ZodOptional<zod.ZodObject<{
2818
+ type: zod.ZodEnum<["stored", "virtual"]>;
2819
+ as: zod.ZodString;
2820
+ }, "strip", zod.ZodTypeAny, {
2821
+ type: "stored" | "virtual";
2822
+ as: string;
2823
+ }, {
2824
+ type: "stored" | "virtual";
2825
+ as: string;
2826
+ }>>;
2827
+ }, "strict", zod.ZodTypeAny, {
2828
+ type: string;
2829
+ name: string;
2830
+ primaryKey: boolean;
2831
+ notNull: boolean;
2832
+ default?: any;
2833
+ generated?: {
2834
+ type: "stored" | "virtual";
2835
+ as: string;
2836
+ } | undefined;
2837
+ autoincrement?: boolean | undefined;
2838
+ }, {
2839
+ type: string;
2840
+ name: string;
2841
+ primaryKey: boolean;
2842
+ notNull: boolean;
2843
+ default?: any;
2844
+ generated?: {
2845
+ type: "stored" | "virtual";
2846
+ as: string;
2847
+ } | undefined;
2848
+ autoincrement?: boolean | undefined;
2849
+ }>>;
2850
+ definition: zod.ZodOptional<zod.ZodString>;
2851
+ isExisting: zod.ZodBoolean;
2852
+ }, "strict", zod.ZodTypeAny, {
2853
+ name: string;
2854
+ columns: Record<string, {
2855
+ type: string;
2856
+ name: string;
2857
+ primaryKey: boolean;
2858
+ notNull: boolean;
2859
+ default?: any;
2860
+ generated?: {
2861
+ type: "stored" | "virtual";
2862
+ as: string;
2863
+ } | undefined;
2864
+ autoincrement?: boolean | undefined;
2865
+ }>;
2866
+ isExisting: boolean;
2867
+ definition?: string | undefined;
2868
+ }, {
2869
+ name: string;
2870
+ columns: Record<string, {
2871
+ type: string;
2872
+ name: string;
2873
+ primaryKey: boolean;
2874
+ notNull: boolean;
2875
+ default?: any;
2876
+ generated?: {
2877
+ type: "stored" | "virtual";
2878
+ as: string;
2879
+ } | undefined;
2880
+ autoincrement?: boolean | undefined;
2881
+ }>;
2882
+ isExisting: boolean;
2883
+ definition?: string | undefined;
2884
+ }>>>;
2885
+ enums: zod.ZodObject<{}, "strip", zod.ZodTypeAny, {}, {}>;
2886
+ _meta: zod.ZodObject<{
2887
+ tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
2888
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
2889
+ }, "strip", zod.ZodTypeAny, {
2890
+ tables: Record<string, string>;
2891
+ columns: Record<string, string>;
2892
+ }, {
2893
+ tables: Record<string, string>;
2894
+ columns: Record<string, string>;
2895
+ }>;
2896
+ internal: zod.ZodOptional<zod.ZodObject<{
2897
+ indexes: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
2898
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
2899
+ isExpression: zod.ZodOptional<zod.ZodBoolean>;
2900
+ }, "strip", zod.ZodTypeAny, {
2901
+ isExpression?: boolean | undefined;
2902
+ }, {
2903
+ isExpression?: boolean | undefined;
2904
+ }>>>;
2905
+ }, "strip", zod.ZodTypeAny, {
2906
+ columns: Record<string, {
2907
+ isExpression?: boolean | undefined;
2908
+ } | undefined>;
2909
+ }, {
2910
+ columns: Record<string, {
2911
+ isExpression?: boolean | undefined;
2912
+ } | undefined>;
2913
+ }>>>>;
2914
+ }, "strip", zod.ZodTypeAny, {
2915
+ indexes?: Record<string, {
2916
+ columns: Record<string, {
2917
+ isExpression?: boolean | undefined;
2918
+ } | undefined>;
2919
+ } | undefined> | undefined;
2920
+ }, {
2921
+ indexes?: Record<string, {
2922
+ columns: Record<string, {
2923
+ isExpression?: boolean | undefined;
2924
+ } | undefined>;
2925
+ } | undefined> | undefined;
2926
+ }>>;
2927
+ } & {
2928
+ id: zod.ZodString;
2929
+ prevId: zod.ZodString;
2930
+ }, "strict", zod.ZodTypeAny, {
2931
+ version: "6";
2932
+ dialect: "sqlite";
2933
+ tables: Record<string, {
2934
+ name: string;
2935
+ columns: Record<string, {
2936
+ type: string;
2937
+ name: string;
2938
+ primaryKey: boolean;
2939
+ notNull: boolean;
2940
+ default?: any;
2941
+ generated?: {
2942
+ type: "stored" | "virtual";
2943
+ as: string;
2944
+ } | undefined;
2945
+ autoincrement?: boolean | undefined;
2946
+ }>;
2947
+ indexes: Record<string, {
2948
+ name: string;
2949
+ columns: string[];
2950
+ isUnique: boolean;
2951
+ where?: string | undefined;
2952
+ }>;
2953
+ foreignKeys: Record<string, {
2954
+ name: string;
2955
+ tableFrom: string;
2956
+ columnsFrom: string[];
2957
+ tableTo: string;
2958
+ columnsTo: string[];
2959
+ onUpdate?: string | undefined;
2960
+ onDelete?: string | undefined;
2961
+ }>;
2962
+ compositePrimaryKeys: Record<string, {
2963
+ columns: string[];
2964
+ name?: string | undefined;
2965
+ }>;
2966
+ uniqueConstraints: Record<string, {
2967
+ name: string;
2968
+ columns: string[];
2969
+ }>;
2970
+ checkConstraints: Record<string, {
2971
+ value: string;
2972
+ name: string;
2973
+ }>;
2974
+ }>;
2975
+ enums: {};
2976
+ views: Record<string, {
2977
+ name: string;
2978
+ columns: Record<string, {
2979
+ type: string;
2980
+ name: string;
2981
+ primaryKey: boolean;
2982
+ notNull: boolean;
2983
+ default?: any;
2984
+ generated?: {
2985
+ type: "stored" | "virtual";
2986
+ as: string;
2987
+ } | undefined;
2988
+ autoincrement?: boolean | undefined;
2989
+ }>;
2990
+ isExisting: boolean;
2991
+ definition?: string | undefined;
2992
+ }>;
2993
+ _meta: {
2994
+ tables: Record<string, string>;
2995
+ columns: Record<string, string>;
2996
+ };
2997
+ id: string;
2998
+ prevId: string;
2999
+ internal?: {
3000
+ indexes?: Record<string, {
3001
+ columns: Record<string, {
3002
+ isExpression?: boolean | undefined;
3003
+ } | undefined>;
3004
+ } | undefined> | undefined;
3005
+ } | undefined;
3006
+ }, {
3007
+ version: "6";
3008
+ dialect: "sqlite";
3009
+ tables: Record<string, {
3010
+ name: string;
3011
+ columns: Record<string, {
3012
+ type: string;
3013
+ name: string;
3014
+ primaryKey: boolean;
3015
+ notNull: boolean;
3016
+ default?: any;
3017
+ generated?: {
3018
+ type: "stored" | "virtual";
3019
+ as: string;
3020
+ } | undefined;
3021
+ autoincrement?: boolean | undefined;
3022
+ }>;
3023
+ indexes: Record<string, {
3024
+ name: string;
3025
+ columns: string[];
3026
+ isUnique: boolean;
3027
+ where?: string | undefined;
3028
+ }>;
3029
+ foreignKeys: Record<string, {
3030
+ name: string;
3031
+ tableFrom: string;
3032
+ columnsFrom: string[];
3033
+ tableTo: string;
3034
+ columnsTo: string[];
3035
+ onUpdate?: string | undefined;
3036
+ onDelete?: string | undefined;
3037
+ }>;
3038
+ compositePrimaryKeys: Record<string, {
3039
+ columns: string[];
3040
+ name?: string | undefined;
3041
+ }>;
3042
+ uniqueConstraints?: Record<string, {
3043
+ name: string;
3044
+ columns: string[];
3045
+ }> | undefined;
3046
+ checkConstraints?: Record<string, {
3047
+ value: string;
3048
+ name: string;
3049
+ }> | undefined;
3050
+ }>;
3051
+ enums: {};
3052
+ _meta: {
3053
+ tables: Record<string, string>;
3054
+ columns: Record<string, string>;
3055
+ };
3056
+ id: string;
3057
+ prevId: string;
3058
+ views?: Record<string, {
3059
+ name: string;
3060
+ columns: Record<string, {
3061
+ type: string;
3062
+ name: string;
3063
+ primaryKey: boolean;
3064
+ notNull: boolean;
3065
+ default?: any;
3066
+ generated?: {
3067
+ type: "stored" | "virtual";
3068
+ as: string;
3069
+ } | undefined;
3070
+ autoincrement?: boolean | undefined;
3071
+ }>;
3072
+ isExisting: boolean;
3073
+ definition?: string | undefined;
3074
+ }> | undefined;
3075
+ internal?: {
3076
+ indexes?: Record<string, {
3077
+ columns: Record<string, {
3078
+ isExpression?: boolean | undefined;
3079
+ } | undefined>;
3080
+ } | undefined> | undefined;
3081
+ } | undefined;
3082
+ }>;
3083
+ type SQLiteSchema = TypeOf<typeof schema>;
3084
+
3085
+ type DrizzleSnapshotJSON = PgSchema;
3086
+ type DrizzleSQLiteSnapshotJSON = SQLiteSchema;
3087
+ type DrizzleMySQLSnapshotJSON = MySqlSchema;
3088
+ type DrizzleSingleStoreSnapshotJSON = SingleStoreSchema;
3089
+ declare const generateDrizzleJson: (imports: Record<string, unknown>, prevId?: string, schemaFilters?: string[], casing?: CasingType) => PgSchema;
3090
+ declare const generateMigration: (prev: DrizzleSnapshotJSON, cur: DrizzleSnapshotJSON) => Promise<string[]>;
3091
+ declare const pushSchema: (imports: Record<string, unknown>, drizzleInstance: PgDatabase<any, any, any, any>, schemaFilters?: string[], tablesFilter?: string[], extensionsFilters?: Config["extensionsFilters"]) => Promise<{
3092
+ hasDataLoss: boolean;
3093
+ warnings: string[];
3094
+ statementsToExecute: string[];
3095
+ apply: () => Promise<void>;
3096
+ }>;
3097
+ declare const startStudioPostgresServer: (imports: Record<string, unknown>, credentials: PostgresCredentials | {
3098
+ driver: "pglite";
3099
+ client: PGlite;
3100
+ }, options?: {
3101
+ host?: string;
3102
+ port?: number;
3103
+ casing?: CasingType;
3104
+ }) => Promise<void>;
3105
+ declare const generateSQLiteDrizzleJson: (imports: Record<string, unknown>, prevId?: string, casing?: CasingType) => Promise<SQLiteSchema>;
3106
+ declare const generateSQLiteMigration: (prev: DrizzleSQLiteSnapshotJSON, cur: DrizzleSQLiteSnapshotJSON) => Promise<string[]>;
3107
+ declare const pushSQLiteSchema: (imports: Record<string, unknown>, drizzleInstance: LibSQLDatabase<any, any>) => Promise<{
3108
+ hasDataLoss: boolean;
3109
+ warnings: string[];
3110
+ statementsToExecute: string[];
3111
+ apply: () => Promise<void>;
3112
+ }>;
3113
+ declare const startStudioSQLiteServer: (imports: Record<string, unknown>, credentials: SqliteCredentials, options?: {
3114
+ host?: string;
3115
+ port?: number;
3116
+ casing?: CasingType;
3117
+ }) => Promise<void>;
3118
+ declare const generateMySQLDrizzleJson: (imports: Record<string, unknown>, prevId?: string, casing?: CasingType) => Promise<MySqlSchema>;
3119
+ declare const generateMySQLMigration: (prev: DrizzleMySQLSnapshotJSON, cur: DrizzleMySQLSnapshotJSON) => Promise<string[]>;
3120
+ declare const pushMySQLSchema: (imports: Record<string, unknown>, drizzleInstance: MySql2Database<any, any>, databaseName: string) => Promise<{
3121
+ hasDataLoss: boolean;
3122
+ warnings: string[];
3123
+ statementsToExecute: string[];
3124
+ apply: () => Promise<void>;
3125
+ }>;
3126
+ declare const startStudioMySQLServer: (imports: Record<string, unknown>, credentials: MysqlCredentials, options?: {
3127
+ host?: string;
3128
+ port?: number;
3129
+ casing?: CasingType;
3130
+ }) => Promise<void>;
3131
+ declare const generateSingleStoreDrizzleJson: (imports: Record<string, unknown>, prevId?: string, casing?: CasingType) => Promise<SingleStoreSchema>;
3132
+ declare const generateSingleStoreMigration: (prev: DrizzleSingleStoreSnapshotJSON, cur: DrizzleSingleStoreSnapshotJSON) => Promise<string[]>;
3133
+ declare const pushSingleStoreSchema: (imports: Record<string, unknown>, drizzleInstance: SingleStoreDriverDatabase<any>, databaseName: string) => Promise<{
3134
+ hasDataLoss: boolean;
3135
+ warnings: string[];
3136
+ statementsToExecute: string[];
3137
+ apply: () => Promise<void>;
3138
+ }>;
3139
+ declare const startStudioSingleStoreServer: (imports: Record<string, unknown>, credentials: SingleStoreCredentials, options?: {
3140
+ host?: string;
3141
+ port?: number;
3142
+ casing?: CasingType;
3143
+ }) => Promise<void>;
3144
+ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => {
3145
+ version: "7";
3146
+ dialect: "postgresql";
3147
+ tables: Record<string, {
3148
+ name: string;
3149
+ schema: string;
3150
+ columns: Record<string, {
3151
+ type: string;
3152
+ name: string;
3153
+ primaryKey: boolean;
3154
+ notNull: boolean;
3155
+ typeSchema?: string | undefined;
3156
+ default?: any;
3157
+ isUnique?: any;
3158
+ uniqueName?: string | undefined;
3159
+ nullsNotDistinct?: boolean | undefined;
3160
+ generated?: {
3161
+ type: "stored";
3162
+ as: string;
3163
+ } | undefined;
3164
+ identity?: {
3165
+ type: "always" | "byDefault";
3166
+ name: string;
3167
+ schema: string;
3168
+ increment?: string | undefined;
3169
+ minValue?: string | undefined;
3170
+ maxValue?: string | undefined;
3171
+ startWith?: string | undefined;
3172
+ cache?: string | undefined;
3173
+ cycle?: boolean | undefined;
3174
+ } | undefined;
3175
+ }>;
3176
+ indexes: Record<string, {
3177
+ name: string;
3178
+ columns: {
3179
+ expression: string;
3180
+ isExpression: boolean;
3181
+ asc: boolean;
3182
+ nulls?: string | undefined;
3183
+ opclass?: string | undefined;
3184
+ }[];
3185
+ isUnique: boolean;
3186
+ method: string;
3187
+ concurrently: boolean;
3188
+ with?: Record<string, any> | undefined;
3189
+ where?: string | undefined;
3190
+ }>;
3191
+ foreignKeys: Record<string, {
3192
+ name: string;
3193
+ tableFrom: string;
3194
+ columnsFrom: string[];
3195
+ tableTo: string;
3196
+ columnsTo: string[];
3197
+ schemaTo?: string | undefined;
3198
+ onUpdate?: string | undefined;
3199
+ onDelete?: string | undefined;
3200
+ }>;
3201
+ compositePrimaryKeys: Record<string, {
3202
+ name: string;
3203
+ columns: string[];
3204
+ }>;
3205
+ uniqueConstraints: Record<string, {
3206
+ name: string;
3207
+ columns: string[];
3208
+ nullsNotDistinct: boolean;
3209
+ }>;
3210
+ policies: Record<string, {
3211
+ name: string;
3212
+ schema?: string | undefined;
3213
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
3214
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
3215
+ to?: string[] | undefined;
3216
+ using?: string | undefined;
3217
+ withCheck?: string | undefined;
3218
+ on?: string | undefined;
3219
+ }>;
3220
+ checkConstraints: Record<string, {
3221
+ value: string;
3222
+ name: string;
3223
+ }>;
3224
+ isRLSEnabled: boolean;
3225
+ }>;
3226
+ policies: Record<string, {
3227
+ name: string;
3228
+ schema?: string | undefined;
3229
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
3230
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
3231
+ to?: string[] | undefined;
3232
+ using?: string | undefined;
3233
+ withCheck?: string | undefined;
3234
+ on?: string | undefined;
3235
+ }>;
3236
+ enums: Record<string, {
3237
+ values: string[];
3238
+ name: string;
3239
+ schema: string;
3240
+ }>;
3241
+ schemas: Record<string, string>;
3242
+ views: Record<string, {
3243
+ name: string;
3244
+ schema: string;
3245
+ columns: Record<string, {
3246
+ type: string;
3247
+ name: string;
3248
+ primaryKey: boolean;
3249
+ notNull: boolean;
3250
+ typeSchema?: string | undefined;
3251
+ default?: any;
3252
+ isUnique?: any;
3253
+ uniqueName?: string | undefined;
3254
+ nullsNotDistinct?: boolean | undefined;
3255
+ generated?: {
3256
+ type: "stored";
3257
+ as: string;
3258
+ } | undefined;
3259
+ identity?: {
3260
+ type: "always" | "byDefault";
3261
+ name: string;
3262
+ schema: string;
3263
+ increment?: string | undefined;
3264
+ minValue?: string | undefined;
3265
+ maxValue?: string | undefined;
3266
+ startWith?: string | undefined;
3267
+ cache?: string | undefined;
3268
+ cycle?: boolean | undefined;
3269
+ } | undefined;
3270
+ }>;
3271
+ materialized: boolean;
3272
+ isExisting: boolean;
3273
+ with?: {
3274
+ checkOption?: "local" | "cascaded" | undefined;
3275
+ securityBarrier?: boolean | undefined;
3276
+ securityInvoker?: boolean | undefined;
3277
+ fillfactor?: number | undefined;
3278
+ toastTupleTarget?: number | undefined;
3279
+ parallelWorkers?: number | undefined;
3280
+ autovacuumEnabled?: boolean | undefined;
3281
+ vacuumIndexCleanup?: "on" | "auto" | "off" | undefined;
3282
+ vacuumTruncate?: boolean | undefined;
3283
+ autovacuumVacuumThreshold?: number | undefined;
3284
+ autovacuumVacuumScaleFactor?: number | undefined;
3285
+ autovacuumVacuumCostDelay?: number | undefined;
3286
+ autovacuumVacuumCostLimit?: number | undefined;
3287
+ autovacuumFreezeMinAge?: number | undefined;
3288
+ autovacuumFreezeMaxAge?: number | undefined;
3289
+ autovacuumFreezeTableAge?: number | undefined;
3290
+ autovacuumMultixactFreezeMinAge?: number | undefined;
3291
+ autovacuumMultixactFreezeMaxAge?: number | undefined;
3292
+ autovacuumMultixactFreezeTableAge?: number | undefined;
3293
+ logAutovacuumMinDuration?: number | undefined;
3294
+ userCatalogTable?: boolean | undefined;
3295
+ } | undefined;
3296
+ using?: string | undefined;
3297
+ definition?: string | undefined;
3298
+ withNoData?: boolean | undefined;
3299
+ tablespace?: string | undefined;
3300
+ }>;
3301
+ sequences: Record<string, {
3302
+ name: string;
3303
+ schema: string;
3304
+ increment?: string | undefined;
3305
+ minValue?: string | undefined;
3306
+ maxValue?: string | undefined;
3307
+ startWith?: string | undefined;
3308
+ cache?: string | undefined;
3309
+ cycle?: boolean | undefined;
3310
+ }>;
3311
+ roles: Record<string, {
3312
+ name: string;
3313
+ createDb?: boolean | undefined;
3314
+ createRole?: boolean | undefined;
3315
+ inherit?: boolean | undefined;
3316
+ }>;
3317
+ _meta: {
3318
+ tables: Record<string, string>;
3319
+ columns: Record<string, string>;
3320
+ schemas: Record<string, string>;
3321
+ };
3322
+ id: string;
3323
+ prevId: string;
3324
+ internal?: {
3325
+ tables: Record<string, {
3326
+ columns: Record<string, {
3327
+ isArray?: boolean | undefined;
3328
+ dimensions?: number | undefined;
3329
+ rawType?: string | undefined;
3330
+ isDefaultAnExpression?: boolean | undefined;
3331
+ } | undefined>;
3332
+ } | undefined>;
3333
+ } | undefined;
3334
+ } | Record<string, unknown>;
3335
+
3336
+ export { type DrizzleMySQLSnapshotJSON, type DrizzleSQLiteSnapshotJSON, type DrizzleSingleStoreSnapshotJSON, type DrizzleSnapshotJSON, generateDrizzleJson, generateMigration, generateMySQLDrizzleJson, generateMySQLMigration, generateSQLiteDrizzleJson, generateSQLiteMigration, generateSingleStoreDrizzleJson, generateSingleStoreMigration, pushMySQLSchema, pushSQLiteSchema, pushSchema, pushSingleStoreSchema, startStudioMySQLServer, startStudioPostgresServer, startStudioSQLiteServer, startStudioSingleStoreServer, upPgSnapshot };