@anthonyalayo/drizzle-kit 1.0.7 → 1.1.0

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 (13) hide show
  1. package/api.d.mts +986 -452
  2. package/api.d.ts +986 -452
  3. package/api.js +54631 -25890
  4. package/api.mjs +54833 -26046
  5. package/bin.cjs +62898 -49463
  6. package/index.d.mts +319 -2
  7. package/index.d.ts +319 -2
  8. package/index.js +3 -3
  9. package/package.json +20 -21
  10. package/utils.js +824 -439
  11. package/utils.mjs +824 -441
  12. package/index-Z-1TKnbX.d.mts +0 -308
  13. package/index-Z-1TKnbX.d.ts +0 -308
package/api.d.ts CHANGED
@@ -1,13 +1,480 @@
1
+ import { PGlite } from '@electric-sql/pglite';
1
2
  import { LibSQLDatabase } from 'drizzle-orm/libsql';
2
3
  import { MySql2Database } from 'drizzle-orm/mysql2';
3
4
  import { PgDatabase } from 'drizzle-orm/pg-core';
4
5
  import { SingleStoreDriverDatabase } from 'drizzle-orm/singlestore';
5
- import { C as CasingType, a as Config } from './index-Z-1TKnbX.js';
6
6
  import * as zod from 'zod';
7
7
  import { TypeOf } from 'zod';
8
- import 'tls';
8
+ import { ConnectionOptions } from 'tls';
9
9
 
10
- declare const schema$2: zod.ZodObject<zod.objectUtil.extendShape<{
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<{
11
478
  version: zod.ZodLiteral<"5">;
12
479
  dialect: zod.ZodLiteral<"mysql">;
13
480
  tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
@@ -31,29 +498,29 @@ declare const schema$2: zod.ZodObject<zod.objectUtil.extendShape<{
31
498
  as: string;
32
499
  }>>;
33
500
  }, "strict", zod.ZodTypeAny, {
34
- name: string;
35
501
  type: string;
502
+ name: string;
36
503
  primaryKey: boolean;
37
504
  notNull: boolean;
38
505
  default?: any;
39
- onUpdate?: any;
40
- autoincrement?: boolean | undefined;
41
506
  generated?: {
42
507
  type: "stored" | "virtual";
43
508
  as: string;
44
509
  } | undefined;
510
+ onUpdate?: any;
511
+ autoincrement?: boolean | undefined;
45
512
  }, {
46
- name: string;
47
513
  type: string;
514
+ name: string;
48
515
  primaryKey: boolean;
49
516
  notNull: boolean;
50
517
  default?: any;
51
- onUpdate?: any;
52
- autoincrement?: boolean | undefined;
53
518
  generated?: {
54
519
  type: "stored" | "virtual";
55
520
  as: string;
56
521
  } | undefined;
522
+ onUpdate?: any;
523
+ autoincrement?: boolean | undefined;
57
524
  }>>;
58
525
  indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
59
526
  name: zod.ZodString;
@@ -68,14 +535,14 @@ declare const schema$2: zod.ZodObject<zod.objectUtil.extendShape<{
68
535
  isUnique: boolean;
69
536
  using?: "btree" | "hash" | undefined;
70
537
  algorithm?: "default" | "inplace" | "copy" | undefined;
71
- lock?: "none" | "default" | "shared" | "exclusive" | undefined;
538
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
72
539
  }, {
73
540
  name: string;
74
541
  columns: string[];
75
542
  isUnique: boolean;
76
543
  using?: "btree" | "hash" | undefined;
77
544
  algorithm?: "default" | "inplace" | "copy" | undefined;
78
- lock?: "none" | "default" | "shared" | "exclusive" | undefined;
545
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
79
546
  }>>;
80
547
  foreignKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
81
548
  name: zod.ZodString;
@@ -126,26 +593,26 @@ declare const schema$2: zod.ZodObject<zod.objectUtil.extendShape<{
126
593
  name: zod.ZodString;
127
594
  value: zod.ZodString;
128
595
  }, "strict", zod.ZodTypeAny, {
129
- name: string;
130
596
  value: string;
131
- }, {
132
597
  name: string;
598
+ }, {
133
599
  value: string;
600
+ name: string;
134
601
  }>>>;
135
602
  }, "strict", zod.ZodTypeAny, {
136
603
  name: string;
137
604
  columns: Record<string, {
138
- name: string;
139
605
  type: string;
606
+ name: string;
140
607
  primaryKey: boolean;
141
608
  notNull: boolean;
142
609
  default?: any;
143
- onUpdate?: any;
144
- autoincrement?: boolean | undefined;
145
610
  generated?: {
146
611
  type: "stored" | "virtual";
147
612
  as: string;
148
613
  } | undefined;
614
+ onUpdate?: any;
615
+ autoincrement?: boolean | undefined;
149
616
  }>;
150
617
  indexes: Record<string, {
151
618
  name: string;
@@ -153,7 +620,7 @@ declare const schema$2: zod.ZodObject<zod.objectUtil.extendShape<{
153
620
  isUnique: boolean;
154
621
  using?: "btree" | "hash" | undefined;
155
622
  algorithm?: "default" | "inplace" | "copy" | undefined;
156
- lock?: "none" | "default" | "shared" | "exclusive" | undefined;
623
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
157
624
  }>;
158
625
  foreignKeys: Record<string, {
159
626
  name: string;
@@ -173,23 +640,23 @@ declare const schema$2: zod.ZodObject<zod.objectUtil.extendShape<{
173
640
  columns: string[];
174
641
  }>;
175
642
  checkConstraint: Record<string, {
176
- name: string;
177
643
  value: string;
644
+ name: string;
178
645
  }>;
179
646
  }, {
180
647
  name: string;
181
648
  columns: Record<string, {
182
- name: string;
183
649
  type: string;
650
+ name: string;
184
651
  primaryKey: boolean;
185
652
  notNull: boolean;
186
653
  default?: any;
187
- onUpdate?: any;
188
- autoincrement?: boolean | undefined;
189
654
  generated?: {
190
655
  type: "stored" | "virtual";
191
656
  as: string;
192
657
  } | undefined;
658
+ onUpdate?: any;
659
+ autoincrement?: boolean | undefined;
193
660
  }>;
194
661
  indexes: Record<string, {
195
662
  name: string;
@@ -197,7 +664,7 @@ declare const schema$2: zod.ZodObject<zod.objectUtil.extendShape<{
197
664
  isUnique: boolean;
198
665
  using?: "btree" | "hash" | undefined;
199
666
  algorithm?: "default" | "inplace" | "copy" | undefined;
200
- lock?: "none" | "default" | "shared" | "exclusive" | undefined;
667
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
201
668
  }>;
202
669
  foreignKeys: Record<string, {
203
670
  name: string;
@@ -217,11 +684,11 @@ declare const schema$2: zod.ZodObject<zod.objectUtil.extendShape<{
217
684
  columns: string[];
218
685
  }> | undefined;
219
686
  checkConstraint?: Record<string, {
220
- name: string;
221
687
  value: string;
688
+ name: string;
222
689
  }> | undefined;
223
690
  }>>;
224
- views: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<zod.objectUtil.extendShape<{
691
+ views: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
225
692
  name: zod.ZodString;
226
693
  columns: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
227
694
  name: zod.ZodString;
@@ -242,86 +709,86 @@ declare const schema$2: zod.ZodObject<zod.objectUtil.extendShape<{
242
709
  as: string;
243
710
  }>>;
244
711
  }, "strict", zod.ZodTypeAny, {
245
- name: string;
246
712
  type: string;
713
+ name: string;
247
714
  primaryKey: boolean;
248
715
  notNull: boolean;
249
716
  default?: any;
250
- onUpdate?: any;
251
- autoincrement?: boolean | undefined;
252
717
  generated?: {
253
718
  type: "stored" | "virtual";
254
719
  as: string;
255
720
  } | undefined;
721
+ onUpdate?: any;
722
+ autoincrement?: boolean | undefined;
256
723
  }, {
257
- name: string;
258
724
  type: string;
725
+ name: string;
259
726
  primaryKey: boolean;
260
727
  notNull: boolean;
261
728
  default?: any;
262
- onUpdate?: any;
263
- autoincrement?: boolean | undefined;
264
729
  generated?: {
265
730
  type: "stored" | "virtual";
266
731
  as: string;
267
732
  } | undefined;
733
+ onUpdate?: any;
734
+ autoincrement?: boolean | undefined;
268
735
  }>>;
269
736
  definition: zod.ZodOptional<zod.ZodString>;
270
737
  isExisting: zod.ZodBoolean;
271
- }, {
738
+ } & {
272
739
  algorithm: zod.ZodEnum<["undefined", "merge", "temptable"]>;
273
740
  sqlSecurity: zod.ZodEnum<["definer", "invoker"]>;
274
741
  withCheckOption: zod.ZodOptional<zod.ZodEnum<["local", "cascaded"]>>;
275
- }>, "strict", zod.ZodTypeAny, {
742
+ }, "strict", zod.ZodTypeAny, {
276
743
  name: string;
277
744
  columns: Record<string, {
278
- name: string;
279
745
  type: string;
746
+ name: string;
280
747
  primaryKey: boolean;
281
748
  notNull: boolean;
282
749
  default?: any;
283
- onUpdate?: any;
284
- autoincrement?: boolean | undefined;
285
750
  generated?: {
286
751
  type: "stored" | "virtual";
287
752
  as: string;
288
753
  } | undefined;
754
+ onUpdate?: any;
755
+ autoincrement?: boolean | undefined;
289
756
  }>;
757
+ isExisting: boolean;
290
758
  algorithm: "undefined" | "merge" | "temptable";
291
759
  sqlSecurity: "definer" | "invoker";
292
- isExisting: boolean;
293
- withCheckOption?: "local" | "cascaded" | undefined;
294
760
  definition?: string | undefined;
761
+ withCheckOption?: "local" | "cascaded" | undefined;
295
762
  }, {
296
763
  name: string;
297
764
  columns: Record<string, {
298
- name: string;
299
765
  type: string;
766
+ name: string;
300
767
  primaryKey: boolean;
301
768
  notNull: boolean;
302
769
  default?: any;
303
- onUpdate?: any;
304
- autoincrement?: boolean | undefined;
305
770
  generated?: {
306
771
  type: "stored" | "virtual";
307
772
  as: string;
308
773
  } | undefined;
774
+ onUpdate?: any;
775
+ autoincrement?: boolean | undefined;
309
776
  }>;
777
+ isExisting: boolean;
310
778
  algorithm: "undefined" | "merge" | "temptable";
311
779
  sqlSecurity: "definer" | "invoker";
312
- isExisting: boolean;
313
- withCheckOption?: "local" | "cascaded" | undefined;
314
780
  definition?: string | undefined;
781
+ withCheckOption?: "local" | "cascaded" | undefined;
315
782
  }>>>;
316
783
  _meta: zod.ZodObject<{
317
784
  tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
318
785
  columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
319
786
  }, "strip", zod.ZodTypeAny, {
320
- columns: Record<string, string>;
321
787
  tables: Record<string, string>;
322
- }, {
323
788
  columns: Record<string, string>;
789
+ }, {
324
790
  tables: Record<string, string>;
791
+ columns: Record<string, string>;
325
792
  }>;
326
793
  internal: zod.ZodOptional<zod.ZodObject<{
327
794
  tables: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
@@ -359,46 +826,48 @@ declare const schema$2: zod.ZodObject<zod.objectUtil.extendShape<{
359
826
  } | undefined>;
360
827
  }>>>>;
361
828
  }, "strip", zod.ZodTypeAny, {
362
- indexes?: Record<string, {
363
- columns: Record<string, {
364
- isExpression?: boolean | undefined;
365
- } | undefined>;
366
- } | undefined> | undefined;
367
829
  tables?: Record<string, {
368
830
  columns: Record<string, {
369
831
  isDefaultAnExpression?: boolean | undefined;
370
832
  } | undefined>;
371
833
  } | undefined> | undefined;
372
- }, {
373
834
  indexes?: Record<string, {
374
835
  columns: Record<string, {
375
836
  isExpression?: boolean | undefined;
376
837
  } | undefined>;
377
838
  } | undefined> | undefined;
839
+ }, {
378
840
  tables?: Record<string, {
379
841
  columns: Record<string, {
380
842
  isDefaultAnExpression?: boolean | undefined;
381
843
  } | undefined>;
382
844
  } | undefined> | undefined;
845
+ indexes?: Record<string, {
846
+ columns: Record<string, {
847
+ isExpression?: boolean | undefined;
848
+ } | undefined>;
849
+ } | undefined> | undefined;
383
850
  }>>;
384
- }, {
851
+ } & {
385
852
  id: zod.ZodString;
386
853
  prevId: zod.ZodString;
387
- }>, "strip", zod.ZodTypeAny, {
854
+ }, "strip", zod.ZodTypeAny, {
855
+ version: "5";
856
+ dialect: "mysql";
388
857
  tables: Record<string, {
389
858
  name: string;
390
859
  columns: Record<string, {
391
- name: string;
392
860
  type: string;
861
+ name: string;
393
862
  primaryKey: boolean;
394
863
  notNull: boolean;
395
864
  default?: any;
396
- onUpdate?: any;
397
- autoincrement?: boolean | undefined;
398
865
  generated?: {
399
866
  type: "stored" | "virtual";
400
867
  as: string;
401
868
  } | undefined;
869
+ onUpdate?: any;
870
+ autoincrement?: boolean | undefined;
402
871
  }>;
403
872
  indexes: Record<string, {
404
873
  name: string;
@@ -406,7 +875,7 @@ declare const schema$2: zod.ZodObject<zod.objectUtil.extendShape<{
406
875
  isUnique: boolean;
407
876
  using?: "btree" | "hash" | undefined;
408
877
  algorithm?: "default" | "inplace" | "copy" | undefined;
409
- lock?: "none" | "default" | "shared" | "exclusive" | undefined;
878
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
410
879
  }>;
411
880
  foreignKeys: Record<string, {
412
881
  name: string;
@@ -426,66 +895,66 @@ declare const schema$2: zod.ZodObject<zod.objectUtil.extendShape<{
426
895
  columns: string[];
427
896
  }>;
428
897
  checkConstraint: Record<string, {
429
- name: string;
430
898
  value: string;
899
+ name: string;
431
900
  }>;
432
901
  }>;
433
- id: string;
434
- prevId: string;
435
- version: "5";
436
- dialect: "mysql";
437
- _meta: {
438
- columns: Record<string, string>;
439
- tables: Record<string, string>;
440
- };
441
902
  views: Record<string, {
442
903
  name: string;
443
904
  columns: Record<string, {
444
- name: string;
445
905
  type: string;
906
+ name: string;
446
907
  primaryKey: boolean;
447
908
  notNull: boolean;
448
909
  default?: any;
449
- onUpdate?: any;
450
- autoincrement?: boolean | undefined;
451
910
  generated?: {
452
911
  type: "stored" | "virtual";
453
912
  as: string;
454
913
  } | undefined;
914
+ onUpdate?: any;
915
+ autoincrement?: boolean | undefined;
455
916
  }>;
917
+ isExisting: boolean;
456
918
  algorithm: "undefined" | "merge" | "temptable";
457
919
  sqlSecurity: "definer" | "invoker";
458
- isExisting: boolean;
459
- withCheckOption?: "local" | "cascaded" | undefined;
460
920
  definition?: string | undefined;
921
+ withCheckOption?: "local" | "cascaded" | undefined;
461
922
  }>;
923
+ _meta: {
924
+ tables: Record<string, string>;
925
+ columns: Record<string, string>;
926
+ };
927
+ id: string;
928
+ prevId: string;
462
929
  internal?: {
463
- indexes?: Record<string, {
930
+ tables?: Record<string, {
464
931
  columns: Record<string, {
465
- isExpression?: boolean | undefined;
932
+ isDefaultAnExpression?: boolean | undefined;
466
933
  } | undefined>;
467
934
  } | undefined> | undefined;
468
- tables?: Record<string, {
935
+ indexes?: Record<string, {
469
936
  columns: Record<string, {
470
- isDefaultAnExpression?: boolean | undefined;
937
+ isExpression?: boolean | undefined;
471
938
  } | undefined>;
472
939
  } | undefined> | undefined;
473
940
  } | undefined;
474
941
  }, {
942
+ version: "5";
943
+ dialect: "mysql";
475
944
  tables: Record<string, {
476
945
  name: string;
477
946
  columns: Record<string, {
478
- name: string;
479
947
  type: string;
948
+ name: string;
480
949
  primaryKey: boolean;
481
950
  notNull: boolean;
482
951
  default?: any;
483
- onUpdate?: any;
484
- autoincrement?: boolean | undefined;
485
952
  generated?: {
486
953
  type: "stored" | "virtual";
487
954
  as: string;
488
955
  } | undefined;
956
+ onUpdate?: any;
957
+ autoincrement?: boolean | undefined;
489
958
  }>;
490
959
  indexes: Record<string, {
491
960
  name: string;
@@ -493,7 +962,7 @@ declare const schema$2: zod.ZodObject<zod.objectUtil.extendShape<{
493
962
  isUnique: boolean;
494
963
  using?: "btree" | "hash" | undefined;
495
964
  algorithm?: "default" | "inplace" | "copy" | undefined;
496
- lock?: "none" | "default" | "shared" | "exclusive" | undefined;
965
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
497
966
  }>;
498
967
  foreignKeys: Record<string, {
499
968
  name: string;
@@ -513,56 +982,54 @@ declare const schema$2: zod.ZodObject<zod.objectUtil.extendShape<{
513
982
  columns: string[];
514
983
  }> | undefined;
515
984
  checkConstraint?: Record<string, {
516
- name: string;
517
985
  value: string;
986
+ name: string;
518
987
  }> | undefined;
519
988
  }>;
520
- id: string;
521
- prevId: string;
522
- version: "5";
523
- dialect: "mysql";
524
989
  _meta: {
525
- columns: Record<string, string>;
526
990
  tables: Record<string, string>;
991
+ columns: Record<string, string>;
527
992
  };
528
- internal?: {
529
- indexes?: Record<string, {
530
- columns: Record<string, {
531
- isExpression?: boolean | undefined;
532
- } | undefined>;
533
- } | undefined> | undefined;
534
- tables?: Record<string, {
535
- columns: Record<string, {
536
- isDefaultAnExpression?: boolean | undefined;
537
- } | undefined>;
538
- } | undefined> | undefined;
539
- } | undefined;
993
+ id: string;
994
+ prevId: string;
540
995
  views?: Record<string, {
541
996
  name: string;
542
997
  columns: Record<string, {
543
- name: string;
544
998
  type: string;
999
+ name: string;
545
1000
  primaryKey: boolean;
546
1001
  notNull: boolean;
547
1002
  default?: any;
548
- onUpdate?: any;
549
- autoincrement?: boolean | undefined;
550
1003
  generated?: {
551
1004
  type: "stored" | "virtual";
552
1005
  as: string;
553
1006
  } | undefined;
1007
+ onUpdate?: any;
1008
+ autoincrement?: boolean | undefined;
554
1009
  }>;
1010
+ isExisting: boolean;
555
1011
  algorithm: "undefined" | "merge" | "temptable";
556
1012
  sqlSecurity: "definer" | "invoker";
557
- isExisting: boolean;
558
- withCheckOption?: "local" | "cascaded" | undefined;
559
1013
  definition?: string | undefined;
1014
+ withCheckOption?: "local" | "cascaded" | undefined;
560
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;
561
1028
  }>;
562
1029
  type MySqlSchema = TypeOf<typeof schema$2>;
563
1030
 
564
- declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
565
- version: zod.ZodLiteral<"8">;
1031
+ declare const pgSchema: zod.ZodObject<{
1032
+ version: zod.ZodLiteral<"7">;
566
1033
  dialect: zod.ZodLiteral<"postgresql">;
567
1034
  tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
568
1035
  name: zod.ZodString;
@@ -587,7 +1054,7 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
587
1054
  type: "stored";
588
1055
  as: string;
589
1056
  }>>;
590
- identity: zod.ZodOptional<zod.ZodObject<zod.objectUtil.extendShape<{
1057
+ identity: zod.ZodOptional<zod.ZodObject<{
591
1058
  name: zod.ZodString;
592
1059
  increment: zod.ZodOptional<zod.ZodString>;
593
1060
  minValue: zod.ZodOptional<zod.ZodString>;
@@ -596,11 +1063,11 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
596
1063
  cache: zod.ZodOptional<zod.ZodString>;
597
1064
  cycle: zod.ZodOptional<zod.ZodBoolean>;
598
1065
  schema: zod.ZodString;
599
- }, {
1066
+ } & {
600
1067
  type: zod.ZodEnum<["always", "byDefault"]>;
601
- }>, "strip", zod.ZodTypeAny, {
602
- name: string;
1068
+ }, "strip", zod.ZodTypeAny, {
603
1069
  type: "always" | "byDefault";
1070
+ name: string;
604
1071
  schema: string;
605
1072
  increment?: string | undefined;
606
1073
  minValue?: string | undefined;
@@ -609,8 +1076,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
609
1076
  cache?: string | undefined;
610
1077
  cycle?: boolean | undefined;
611
1078
  }, {
612
- name: string;
613
1079
  type: "always" | "byDefault";
1080
+ name: string;
614
1081
  schema: string;
615
1082
  increment?: string | undefined;
616
1083
  minValue?: string | undefined;
@@ -620,22 +1087,22 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
620
1087
  cycle?: boolean | undefined;
621
1088
  }>>;
622
1089
  }, "strict", zod.ZodTypeAny, {
623
- name: string;
624
1090
  type: string;
1091
+ name: string;
625
1092
  primaryKey: boolean;
626
1093
  notNull: boolean;
627
- isUnique?: any;
1094
+ typeSchema?: string | undefined;
628
1095
  default?: any;
1096
+ isUnique?: any;
1097
+ uniqueName?: string | undefined;
1098
+ nullsNotDistinct?: boolean | undefined;
629
1099
  generated?: {
630
1100
  type: "stored";
631
1101
  as: string;
632
1102
  } | undefined;
633
- typeSchema?: string | undefined;
634
- uniqueName?: string | undefined;
635
- nullsNotDistinct?: boolean | undefined;
636
1103
  identity?: {
637
- name: string;
638
1104
  type: "always" | "byDefault";
1105
+ name: string;
639
1106
  schema: string;
640
1107
  increment?: string | undefined;
641
1108
  minValue?: string | undefined;
@@ -645,22 +1112,22 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
645
1112
  cycle?: boolean | undefined;
646
1113
  } | undefined;
647
1114
  }, {
648
- name: string;
649
1115
  type: string;
1116
+ name: string;
650
1117
  primaryKey: boolean;
651
1118
  notNull: boolean;
652
- isUnique?: any;
1119
+ typeSchema?: string | undefined;
653
1120
  default?: any;
1121
+ isUnique?: any;
1122
+ uniqueName?: string | undefined;
1123
+ nullsNotDistinct?: boolean | undefined;
654
1124
  generated?: {
655
1125
  type: "stored";
656
1126
  as: string;
657
1127
  } | undefined;
658
- typeSchema?: string | undefined;
659
- uniqueName?: string | undefined;
660
- nullsNotDistinct?: boolean | undefined;
661
1128
  identity?: {
662
- name: string;
663
1129
  type: "always" | "byDefault";
1130
+ name: string;
664
1131
  schema: string;
665
1132
  increment?: string | undefined;
666
1133
  minValue?: string | undefined;
@@ -679,14 +1146,14 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
679
1146
  nulls: zod.ZodOptional<zod.ZodString>;
680
1147
  opclass: zod.ZodOptional<zod.ZodString>;
681
1148
  }, "strip", zod.ZodTypeAny, {
682
- isExpression: boolean;
683
1149
  expression: string;
1150
+ isExpression: boolean;
684
1151
  asc: boolean;
685
1152
  nulls?: string | undefined;
686
1153
  opclass?: string | undefined;
687
1154
  }, {
688
- isExpression: boolean;
689
1155
  expression: string;
1156
+ isExpression: boolean;
690
1157
  asc: boolean;
691
1158
  nulls?: string | undefined;
692
1159
  opclass?: string | undefined;
@@ -699,8 +1166,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
699
1166
  }, "strict", zod.ZodTypeAny, {
700
1167
  name: string;
701
1168
  columns: {
702
- isExpression: boolean;
703
1169
  expression: string;
1170
+ isExpression: boolean;
704
1171
  asc: boolean;
705
1172
  nulls?: string | undefined;
706
1173
  opclass?: string | undefined;
@@ -713,8 +1180,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
713
1180
  }, {
714
1181
  name: string;
715
1182
  columns: {
716
- isExpression: boolean;
717
1183
  expression: string;
1184
+ isExpression: boolean;
718
1185
  asc: boolean;
719
1186
  nulls?: string | undefined;
720
1187
  opclass?: string | undefined;
@@ -740,18 +1207,18 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
740
1207
  columnsFrom: string[];
741
1208
  tableTo: string;
742
1209
  columnsTo: string[];
1210
+ schemaTo?: string | undefined;
743
1211
  onUpdate?: string | undefined;
744
1212
  onDelete?: string | undefined;
745
- schemaTo?: string | undefined;
746
1213
  }, {
747
1214
  name: string;
748
1215
  tableFrom: string;
749
1216
  columnsFrom: string[];
750
1217
  tableTo: string;
751
1218
  columnsTo: string[];
1219
+ schemaTo?: string | undefined;
752
1220
  onUpdate?: string | undefined;
753
1221
  onDelete?: string | undefined;
754
- schemaTo?: string | undefined;
755
1222
  }>>;
756
1223
  compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
757
1224
  name: zod.ZodString;
@@ -787,20 +1254,20 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
787
1254
  schema: zod.ZodOptional<zod.ZodString>;
788
1255
  }, "strict", zod.ZodTypeAny, {
789
1256
  name: string;
790
- using?: string | undefined;
791
- as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
792
1257
  schema?: string | undefined;
1258
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
793
1259
  for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
794
1260
  to?: string[] | undefined;
1261
+ using?: string | undefined;
795
1262
  withCheck?: string | undefined;
796
1263
  on?: string | undefined;
797
1264
  }, {
798
1265
  name: string;
799
- using?: string | undefined;
800
- as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
801
1266
  schema?: string | undefined;
1267
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
802
1268
  for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
803
1269
  to?: string[] | undefined;
1270
+ using?: string | undefined;
804
1271
  withCheck?: string | undefined;
805
1272
  on?: string | undefined;
806
1273
  }>>>;
@@ -817,23 +1284,24 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
817
1284
  isRLSEnabled: zod.ZodDefault<zod.ZodBoolean>;
818
1285
  }, "strict", zod.ZodTypeAny, {
819
1286
  name: string;
1287
+ schema: string;
820
1288
  columns: Record<string, {
821
- name: string;
822
1289
  type: string;
1290
+ name: string;
823
1291
  primaryKey: boolean;
824
1292
  notNull: boolean;
825
- isUnique?: any;
1293
+ typeSchema?: string | undefined;
826
1294
  default?: any;
1295
+ isUnique?: any;
1296
+ uniqueName?: string | undefined;
1297
+ nullsNotDistinct?: boolean | undefined;
827
1298
  generated?: {
828
1299
  type: "stored";
829
1300
  as: string;
830
1301
  } | undefined;
831
- typeSchema?: string | undefined;
832
- uniqueName?: string | undefined;
833
- nullsNotDistinct?: boolean | undefined;
834
1302
  identity?: {
835
- name: string;
836
1303
  type: "always" | "byDefault";
1304
+ name: string;
837
1305
  schema: string;
838
1306
  increment?: string | undefined;
839
1307
  minValue?: string | undefined;
@@ -846,8 +1314,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
846
1314
  indexes: Record<string, {
847
1315
  name: string;
848
1316
  columns: {
849
- isExpression: boolean;
850
1317
  expression: string;
1318
+ isExpression: boolean;
851
1319
  asc: boolean;
852
1320
  nulls?: string | undefined;
853
1321
  opclass?: string | undefined;
@@ -864,11 +1332,10 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
864
1332
  columnsFrom: string[];
865
1333
  tableTo: string;
866
1334
  columnsTo: string[];
1335
+ schemaTo?: string | undefined;
867
1336
  onUpdate?: string | undefined;
868
1337
  onDelete?: string | undefined;
869
- schemaTo?: string | undefined;
870
1338
  }>;
871
- schema: string;
872
1339
  compositePrimaryKeys: Record<string, {
873
1340
  name: string;
874
1341
  columns: string[];
@@ -878,40 +1345,41 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
878
1345
  columns: string[];
879
1346
  nullsNotDistinct: boolean;
880
1347
  }>;
881
- checkConstraints: Record<string, {
882
- value: string;
883
- name?: string | undefined;
884
- }>;
885
1348
  policies: Record<string, {
886
1349
  name: string;
887
- using?: string | undefined;
888
- as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
889
1350
  schema?: string | undefined;
1351
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
890
1352
  for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
891
1353
  to?: string[] | undefined;
1354
+ using?: string | undefined;
892
1355
  withCheck?: string | undefined;
893
1356
  on?: string | undefined;
894
1357
  }>;
1358
+ checkConstraints: Record<string, {
1359
+ value: string;
1360
+ name?: string | undefined;
1361
+ }>;
895
1362
  isRLSEnabled: boolean;
896
1363
  }, {
897
1364
  name: string;
1365
+ schema: string;
898
1366
  columns: Record<string, {
899
- name: string;
900
1367
  type: string;
1368
+ name: string;
901
1369
  primaryKey: boolean;
902
1370
  notNull: boolean;
903
- isUnique?: any;
1371
+ typeSchema?: string | undefined;
904
1372
  default?: any;
1373
+ isUnique?: any;
1374
+ uniqueName?: string | undefined;
1375
+ nullsNotDistinct?: boolean | undefined;
905
1376
  generated?: {
906
1377
  type: "stored";
907
1378
  as: string;
908
1379
  } | undefined;
909
- typeSchema?: string | undefined;
910
- uniqueName?: string | undefined;
911
- nullsNotDistinct?: boolean | undefined;
912
1380
  identity?: {
913
- name: string;
914
1381
  type: "always" | "byDefault";
1382
+ name: string;
915
1383
  schema: string;
916
1384
  increment?: string | undefined;
917
1385
  minValue?: string | undefined;
@@ -924,8 +1392,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
924
1392
  indexes: Record<string, {
925
1393
  name: string;
926
1394
  columns: {
927
- isExpression: boolean;
928
1395
  expression: string;
1396
+ isExpression: boolean;
929
1397
  asc: boolean;
930
1398
  nulls?: string | undefined;
931
1399
  opclass?: string | undefined;
@@ -942,11 +1410,10 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
942
1410
  columnsFrom: string[];
943
1411
  tableTo: string;
944
1412
  columnsTo: string[];
1413
+ schemaTo?: string | undefined;
945
1414
  onUpdate?: string | undefined;
946
1415
  onDelete?: string | undefined;
947
- schemaTo?: string | undefined;
948
1416
  }>;
949
- schema: string;
950
1417
  compositePrimaryKeys: Record<string, {
951
1418
  name: string;
952
1419
  columns: string[];
@@ -956,20 +1423,20 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
956
1423
  columns: string[];
957
1424
  nullsNotDistinct: boolean;
958
1425
  }> | undefined;
959
- checkConstraints?: Record<string, {
960
- value: string;
961
- name?: string | undefined;
962
- }> | undefined;
963
1426
  policies?: Record<string, {
964
1427
  name: string;
965
- using?: string | undefined;
966
- as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
967
1428
  schema?: string | undefined;
1429
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
968
1430
  for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
969
1431
  to?: string[] | undefined;
1432
+ using?: string | undefined;
970
1433
  withCheck?: string | undefined;
971
1434
  on?: string | undefined;
972
1435
  }> | undefined;
1436
+ checkConstraints?: Record<string, {
1437
+ value: string;
1438
+ name?: string | undefined;
1439
+ }> | undefined;
973
1440
  isRLSEnabled?: boolean | undefined;
974
1441
  }>>;
975
1442
  enums: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
@@ -977,16 +1444,16 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
977
1444
  schema: zod.ZodString;
978
1445
  values: zod.ZodArray<zod.ZodString, "many">;
979
1446
  }, "strict", zod.ZodTypeAny, {
980
- name: string;
981
1447
  values: string[];
1448
+ name: string;
982
1449
  schema: string;
983
1450
  }, {
984
- name: string;
985
1451
  values: string[];
1452
+ name: string;
986
1453
  schema: string;
987
1454
  }>>;
988
1455
  schemas: zod.ZodRecord<zod.ZodString, zod.ZodString>;
989
- domains: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1456
+ domains: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
990
1457
  name: zod.ZodString;
991
1458
  schema: zod.ZodString;
992
1459
  baseType: zod.ZodString;
@@ -1022,7 +1489,7 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1022
1489
  name?: string | undefined;
1023
1490
  }> | undefined;
1024
1491
  defaultValue?: any;
1025
- }>>;
1492
+ }>>>;
1026
1493
  views: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1027
1494
  name: zod.ZodString;
1028
1495
  schema: zod.ZodString;
@@ -1046,7 +1513,7 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1046
1513
  type: "stored";
1047
1514
  as: string;
1048
1515
  }>>;
1049
- identity: zod.ZodOptional<zod.ZodObject<zod.objectUtil.extendShape<{
1516
+ identity: zod.ZodOptional<zod.ZodObject<{
1050
1517
  name: zod.ZodString;
1051
1518
  increment: zod.ZodOptional<zod.ZodString>;
1052
1519
  minValue: zod.ZodOptional<zod.ZodString>;
@@ -1055,11 +1522,11 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1055
1522
  cache: zod.ZodOptional<zod.ZodString>;
1056
1523
  cycle: zod.ZodOptional<zod.ZodBoolean>;
1057
1524
  schema: zod.ZodString;
1058
- }, {
1525
+ } & {
1059
1526
  type: zod.ZodEnum<["always", "byDefault"]>;
1060
- }>, "strip", zod.ZodTypeAny, {
1061
- name: string;
1527
+ }, "strip", zod.ZodTypeAny, {
1062
1528
  type: "always" | "byDefault";
1529
+ name: string;
1063
1530
  schema: string;
1064
1531
  increment?: string | undefined;
1065
1532
  minValue?: string | undefined;
@@ -1068,8 +1535,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1068
1535
  cache?: string | undefined;
1069
1536
  cycle?: boolean | undefined;
1070
1537
  }, {
1071
- name: string;
1072
1538
  type: "always" | "byDefault";
1539
+ name: string;
1073
1540
  schema: string;
1074
1541
  increment?: string | undefined;
1075
1542
  minValue?: string | undefined;
@@ -1079,22 +1546,22 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1079
1546
  cycle?: boolean | undefined;
1080
1547
  }>>;
1081
1548
  }, "strict", zod.ZodTypeAny, {
1082
- name: string;
1083
1549
  type: string;
1550
+ name: string;
1084
1551
  primaryKey: boolean;
1085
1552
  notNull: boolean;
1086
- isUnique?: any;
1553
+ typeSchema?: string | undefined;
1087
1554
  default?: any;
1555
+ isUnique?: any;
1556
+ uniqueName?: string | undefined;
1557
+ nullsNotDistinct?: boolean | undefined;
1088
1558
  generated?: {
1089
1559
  type: "stored";
1090
1560
  as: string;
1091
1561
  } | undefined;
1092
- typeSchema?: string | undefined;
1093
- uniqueName?: string | undefined;
1094
- nullsNotDistinct?: boolean | undefined;
1095
1562
  identity?: {
1096
- name: string;
1097
1563
  type: "always" | "byDefault";
1564
+ name: string;
1098
1565
  schema: string;
1099
1566
  increment?: string | undefined;
1100
1567
  minValue?: string | undefined;
@@ -1104,22 +1571,22 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1104
1571
  cycle?: boolean | undefined;
1105
1572
  } | undefined;
1106
1573
  }, {
1107
- name: string;
1108
1574
  type: string;
1575
+ name: string;
1109
1576
  primaryKey: boolean;
1110
1577
  notNull: boolean;
1111
- isUnique?: any;
1578
+ typeSchema?: string | undefined;
1112
1579
  default?: any;
1580
+ isUnique?: any;
1581
+ uniqueName?: string | undefined;
1582
+ nullsNotDistinct?: boolean | undefined;
1113
1583
  generated?: {
1114
1584
  type: "stored";
1115
1585
  as: string;
1116
1586
  } | undefined;
1117
- typeSchema?: string | undefined;
1118
- uniqueName?: string | undefined;
1119
- nullsNotDistinct?: boolean | undefined;
1120
1587
  identity?: {
1121
- name: string;
1122
1588
  type: "always" | "byDefault";
1589
+ name: string;
1123
1590
  schema: string;
1124
1591
  increment?: string | undefined;
1125
1592
  minValue?: string | undefined;
@@ -1131,11 +1598,11 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1131
1598
  }>>;
1132
1599
  definition: zod.ZodOptional<zod.ZodString>;
1133
1600
  materialized: zod.ZodBoolean;
1134
- with: zod.ZodOptional<zod.ZodObject<zod.objectUtil.extendShape<{
1601
+ with: zod.ZodOptional<zod.ZodObject<{
1135
1602
  checkOption: zod.ZodOptional<zod.ZodEnum<["local", "cascaded"]>>;
1136
1603
  securityBarrier: zod.ZodOptional<zod.ZodBoolean>;
1137
1604
  securityInvoker: zod.ZodOptional<zod.ZodBoolean>;
1138
- }, {
1605
+ } & {
1139
1606
  fillfactor: zod.ZodOptional<zod.ZodNumber>;
1140
1607
  toastTupleTarget: zod.ZodOptional<zod.ZodNumber>;
1141
1608
  parallelWorkers: zod.ZodOptional<zod.ZodNumber>;
@@ -1154,7 +1621,7 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1154
1621
  autovacuumMultixactFreezeTableAge: zod.ZodOptional<zod.ZodNumber>;
1155
1622
  logAutovacuumMinDuration: zod.ZodOptional<zod.ZodNumber>;
1156
1623
  userCatalogTable: zod.ZodOptional<zod.ZodBoolean>;
1157
- }>, "strict", zod.ZodTypeAny, {
1624
+ }, "strict", zod.ZodTypeAny, {
1158
1625
  checkOption?: "local" | "cascaded" | undefined;
1159
1626
  securityBarrier?: boolean | undefined;
1160
1627
  securityInvoker?: boolean | undefined;
@@ -1205,23 +1672,24 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1205
1672
  tablespace: zod.ZodOptional<zod.ZodString>;
1206
1673
  }, "strict", zod.ZodTypeAny, {
1207
1674
  name: string;
1675
+ schema: string;
1208
1676
  columns: Record<string, {
1209
- name: string;
1210
1677
  type: string;
1678
+ name: string;
1211
1679
  primaryKey: boolean;
1212
1680
  notNull: boolean;
1213
- isUnique?: any;
1681
+ typeSchema?: string | undefined;
1214
1682
  default?: any;
1683
+ isUnique?: any;
1684
+ uniqueName?: string | undefined;
1685
+ nullsNotDistinct?: boolean | undefined;
1215
1686
  generated?: {
1216
1687
  type: "stored";
1217
1688
  as: string;
1218
1689
  } | undefined;
1219
- typeSchema?: string | undefined;
1220
- uniqueName?: string | undefined;
1221
- nullsNotDistinct?: boolean | undefined;
1222
1690
  identity?: {
1223
- name: string;
1224
1691
  type: "always" | "byDefault";
1692
+ name: string;
1225
1693
  schema: string;
1226
1694
  increment?: string | undefined;
1227
1695
  minValue?: string | undefined;
@@ -1231,11 +1699,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1231
1699
  cycle?: boolean | undefined;
1232
1700
  } | undefined;
1233
1701
  }>;
1234
- schema: string;
1235
- isExisting: boolean;
1236
1702
  materialized: boolean;
1237
- using?: string | undefined;
1238
- definition?: string | undefined;
1703
+ isExisting: boolean;
1239
1704
  with?: {
1240
1705
  checkOption?: "local" | "cascaded" | undefined;
1241
1706
  securityBarrier?: boolean | undefined;
@@ -1259,27 +1724,30 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1259
1724
  logAutovacuumMinDuration?: number | undefined;
1260
1725
  userCatalogTable?: boolean | undefined;
1261
1726
  } | undefined;
1727
+ using?: string | undefined;
1728
+ definition?: string | undefined;
1262
1729
  withNoData?: boolean | undefined;
1263
1730
  tablespace?: string | undefined;
1264
1731
  }, {
1265
1732
  name: string;
1733
+ schema: string;
1266
1734
  columns: Record<string, {
1267
- name: string;
1268
1735
  type: string;
1736
+ name: string;
1269
1737
  primaryKey: boolean;
1270
1738
  notNull: boolean;
1271
- isUnique?: any;
1739
+ typeSchema?: string | undefined;
1272
1740
  default?: any;
1741
+ isUnique?: any;
1742
+ uniqueName?: string | undefined;
1743
+ nullsNotDistinct?: boolean | undefined;
1273
1744
  generated?: {
1274
1745
  type: "stored";
1275
1746
  as: string;
1276
1747
  } | undefined;
1277
- typeSchema?: string | undefined;
1278
- uniqueName?: string | undefined;
1279
- nullsNotDistinct?: boolean | undefined;
1280
1748
  identity?: {
1281
- name: string;
1282
1749
  type: "always" | "byDefault";
1750
+ name: string;
1283
1751
  schema: string;
1284
1752
  increment?: string | undefined;
1285
1753
  minValue?: string | undefined;
@@ -1289,11 +1757,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1289
1757
  cycle?: boolean | undefined;
1290
1758
  } | undefined;
1291
1759
  }>;
1292
- schema: string;
1293
- isExisting: boolean;
1294
1760
  materialized: boolean;
1295
- using?: string | undefined;
1296
- definition?: string | undefined;
1761
+ isExisting: boolean;
1297
1762
  with?: {
1298
1763
  checkOption?: "local" | "cascaded" | undefined;
1299
1764
  securityBarrier?: boolean | undefined;
@@ -1317,6 +1782,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1317
1782
  logAutovacuumMinDuration?: number | undefined;
1318
1783
  userCatalogTable?: boolean | undefined;
1319
1784
  } | undefined;
1785
+ using?: string | undefined;
1786
+ definition?: string | undefined;
1320
1787
  withNoData?: boolean | undefined;
1321
1788
  tablespace?: string | undefined;
1322
1789
  }>>>;
@@ -1375,20 +1842,20 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1375
1842
  schema: zod.ZodOptional<zod.ZodString>;
1376
1843
  }, "strict", zod.ZodTypeAny, {
1377
1844
  name: string;
1378
- using?: string | undefined;
1379
- as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1380
1845
  schema?: string | undefined;
1846
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1381
1847
  for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1382
1848
  to?: string[] | undefined;
1849
+ using?: string | undefined;
1383
1850
  withCheck?: string | undefined;
1384
1851
  on?: string | undefined;
1385
1852
  }, {
1386
1853
  name: string;
1387
- using?: string | undefined;
1388
- as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1389
1854
  schema?: string | undefined;
1855
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1390
1856
  for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1391
1857
  to?: string[] | undefined;
1858
+ using?: string | undefined;
1392
1859
  withCheck?: string | undefined;
1393
1860
  on?: string | undefined;
1394
1861
  }>>>;
@@ -1397,12 +1864,12 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1397
1864
  tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
1398
1865
  columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
1399
1866
  }, "strip", zod.ZodTypeAny, {
1400
- columns: Record<string, string>;
1401
1867
  tables: Record<string, string>;
1868
+ columns: Record<string, string>;
1402
1869
  schemas: Record<string, string>;
1403
1870
  }, {
1404
- columns: Record<string, string>;
1405
1871
  tables: Record<string, string>;
1872
+ columns: Record<string, string>;
1406
1873
  schemas: Record<string, string>;
1407
1874
  }>;
1408
1875
  internal: zod.ZodOptional<zod.ZodObject<{
@@ -1413,73 +1880,76 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1413
1880
  rawType: zod.ZodOptional<zod.ZodString>;
1414
1881
  isDefaultAnExpression: zod.ZodOptional<zod.ZodBoolean>;
1415
1882
  }, "strip", zod.ZodTypeAny, {
1416
- isDefaultAnExpression?: boolean | undefined;
1417
1883
  isArray?: boolean | undefined;
1418
1884
  dimensions?: number | undefined;
1419
1885
  rawType?: string | undefined;
1420
- }, {
1421
1886
  isDefaultAnExpression?: boolean | undefined;
1887
+ }, {
1422
1888
  isArray?: boolean | undefined;
1423
1889
  dimensions?: number | undefined;
1424
1890
  rawType?: string | undefined;
1891
+ isDefaultAnExpression?: boolean | undefined;
1425
1892
  }>>>;
1426
1893
  }, "strip", zod.ZodTypeAny, {
1427
1894
  columns: Record<string, {
1428
- isDefaultAnExpression?: boolean | undefined;
1429
1895
  isArray?: boolean | undefined;
1430
1896
  dimensions?: number | undefined;
1431
1897
  rawType?: string | undefined;
1898
+ isDefaultAnExpression?: boolean | undefined;
1432
1899
  } | undefined>;
1433
1900
  }, {
1434
1901
  columns: Record<string, {
1435
- isDefaultAnExpression?: boolean | undefined;
1436
1902
  isArray?: boolean | undefined;
1437
1903
  dimensions?: number | undefined;
1438
1904
  rawType?: string | undefined;
1905
+ isDefaultAnExpression?: boolean | undefined;
1439
1906
  } | undefined>;
1440
1907
  }>>>;
1441
1908
  }, "strip", zod.ZodTypeAny, {
1442
1909
  tables: Record<string, {
1443
1910
  columns: Record<string, {
1444
- isDefaultAnExpression?: boolean | undefined;
1445
1911
  isArray?: boolean | undefined;
1446
1912
  dimensions?: number | undefined;
1447
1913
  rawType?: string | undefined;
1914
+ isDefaultAnExpression?: boolean | undefined;
1448
1915
  } | undefined>;
1449
1916
  } | undefined>;
1450
1917
  }, {
1451
1918
  tables: Record<string, {
1452
1919
  columns: Record<string, {
1453
- isDefaultAnExpression?: boolean | undefined;
1454
1920
  isArray?: boolean | undefined;
1455
1921
  dimensions?: number | undefined;
1456
1922
  rawType?: string | undefined;
1923
+ isDefaultAnExpression?: boolean | undefined;
1457
1924
  } | undefined>;
1458
1925
  } | undefined>;
1459
1926
  }>>;
1460
- }, {
1927
+ } & {
1461
1928
  id: zod.ZodString;
1462
1929
  prevId: zod.ZodString;
1463
- }>, "strip", zod.ZodTypeAny, {
1930
+ }, "strip", zod.ZodTypeAny, {
1931
+ version: "7";
1932
+ dialect: "postgresql";
1464
1933
  tables: Record<string, {
1465
1934
  name: string;
1935
+ schema: string;
1466
1936
  columns: Record<string, {
1467
- name: string;
1468
1937
  type: string;
1938
+ name: string;
1469
1939
  primaryKey: boolean;
1470
1940
  notNull: boolean;
1471
- isUnique?: any;
1941
+ typeSchema?: string | undefined;
1472
1942
  default?: any;
1943
+ isUnique?: any;
1944
+ uniqueName?: string | undefined;
1945
+ nullsNotDistinct?: boolean | undefined;
1473
1946
  generated?: {
1474
1947
  type: "stored";
1475
1948
  as: string;
1476
1949
  } | undefined;
1477
- typeSchema?: string | undefined;
1478
- uniqueName?: string | undefined;
1479
- nullsNotDistinct?: boolean | undefined;
1480
1950
  identity?: {
1481
- name: string;
1482
1951
  type: "always" | "byDefault";
1952
+ name: string;
1483
1953
  schema: string;
1484
1954
  increment?: string | undefined;
1485
1955
  minValue?: string | undefined;
@@ -1492,8 +1962,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1492
1962
  indexes: Record<string, {
1493
1963
  name: string;
1494
1964
  columns: {
1495
- isExpression: boolean;
1496
1965
  expression: string;
1966
+ isExpression: boolean;
1497
1967
  asc: boolean;
1498
1968
  nulls?: string | undefined;
1499
1969
  opclass?: string | undefined;
@@ -1510,11 +1980,10 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1510
1980
  columnsFrom: string[];
1511
1981
  tableTo: string;
1512
1982
  columnsTo: string[];
1983
+ schemaTo?: string | undefined;
1513
1984
  onUpdate?: string | undefined;
1514
1985
  onDelete?: string | undefined;
1515
- schemaTo?: string | undefined;
1516
1986
  }>;
1517
- schema: string;
1518
1987
  compositePrimaryKeys: Record<string, {
1519
1988
  name: string;
1520
1989
  columns: string[];
@@ -1524,51 +1993,69 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1524
1993
  columns: string[];
1525
1994
  nullsNotDistinct: boolean;
1526
1995
  }>;
1527
- checkConstraints: Record<string, {
1528
- value: string;
1529
- name?: string | undefined;
1530
- }>;
1531
1996
  policies: Record<string, {
1532
1997
  name: string;
1533
- using?: string | undefined;
1534
- as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1535
1998
  schema?: string | undefined;
1999
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1536
2000
  for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1537
2001
  to?: string[] | undefined;
2002
+ using?: string | undefined;
1538
2003
  withCheck?: string | undefined;
1539
2004
  on?: string | undefined;
1540
2005
  }>;
2006
+ checkConstraints: Record<string, {
2007
+ value: string;
2008
+ name?: string | undefined;
2009
+ }>;
1541
2010
  isRLSEnabled: boolean;
1542
2011
  }>;
1543
- id: string;
1544
- prevId: string;
1545
- version: "8";
1546
- dialect: "postgresql";
2012
+ policies: Record<string, {
2013
+ name: string;
2014
+ schema?: string | undefined;
2015
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
2016
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
2017
+ to?: string[] | undefined;
2018
+ using?: string | undefined;
2019
+ withCheck?: string | undefined;
2020
+ on?: string | undefined;
2021
+ }>;
2022
+ enums: Record<string, {
2023
+ values: string[];
2024
+ name: string;
2025
+ schema: string;
2026
+ }>;
1547
2027
  schemas: Record<string, string>;
1548
- _meta: {
1549
- columns: Record<string, string>;
1550
- tables: Record<string, string>;
1551
- schemas: Record<string, string>;
1552
- };
2028
+ domains: Record<string, {
2029
+ name: string;
2030
+ schema: string;
2031
+ baseType: string;
2032
+ notNull?: boolean | undefined;
2033
+ checkConstraints?: Record<string, {
2034
+ value: string;
2035
+ name?: string | undefined;
2036
+ }> | undefined;
2037
+ defaultValue?: any;
2038
+ }>;
1553
2039
  views: Record<string, {
1554
2040
  name: string;
2041
+ schema: string;
1555
2042
  columns: Record<string, {
1556
- name: string;
1557
2043
  type: string;
2044
+ name: string;
1558
2045
  primaryKey: boolean;
1559
2046
  notNull: boolean;
1560
- isUnique?: any;
2047
+ typeSchema?: string | undefined;
1561
2048
  default?: any;
2049
+ isUnique?: any;
2050
+ uniqueName?: string | undefined;
2051
+ nullsNotDistinct?: boolean | undefined;
1562
2052
  generated?: {
1563
2053
  type: "stored";
1564
2054
  as: string;
1565
2055
  } | undefined;
1566
- typeSchema?: string | undefined;
1567
- uniqueName?: string | undefined;
1568
- nullsNotDistinct?: boolean | undefined;
1569
2056
  identity?: {
1570
- name: string;
1571
2057
  type: "always" | "byDefault";
2058
+ name: string;
1572
2059
  schema: string;
1573
2060
  increment?: string | undefined;
1574
2061
  minValue?: string | undefined;
@@ -1578,11 +2065,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1578
2065
  cycle?: boolean | undefined;
1579
2066
  } | undefined;
1580
2067
  }>;
1581
- schema: string;
1582
- isExisting: boolean;
1583
2068
  materialized: boolean;
1584
- using?: string | undefined;
1585
- definition?: string | undefined;
2069
+ isExisting: boolean;
1586
2070
  with?: {
1587
2071
  checkOption?: "local" | "cascaded" | undefined;
1588
2072
  securityBarrier?: boolean | undefined;
@@ -1606,24 +2090,11 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1606
2090
  logAutovacuumMinDuration?: number | undefined;
1607
2091
  userCatalogTable?: boolean | undefined;
1608
2092
  } | undefined;
2093
+ using?: string | undefined;
2094
+ definition?: string | undefined;
1609
2095
  withNoData?: boolean | undefined;
1610
2096
  tablespace?: string | undefined;
1611
2097
  }>;
1612
- enums: Record<string, {
1613
- name: string;
1614
- values: string[];
1615
- schema: string;
1616
- }>;
1617
- policies: Record<string, {
1618
- name: string;
1619
- using?: string | undefined;
1620
- as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1621
- schema?: string | undefined;
1622
- for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1623
- to?: string[] | undefined;
1624
- withCheck?: string | undefined;
1625
- on?: string | undefined;
1626
- }>;
1627
2098
  sequences: Record<string, {
1628
2099
  name: string;
1629
2100
  schema: string;
@@ -1640,47 +2111,46 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1640
2111
  createRole?: boolean | undefined;
1641
2112
  inherit?: boolean | undefined;
1642
2113
  }>;
1643
- domains: Record<string, {
1644
- name: string;
1645
- schema: string;
1646
- baseType: string;
1647
- notNull?: boolean | undefined;
1648
- checkConstraints?: Record<string, {
1649
- value: string;
1650
- name?: string | undefined;
1651
- }> | undefined;
1652
- defaultValue?: any;
1653
- }>;
2114
+ _meta: {
2115
+ tables: Record<string, string>;
2116
+ columns: Record<string, string>;
2117
+ schemas: Record<string, string>;
2118
+ };
2119
+ id: string;
2120
+ prevId: string;
1654
2121
  internal?: {
1655
2122
  tables: Record<string, {
1656
2123
  columns: Record<string, {
1657
- isDefaultAnExpression?: boolean | undefined;
1658
2124
  isArray?: boolean | undefined;
1659
2125
  dimensions?: number | undefined;
1660
2126
  rawType?: string | undefined;
2127
+ isDefaultAnExpression?: boolean | undefined;
1661
2128
  } | undefined>;
1662
2129
  } | undefined>;
1663
2130
  } | undefined;
1664
2131
  }, {
2132
+ version: "7";
2133
+ dialect: "postgresql";
1665
2134
  tables: Record<string, {
1666
2135
  name: string;
2136
+ schema: string;
1667
2137
  columns: Record<string, {
1668
- name: string;
1669
2138
  type: string;
2139
+ name: string;
1670
2140
  primaryKey: boolean;
1671
2141
  notNull: boolean;
1672
- isUnique?: any;
2142
+ typeSchema?: string | undefined;
1673
2143
  default?: any;
2144
+ isUnique?: any;
2145
+ uniqueName?: string | undefined;
2146
+ nullsNotDistinct?: boolean | undefined;
1674
2147
  generated?: {
1675
2148
  type: "stored";
1676
2149
  as: string;
1677
2150
  } | undefined;
1678
- typeSchema?: string | undefined;
1679
- uniqueName?: string | undefined;
1680
- nullsNotDistinct?: boolean | undefined;
1681
2151
  identity?: {
1682
- name: string;
1683
2152
  type: "always" | "byDefault";
2153
+ name: string;
1684
2154
  schema: string;
1685
2155
  increment?: string | undefined;
1686
2156
  minValue?: string | undefined;
@@ -1693,8 +2163,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1693
2163
  indexes: Record<string, {
1694
2164
  name: string;
1695
2165
  columns: {
1696
- isExpression: boolean;
1697
2166
  expression: string;
2167
+ isExpression: boolean;
1698
2168
  asc: boolean;
1699
2169
  nulls?: string | undefined;
1700
2170
  opclass?: string | undefined;
@@ -1711,11 +2181,10 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1711
2181
  columnsFrom: string[];
1712
2182
  tableTo: string;
1713
2183
  columnsTo: string[];
2184
+ schemaTo?: string | undefined;
1714
2185
  onUpdate?: string | undefined;
1715
2186
  onDelete?: string | undefined;
1716
- schemaTo?: string | undefined;
1717
2187
  }>;
1718
- schema: string;
1719
2188
  compositePrimaryKeys: Record<string, {
1720
2189
  name: string;
1721
2190
  columns: string[];
@@ -1725,38 +2194,46 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1725
2194
  columns: string[];
1726
2195
  nullsNotDistinct: boolean;
1727
2196
  }> | undefined;
1728
- checkConstraints?: Record<string, {
1729
- value: string;
1730
- name?: string | undefined;
1731
- }> | undefined;
1732
2197
  policies?: Record<string, {
1733
2198
  name: string;
1734
- using?: string | undefined;
1735
- as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1736
2199
  schema?: string | undefined;
2200
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1737
2201
  for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1738
2202
  to?: string[] | undefined;
2203
+ using?: string | undefined;
1739
2204
  withCheck?: string | undefined;
1740
2205
  on?: string | undefined;
1741
2206
  }> | undefined;
2207
+ checkConstraints?: Record<string, {
2208
+ value: string;
2209
+ name?: string | undefined;
2210
+ }> | undefined;
1742
2211
  isRLSEnabled?: boolean | undefined;
1743
2212
  }>;
1744
- id: string;
1745
- prevId: string;
1746
- version: "8";
1747
- dialect: "postgresql";
2213
+ enums: Record<string, {
2214
+ values: string[];
2215
+ name: string;
2216
+ schema: string;
2217
+ }>;
1748
2218
  schemas: Record<string, string>;
1749
2219
  _meta: {
1750
- columns: Record<string, string>;
1751
2220
  tables: Record<string, string>;
2221
+ columns: Record<string, string>;
1752
2222
  schemas: Record<string, string>;
1753
2223
  };
1754
- enums: Record<string, {
2224
+ id: string;
2225
+ prevId: string;
2226
+ policies?: Record<string, {
1755
2227
  name: string;
1756
- values: string[];
1757
- schema: string;
1758
- }>;
1759
- domains: Record<string, {
2228
+ schema?: string | undefined;
2229
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
2230
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
2231
+ to?: string[] | undefined;
2232
+ using?: string | undefined;
2233
+ withCheck?: string | undefined;
2234
+ on?: string | undefined;
2235
+ }> | undefined;
2236
+ domains?: Record<string, {
1760
2237
  name: string;
1761
2238
  schema: string;
1762
2239
  baseType: string;
@@ -1766,36 +2243,27 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1766
2243
  name?: string | undefined;
1767
2244
  }> | undefined;
1768
2245
  defaultValue?: any;
1769
- }>;
1770
- internal?: {
1771
- tables: Record<string, {
1772
- columns: Record<string, {
1773
- isDefaultAnExpression?: boolean | undefined;
1774
- isArray?: boolean | undefined;
1775
- dimensions?: number | undefined;
1776
- rawType?: string | undefined;
1777
- } | undefined>;
1778
- } | undefined>;
1779
- } | undefined;
2246
+ }> | undefined;
1780
2247
  views?: Record<string, {
1781
2248
  name: string;
2249
+ schema: string;
1782
2250
  columns: Record<string, {
1783
- name: string;
1784
2251
  type: string;
2252
+ name: string;
1785
2253
  primaryKey: boolean;
1786
2254
  notNull: boolean;
1787
- isUnique?: any;
2255
+ typeSchema?: string | undefined;
1788
2256
  default?: any;
2257
+ isUnique?: any;
2258
+ uniqueName?: string | undefined;
2259
+ nullsNotDistinct?: boolean | undefined;
1789
2260
  generated?: {
1790
2261
  type: "stored";
1791
2262
  as: string;
1792
2263
  } | undefined;
1793
- typeSchema?: string | undefined;
1794
- uniqueName?: string | undefined;
1795
- nullsNotDistinct?: boolean | undefined;
1796
2264
  identity?: {
1797
- name: string;
1798
2265
  type: "always" | "byDefault";
2266
+ name: string;
1799
2267
  schema: string;
1800
2268
  increment?: string | undefined;
1801
2269
  minValue?: string | undefined;
@@ -1805,11 +2273,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1805
2273
  cycle?: boolean | undefined;
1806
2274
  } | undefined;
1807
2275
  }>;
1808
- schema: string;
1809
- isExisting: boolean;
1810
2276
  materialized: boolean;
1811
- using?: string | undefined;
1812
- definition?: string | undefined;
2277
+ isExisting: boolean;
1813
2278
  with?: {
1814
2279
  checkOption?: "local" | "cascaded" | undefined;
1815
2280
  securityBarrier?: boolean | undefined;
@@ -1831,20 +2296,12 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1831
2296
  autovacuumMultixactFreezeMaxAge?: number | undefined;
1832
2297
  autovacuumMultixactFreezeTableAge?: number | undefined;
1833
2298
  logAutovacuumMinDuration?: number | undefined;
1834
- userCatalogTable?: boolean | undefined;
1835
- } | undefined;
1836
- withNoData?: boolean | undefined;
1837
- tablespace?: string | undefined;
1838
- }> | undefined;
1839
- policies?: Record<string, {
1840
- name: string;
1841
- using?: string | undefined;
1842
- as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1843
- schema?: string | undefined;
1844
- for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1845
- to?: string[] | undefined;
1846
- withCheck?: string | undefined;
1847
- on?: string | undefined;
2299
+ userCatalogTable?: boolean | undefined;
2300
+ } | undefined;
2301
+ using?: string | undefined;
2302
+ definition?: string | undefined;
2303
+ withNoData?: boolean | undefined;
2304
+ tablespace?: string | undefined;
1848
2305
  }> | undefined;
1849
2306
  sequences?: Record<string, {
1850
2307
  name: string;
@@ -1862,10 +2319,20 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1862
2319
  createRole?: boolean | undefined;
1863
2320
  inherit?: boolean | undefined;
1864
2321
  }> | undefined;
2322
+ internal?: {
2323
+ tables: Record<string, {
2324
+ columns: Record<string, {
2325
+ isArray?: boolean | undefined;
2326
+ dimensions?: number | undefined;
2327
+ rawType?: string | undefined;
2328
+ isDefaultAnExpression?: boolean | undefined;
2329
+ } | undefined>;
2330
+ } | undefined>;
2331
+ } | undefined;
1865
2332
  }>;
1866
2333
  type PgSchema = TypeOf<typeof pgSchema>;
1867
2334
 
1868
- declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
2335
+ declare const schema$1: zod.ZodObject<{
1869
2336
  version: zod.ZodLiteral<"1">;
1870
2337
  dialect: zod.ZodLiteral<"singlestore">;
1871
2338
  tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
@@ -1889,29 +2356,29 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
1889
2356
  as: string;
1890
2357
  }>>;
1891
2358
  }, "strict", zod.ZodTypeAny, {
1892
- name: string;
1893
2359
  type: string;
2360
+ name: string;
1894
2361
  primaryKey: boolean;
1895
2362
  notNull: boolean;
1896
2363
  default?: any;
1897
- onUpdate?: any;
1898
- autoincrement?: boolean | undefined;
1899
2364
  generated?: {
1900
2365
  type: "stored" | "virtual";
1901
2366
  as: string;
1902
2367
  } | undefined;
2368
+ onUpdate?: any;
2369
+ autoincrement?: boolean | undefined;
1903
2370
  }, {
1904
- name: string;
1905
2371
  type: string;
2372
+ name: string;
1906
2373
  primaryKey: boolean;
1907
2374
  notNull: boolean;
1908
2375
  default?: any;
1909
- onUpdate?: any;
1910
- autoincrement?: boolean | undefined;
1911
2376
  generated?: {
1912
2377
  type: "stored" | "virtual";
1913
2378
  as: string;
1914
2379
  } | undefined;
2380
+ onUpdate?: any;
2381
+ autoincrement?: boolean | undefined;
1915
2382
  }>>;
1916
2383
  indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1917
2384
  name: zod.ZodString;
@@ -1926,14 +2393,14 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
1926
2393
  isUnique: boolean;
1927
2394
  using?: "btree" | "hash" | undefined;
1928
2395
  algorithm?: "default" | "inplace" | "copy" | undefined;
1929
- lock?: "none" | "default" | "shared" | "exclusive" | undefined;
2396
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1930
2397
  }, {
1931
2398
  name: string;
1932
2399
  columns: string[];
1933
2400
  isUnique: boolean;
1934
2401
  using?: "btree" | "hash" | undefined;
1935
2402
  algorithm?: "default" | "inplace" | "copy" | undefined;
1936
- lock?: "none" | "default" | "shared" | "exclusive" | undefined;
2403
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1937
2404
  }>>;
1938
2405
  compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1939
2406
  name: zod.ZodString;
@@ -1958,17 +2425,17 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
1958
2425
  }, "strict", zod.ZodTypeAny, {
1959
2426
  name: string;
1960
2427
  columns: Record<string, {
1961
- name: string;
1962
2428
  type: string;
2429
+ name: string;
1963
2430
  primaryKey: boolean;
1964
2431
  notNull: boolean;
1965
2432
  default?: any;
1966
- onUpdate?: any;
1967
- autoincrement?: boolean | undefined;
1968
2433
  generated?: {
1969
2434
  type: "stored" | "virtual";
1970
2435
  as: string;
1971
2436
  } | undefined;
2437
+ onUpdate?: any;
2438
+ autoincrement?: boolean | undefined;
1972
2439
  }>;
1973
2440
  indexes: Record<string, {
1974
2441
  name: string;
@@ -1976,7 +2443,7 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
1976
2443
  isUnique: boolean;
1977
2444
  using?: "btree" | "hash" | undefined;
1978
2445
  algorithm?: "default" | "inplace" | "copy" | undefined;
1979
- lock?: "none" | "default" | "shared" | "exclusive" | undefined;
2446
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1980
2447
  }>;
1981
2448
  compositePrimaryKeys: Record<string, {
1982
2449
  name: string;
@@ -1989,17 +2456,17 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
1989
2456
  }, {
1990
2457
  name: string;
1991
2458
  columns: Record<string, {
1992
- name: string;
1993
2459
  type: string;
2460
+ name: string;
1994
2461
  primaryKey: boolean;
1995
2462
  notNull: boolean;
1996
2463
  default?: any;
1997
- onUpdate?: any;
1998
- autoincrement?: boolean | undefined;
1999
2464
  generated?: {
2000
2465
  type: "stored" | "virtual";
2001
2466
  as: string;
2002
2467
  } | undefined;
2468
+ onUpdate?: any;
2469
+ autoincrement?: boolean | undefined;
2003
2470
  }>;
2004
2471
  indexes: Record<string, {
2005
2472
  name: string;
@@ -2007,7 +2474,7 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
2007
2474
  isUnique: boolean;
2008
2475
  using?: "btree" | "hash" | undefined;
2009
2476
  algorithm?: "default" | "inplace" | "copy" | undefined;
2010
- lock?: "none" | "default" | "shared" | "exclusive" | undefined;
2477
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2011
2478
  }>;
2012
2479
  compositePrimaryKeys: Record<string, {
2013
2480
  name: string;
@@ -2022,11 +2489,11 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
2022
2489
  tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
2023
2490
  columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
2024
2491
  }, "strip", zod.ZodTypeAny, {
2025
- columns: Record<string, string>;
2026
2492
  tables: Record<string, string>;
2027
- }, {
2028
2493
  columns: Record<string, string>;
2494
+ }, {
2029
2495
  tables: Record<string, string>;
2496
+ columns: Record<string, string>;
2030
2497
  }>;
2031
2498
  internal: zod.ZodOptional<zod.ZodObject<{
2032
2499
  tables: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
@@ -2064,46 +2531,48 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
2064
2531
  } | undefined>;
2065
2532
  }>>>>;
2066
2533
  }, "strip", zod.ZodTypeAny, {
2067
- indexes?: Record<string, {
2068
- columns: Record<string, {
2069
- isExpression?: boolean | undefined;
2070
- } | undefined>;
2071
- } | undefined> | undefined;
2072
2534
  tables?: Record<string, {
2073
2535
  columns: Record<string, {
2074
2536
  isDefaultAnExpression?: boolean | undefined;
2075
2537
  } | undefined>;
2076
2538
  } | undefined> | undefined;
2077
- }, {
2078
2539
  indexes?: Record<string, {
2079
2540
  columns: Record<string, {
2080
2541
  isExpression?: boolean | undefined;
2081
2542
  } | undefined>;
2082
2543
  } | undefined> | undefined;
2544
+ }, {
2083
2545
  tables?: Record<string, {
2084
2546
  columns: Record<string, {
2085
2547
  isDefaultAnExpression?: boolean | undefined;
2086
2548
  } | undefined>;
2087
2549
  } | undefined> | undefined;
2550
+ indexes?: Record<string, {
2551
+ columns: Record<string, {
2552
+ isExpression?: boolean | undefined;
2553
+ } | undefined>;
2554
+ } | undefined> | undefined;
2088
2555
  }>>;
2089
- }, {
2556
+ } & {
2090
2557
  id: zod.ZodString;
2091
2558
  prevId: zod.ZodString;
2092
- }>, "strip", zod.ZodTypeAny, {
2559
+ }, "strip", zod.ZodTypeAny, {
2560
+ version: "1";
2561
+ dialect: "singlestore";
2093
2562
  tables: Record<string, {
2094
2563
  name: string;
2095
2564
  columns: Record<string, {
2096
- name: string;
2097
2565
  type: string;
2566
+ name: string;
2098
2567
  primaryKey: boolean;
2099
2568
  notNull: boolean;
2100
2569
  default?: any;
2101
- onUpdate?: any;
2102
- autoincrement?: boolean | undefined;
2103
2570
  generated?: {
2104
2571
  type: "stored" | "virtual";
2105
2572
  as: string;
2106
2573
  } | undefined;
2574
+ onUpdate?: any;
2575
+ autoincrement?: boolean | undefined;
2107
2576
  }>;
2108
2577
  indexes: Record<string, {
2109
2578
  name: string;
@@ -2111,7 +2580,7 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
2111
2580
  isUnique: boolean;
2112
2581
  using?: "btree" | "hash" | undefined;
2113
2582
  algorithm?: "default" | "inplace" | "copy" | undefined;
2114
- lock?: "none" | "default" | "shared" | "exclusive" | undefined;
2583
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2115
2584
  }>;
2116
2585
  compositePrimaryKeys: Record<string, {
2117
2586
  name: string;
@@ -2122,41 +2591,41 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
2122
2591
  columns: string[];
2123
2592
  }>;
2124
2593
  }>;
2125
- id: string;
2126
- prevId: string;
2127
- version: "1";
2128
- dialect: "singlestore";
2129
2594
  _meta: {
2130
- columns: Record<string, string>;
2131
2595
  tables: Record<string, string>;
2596
+ columns: Record<string, string>;
2132
2597
  };
2598
+ id: string;
2599
+ prevId: string;
2133
2600
  internal?: {
2134
- indexes?: Record<string, {
2601
+ tables?: Record<string, {
2135
2602
  columns: Record<string, {
2136
- isExpression?: boolean | undefined;
2603
+ isDefaultAnExpression?: boolean | undefined;
2137
2604
  } | undefined>;
2138
2605
  } | undefined> | undefined;
2139
- tables?: Record<string, {
2606
+ indexes?: Record<string, {
2140
2607
  columns: Record<string, {
2141
- isDefaultAnExpression?: boolean | undefined;
2608
+ isExpression?: boolean | undefined;
2142
2609
  } | undefined>;
2143
2610
  } | undefined> | undefined;
2144
2611
  } | undefined;
2145
2612
  }, {
2613
+ version: "1";
2614
+ dialect: "singlestore";
2146
2615
  tables: Record<string, {
2147
2616
  name: string;
2148
2617
  columns: Record<string, {
2149
- name: string;
2150
2618
  type: string;
2619
+ name: string;
2151
2620
  primaryKey: boolean;
2152
2621
  notNull: boolean;
2153
2622
  default?: any;
2154
- onUpdate?: any;
2155
- autoincrement?: boolean | undefined;
2156
2623
  generated?: {
2157
2624
  type: "stored" | "virtual";
2158
2625
  as: string;
2159
2626
  } | undefined;
2627
+ onUpdate?: any;
2628
+ autoincrement?: boolean | undefined;
2160
2629
  }>;
2161
2630
  indexes: Record<string, {
2162
2631
  name: string;
@@ -2164,7 +2633,7 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
2164
2633
  isUnique: boolean;
2165
2634
  using?: "btree" | "hash" | undefined;
2166
2635
  algorithm?: "default" | "inplace" | "copy" | undefined;
2167
- lock?: "none" | "default" | "shared" | "exclusive" | undefined;
2636
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2168
2637
  }>;
2169
2638
  compositePrimaryKeys: Record<string, {
2170
2639
  name: string;
@@ -2175,30 +2644,28 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
2175
2644
  columns: string[];
2176
2645
  }> | undefined;
2177
2646
  }>;
2178
- id: string;
2179
- prevId: string;
2180
- version: "1";
2181
- dialect: "singlestore";
2182
2647
  _meta: {
2183
- columns: Record<string, string>;
2184
2648
  tables: Record<string, string>;
2649
+ columns: Record<string, string>;
2185
2650
  };
2651
+ id: string;
2652
+ prevId: string;
2186
2653
  internal?: {
2187
- indexes?: Record<string, {
2654
+ tables?: Record<string, {
2188
2655
  columns: Record<string, {
2189
- isExpression?: boolean | undefined;
2656
+ isDefaultAnExpression?: boolean | undefined;
2190
2657
  } | undefined>;
2191
2658
  } | undefined> | undefined;
2192
- tables?: Record<string, {
2659
+ indexes?: Record<string, {
2193
2660
  columns: Record<string, {
2194
- isDefaultAnExpression?: boolean | undefined;
2661
+ isExpression?: boolean | undefined;
2195
2662
  } | undefined>;
2196
2663
  } | undefined> | undefined;
2197
2664
  } | undefined;
2198
2665
  }>;
2199
2666
  type SingleStoreSchema = TypeOf<typeof schema$1>;
2200
2667
 
2201
- declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
2668
+ declare const schema: zod.ZodObject<{
2202
2669
  version: zod.ZodLiteral<"6">;
2203
2670
  dialect: zod.ZodEnum<["sqlite"]>;
2204
2671
  tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
@@ -2221,27 +2688,27 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
2221
2688
  as: string;
2222
2689
  }>>;
2223
2690
  }, "strict", zod.ZodTypeAny, {
2224
- name: string;
2225
2691
  type: string;
2692
+ name: string;
2226
2693
  primaryKey: boolean;
2227
2694
  notNull: boolean;
2228
2695
  default?: any;
2229
- autoincrement?: boolean | undefined;
2230
2696
  generated?: {
2231
2697
  type: "stored" | "virtual";
2232
2698
  as: string;
2233
2699
  } | undefined;
2700
+ autoincrement?: boolean | undefined;
2234
2701
  }, {
2235
- name: string;
2236
2702
  type: string;
2703
+ name: string;
2237
2704
  primaryKey: boolean;
2238
2705
  notNull: boolean;
2239
2706
  default?: any;
2240
- autoincrement?: boolean | undefined;
2241
2707
  generated?: {
2242
2708
  type: "stored" | "virtual";
2243
2709
  as: string;
2244
2710
  } | undefined;
2711
+ autoincrement?: boolean | undefined;
2245
2712
  }>>;
2246
2713
  indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
2247
2714
  name: zod.ZodString;
@@ -2308,25 +2775,25 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
2308
2775
  name: zod.ZodString;
2309
2776
  value: zod.ZodString;
2310
2777
  }, "strict", zod.ZodTypeAny, {
2311
- name: string;
2312
2778
  value: string;
2313
- }, {
2314
2779
  name: string;
2780
+ }, {
2315
2781
  value: string;
2782
+ name: string;
2316
2783
  }>>>;
2317
2784
  }, "strict", zod.ZodTypeAny, {
2318
2785
  name: string;
2319
2786
  columns: Record<string, {
2320
- name: string;
2321
2787
  type: string;
2788
+ name: string;
2322
2789
  primaryKey: boolean;
2323
2790
  notNull: boolean;
2324
2791
  default?: any;
2325
- autoincrement?: boolean | undefined;
2326
2792
  generated?: {
2327
2793
  type: "stored" | "virtual";
2328
2794
  as: string;
2329
2795
  } | undefined;
2796
+ autoincrement?: boolean | undefined;
2330
2797
  }>;
2331
2798
  indexes: Record<string, {
2332
2799
  name: string;
@@ -2352,22 +2819,22 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
2352
2819
  columns: string[];
2353
2820
  }>;
2354
2821
  checkConstraints: Record<string, {
2355
- name: string;
2356
2822
  value: string;
2823
+ name: string;
2357
2824
  }>;
2358
2825
  }, {
2359
2826
  name: string;
2360
2827
  columns: Record<string, {
2361
- name: string;
2362
2828
  type: string;
2829
+ name: string;
2363
2830
  primaryKey: boolean;
2364
2831
  notNull: boolean;
2365
2832
  default?: any;
2366
- autoincrement?: boolean | undefined;
2367
2833
  generated?: {
2368
2834
  type: "stored" | "virtual";
2369
2835
  as: string;
2370
2836
  } | undefined;
2837
+ autoincrement?: boolean | undefined;
2371
2838
  }>;
2372
2839
  indexes: Record<string, {
2373
2840
  name: string;
@@ -2393,8 +2860,8 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
2393
2860
  columns: string[];
2394
2861
  }> | undefined;
2395
2862
  checkConstraints?: Record<string, {
2396
- name: string;
2397
2863
  value: string;
2864
+ name: string;
2398
2865
  }> | undefined;
2399
2866
  }>>;
2400
2867
  views: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
@@ -2417,59 +2884,59 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
2417
2884
  as: string;
2418
2885
  }>>;
2419
2886
  }, "strict", zod.ZodTypeAny, {
2420
- name: string;
2421
2887
  type: string;
2888
+ name: string;
2422
2889
  primaryKey: boolean;
2423
2890
  notNull: boolean;
2424
2891
  default?: any;
2425
- autoincrement?: boolean | undefined;
2426
2892
  generated?: {
2427
2893
  type: "stored" | "virtual";
2428
2894
  as: string;
2429
2895
  } | undefined;
2896
+ autoincrement?: boolean | undefined;
2430
2897
  }, {
2431
- name: string;
2432
2898
  type: string;
2899
+ name: string;
2433
2900
  primaryKey: boolean;
2434
2901
  notNull: boolean;
2435
2902
  default?: any;
2436
- autoincrement?: boolean | undefined;
2437
2903
  generated?: {
2438
2904
  type: "stored" | "virtual";
2439
2905
  as: string;
2440
2906
  } | undefined;
2907
+ autoincrement?: boolean | undefined;
2441
2908
  }>>;
2442
2909
  definition: zod.ZodOptional<zod.ZodString>;
2443
2910
  isExisting: zod.ZodBoolean;
2444
2911
  }, "strict", zod.ZodTypeAny, {
2445
2912
  name: string;
2446
2913
  columns: Record<string, {
2447
- name: string;
2448
2914
  type: string;
2915
+ name: string;
2449
2916
  primaryKey: boolean;
2450
2917
  notNull: boolean;
2451
2918
  default?: any;
2452
- autoincrement?: boolean | undefined;
2453
2919
  generated?: {
2454
2920
  type: "stored" | "virtual";
2455
2921
  as: string;
2456
2922
  } | undefined;
2923
+ autoincrement?: boolean | undefined;
2457
2924
  }>;
2458
2925
  isExisting: boolean;
2459
2926
  definition?: string | undefined;
2460
2927
  }, {
2461
2928
  name: string;
2462
2929
  columns: Record<string, {
2463
- name: string;
2464
2930
  type: string;
2931
+ name: string;
2465
2932
  primaryKey: boolean;
2466
2933
  notNull: boolean;
2467
2934
  default?: any;
2468
- autoincrement?: boolean | undefined;
2469
2935
  generated?: {
2470
2936
  type: "stored" | "virtual";
2471
2937
  as: string;
2472
2938
  } | undefined;
2939
+ autoincrement?: boolean | undefined;
2473
2940
  }>;
2474
2941
  isExisting: boolean;
2475
2942
  definition?: string | undefined;
@@ -2479,11 +2946,11 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
2479
2946
  tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
2480
2947
  columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
2481
2948
  }, "strip", zod.ZodTypeAny, {
2482
- columns: Record<string, string>;
2483
2949
  tables: Record<string, string>;
2484
- }, {
2485
2950
  columns: Record<string, string>;
2951
+ }, {
2486
2952
  tables: Record<string, string>;
2953
+ columns: Record<string, string>;
2487
2954
  }>;
2488
2955
  internal: zod.ZodOptional<zod.ZodObject<{
2489
2956
  indexes: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
@@ -2516,23 +2983,25 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
2516
2983
  } | undefined>;
2517
2984
  } | undefined> | undefined;
2518
2985
  }>>;
2519
- }, {
2986
+ } & {
2520
2987
  id: zod.ZodString;
2521
2988
  prevId: zod.ZodString;
2522
- }>, "strict", zod.ZodTypeAny, {
2989
+ }, "strict", zod.ZodTypeAny, {
2990
+ version: "6";
2991
+ dialect: "sqlite";
2523
2992
  tables: Record<string, {
2524
2993
  name: string;
2525
2994
  columns: Record<string, {
2526
- name: string;
2527
2995
  type: string;
2996
+ name: string;
2528
2997
  primaryKey: boolean;
2529
2998
  notNull: boolean;
2530
2999
  default?: any;
2531
- autoincrement?: boolean | undefined;
2532
3000
  generated?: {
2533
3001
  type: "stored" | "virtual";
2534
3002
  as: string;
2535
3003
  } | undefined;
3004
+ autoincrement?: boolean | undefined;
2536
3005
  }>;
2537
3006
  indexes: Record<string, {
2538
3007
  name: string;
@@ -2558,36 +3027,34 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
2558
3027
  columns: string[];
2559
3028
  }>;
2560
3029
  checkConstraints: Record<string, {
2561
- name: string;
2562
3030
  value: string;
3031
+ name: string;
2563
3032
  }>;
2564
3033
  }>;
2565
- id: string;
2566
- prevId: string;
2567
- version: "6";
2568
- dialect: "sqlite";
2569
- _meta: {
2570
- columns: Record<string, string>;
2571
- tables: Record<string, string>;
2572
- };
3034
+ enums: {};
2573
3035
  views: Record<string, {
2574
3036
  name: string;
2575
3037
  columns: Record<string, {
2576
- name: string;
2577
3038
  type: string;
3039
+ name: string;
2578
3040
  primaryKey: boolean;
2579
3041
  notNull: boolean;
2580
3042
  default?: any;
2581
- autoincrement?: boolean | undefined;
2582
3043
  generated?: {
2583
3044
  type: "stored" | "virtual";
2584
3045
  as: string;
2585
3046
  } | undefined;
3047
+ autoincrement?: boolean | undefined;
2586
3048
  }>;
2587
3049
  isExisting: boolean;
2588
3050
  definition?: string | undefined;
2589
3051
  }>;
2590
- enums: {};
3052
+ _meta: {
3053
+ tables: Record<string, string>;
3054
+ columns: Record<string, string>;
3055
+ };
3056
+ id: string;
3057
+ prevId: string;
2591
3058
  internal?: {
2592
3059
  indexes?: Record<string, {
2593
3060
  columns: Record<string, {
@@ -2596,19 +3063,21 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
2596
3063
  } | undefined> | undefined;
2597
3064
  } | undefined;
2598
3065
  }, {
3066
+ version: "6";
3067
+ dialect: "sqlite";
2599
3068
  tables: Record<string, {
2600
3069
  name: string;
2601
3070
  columns: Record<string, {
2602
- name: string;
2603
3071
  type: string;
3072
+ name: string;
2604
3073
  primaryKey: boolean;
2605
3074
  notNull: boolean;
2606
3075
  default?: any;
2607
- autoincrement?: boolean | undefined;
2608
3076
  generated?: {
2609
3077
  type: "stored" | "virtual";
2610
3078
  as: string;
2611
3079
  } | undefined;
3080
+ autoincrement?: boolean | undefined;
2612
3081
  }>;
2613
3082
  indexes: Record<string, {
2614
3083
  name: string;
@@ -2634,43 +3103,41 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
2634
3103
  columns: string[];
2635
3104
  }> | undefined;
2636
3105
  checkConstraints?: Record<string, {
2637
- name: string;
2638
3106
  value: string;
3107
+ name: string;
2639
3108
  }> | undefined;
2640
3109
  }>;
2641
- id: string;
2642
- prevId: string;
2643
- version: "6";
2644
- dialect: "sqlite";
3110
+ enums: {};
2645
3111
  _meta: {
2646
- columns: Record<string, string>;
2647
3112
  tables: Record<string, string>;
3113
+ columns: Record<string, string>;
2648
3114
  };
2649
- enums: {};
2650
- internal?: {
2651
- indexes?: Record<string, {
2652
- columns: Record<string, {
2653
- isExpression?: boolean | undefined;
2654
- } | undefined>;
2655
- } | undefined> | undefined;
2656
- } | undefined;
3115
+ id: string;
3116
+ prevId: string;
2657
3117
  views?: Record<string, {
2658
3118
  name: string;
2659
3119
  columns: Record<string, {
2660
- name: string;
2661
3120
  type: string;
3121
+ name: string;
2662
3122
  primaryKey: boolean;
2663
3123
  notNull: boolean;
2664
3124
  default?: any;
2665
- autoincrement?: boolean | undefined;
2666
3125
  generated?: {
2667
3126
  type: "stored" | "virtual";
2668
3127
  as: string;
2669
3128
  } | undefined;
3129
+ autoincrement?: boolean | undefined;
2670
3130
  }>;
2671
3131
  isExisting: boolean;
2672
3132
  definition?: string | undefined;
2673
3133
  }> | undefined;
3134
+ internal?: {
3135
+ indexes?: Record<string, {
3136
+ columns: Record<string, {
3137
+ isExpression?: boolean | undefined;
3138
+ } | undefined>;
3139
+ } | undefined> | undefined;
3140
+ } | undefined;
2674
3141
  }>;
2675
3142
  type SQLiteSchema = TypeOf<typeof schema>;
2676
3143
 
@@ -2686,6 +3153,14 @@ declare const pushSchema: (imports: Record<string, unknown>, drizzleInstance: Pg
2686
3153
  statementsToExecute: string[];
2687
3154
  apply: () => Promise<void>;
2688
3155
  }>;
3156
+ declare const startStudioPostgresServer: (imports: Record<string, unknown>, credentials: PostgresCredentials | {
3157
+ driver: "pglite";
3158
+ client: PGlite;
3159
+ }, options?: {
3160
+ host?: string;
3161
+ port?: number;
3162
+ casing?: CasingType;
3163
+ }) => Promise<void>;
2689
3164
  declare const generateSQLiteDrizzleJson: (imports: Record<string, unknown>, prevId?: string, casing?: CasingType) => Promise<SQLiteSchema>;
2690
3165
  declare const generateSQLiteMigration: (prev: DrizzleSQLiteSnapshotJSON, cur: DrizzleSQLiteSnapshotJSON) => Promise<string[]>;
2691
3166
  declare const pushSQLiteSchema: (imports: Record<string, unknown>, drizzleInstance: LibSQLDatabase<any>) => Promise<{
@@ -2694,6 +3169,14 @@ declare const pushSQLiteSchema: (imports: Record<string, unknown>, drizzleInstan
2694
3169
  statementsToExecute: string[];
2695
3170
  apply: () => Promise<void>;
2696
3171
  }>;
3172
+ declare const startStudioSQLiteServer: (imports: Record<string, unknown>, credentials: SqliteCredentials | {
3173
+ driver: "d1";
3174
+ binding: D1Database;
3175
+ }, options?: {
3176
+ host?: string;
3177
+ port?: number;
3178
+ casing?: CasingType;
3179
+ }) => Promise<void>;
2697
3180
  declare const generateMySQLDrizzleJson: (imports: Record<string, unknown>, prevId?: string, casing?: CasingType) => Promise<MySqlSchema>;
2698
3181
  declare const generateMySQLMigration: (prev: DrizzleMySQLSnapshotJSON, cur: DrizzleMySQLSnapshotJSON) => Promise<string[]>;
2699
3182
  declare const pushMySQLSchema: (imports: Record<string, unknown>, drizzleInstance: MySql2Database<any>, databaseName: string) => Promise<{
@@ -2702,6 +3185,11 @@ declare const pushMySQLSchema: (imports: Record<string, unknown>, drizzleInstanc
2702
3185
  statementsToExecute: string[];
2703
3186
  apply: () => Promise<void>;
2704
3187
  }>;
3188
+ declare const startStudioMySQLServer: (imports: Record<string, unknown>, credentials: MysqlCredentials, options?: {
3189
+ host?: string;
3190
+ port?: number;
3191
+ casing?: CasingType;
3192
+ }) => Promise<void>;
2705
3193
  declare const generateSingleStoreDrizzleJson: (imports: Record<string, unknown>, prevId?: string, casing?: CasingType) => Promise<SingleStoreSchema>;
2706
3194
  declare const generateSingleStoreMigration: (prev: DrizzleSingleStoreSnapshotJSON, cur: DrizzleSingleStoreSnapshotJSON) => Promise<string[]>;
2707
3195
  declare const pushSingleStoreSchema: (imports: Record<string, unknown>, drizzleInstance: SingleStoreDriverDatabase<any>, databaseName: string) => Promise<{
@@ -2710,7 +3198,12 @@ declare const pushSingleStoreSchema: (imports: Record<string, unknown>, drizzleI
2710
3198
  statementsToExecute: string[];
2711
3199
  apply: () => Promise<void>;
2712
3200
  }>;
2713
- declare const upPgSnapshot: (snapshot: Record<string, unknown>) => Record<string, unknown> | {
3201
+ declare const startStudioSingleStoreServer: (imports: Record<string, unknown>, credentials: SingleStoreCredentials, options?: {
3202
+ host?: string;
3203
+ port?: number;
3204
+ casing?: CasingType;
3205
+ }) => Promise<void>;
3206
+ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => {
2714
3207
  version: "7";
2715
3208
  dialect: "postgresql";
2716
3209
  tables: Record<string, {
@@ -2726,6 +3219,21 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => Record<string
2726
3219
  isUnique?: any;
2727
3220
  uniqueName?: string | undefined;
2728
3221
  nullsNotDistinct?: boolean | undefined;
3222
+ generated?: {
3223
+ type: "stored";
3224
+ as: string;
3225
+ } | undefined;
3226
+ identity?: {
3227
+ type: "always" | "byDefault";
3228
+ name: string;
3229
+ schema: string;
3230
+ increment?: string | undefined;
3231
+ minValue?: string | undefined;
3232
+ maxValue?: string | undefined;
3233
+ startWith?: string | undefined;
3234
+ cache?: string | undefined;
3235
+ cycle?: boolean | undefined;
3236
+ } | undefined;
2729
3237
  }>;
2730
3238
  indexes: Record<string, {
2731
3239
  name: string;
@@ -2761,6 +3269,21 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => Record<string
2761
3269
  columns: string[];
2762
3270
  nullsNotDistinct: boolean;
2763
3271
  }>;
3272
+ policies: Record<string, {
3273
+ name: string;
3274
+ schema?: string | undefined;
3275
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
3276
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
3277
+ to?: string[] | undefined;
3278
+ using?: string | undefined;
3279
+ withCheck?: string | undefined;
3280
+ on?: string | undefined;
3281
+ }>;
3282
+ checkConstraints: Record<string, {
3283
+ value: string;
3284
+ name?: string | undefined;
3285
+ }>;
3286
+ isRLSEnabled: boolean;
2764
3287
  }>;
2765
3288
  policies: Record<string, {
2766
3289
  name: string;
@@ -2778,6 +3301,17 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => Record<string
2778
3301
  schema: string;
2779
3302
  }>;
2780
3303
  schemas: Record<string, string>;
3304
+ domains: Record<string, {
3305
+ name: string;
3306
+ schema: string;
3307
+ baseType: string;
3308
+ notNull?: boolean | undefined;
3309
+ checkConstraints?: Record<string, {
3310
+ value: string;
3311
+ name?: string | undefined;
3312
+ }> | undefined;
3313
+ defaultValue?: any;
3314
+ }>;
2781
3315
  views: Record<string, {
2782
3316
  name: string;
2783
3317
  schema: string;
@@ -2870,6 +3404,6 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => Record<string
2870
3404
  } | undefined>;
2871
3405
  } | undefined>;
2872
3406
  } | undefined;
2873
- };
3407
+ } | Record<string, unknown>;
2874
3408
 
2875
- export { type DrizzleMySQLSnapshotJSON, type DrizzleSQLiteSnapshotJSON, type DrizzleSingleStoreSnapshotJSON, type DrizzleSnapshotJSON, generateDrizzleJson, generateMigration, generateMySQLDrizzleJson, generateMySQLMigration, generateSQLiteDrizzleJson, generateSQLiteMigration, generateSingleStoreDrizzleJson, generateSingleStoreMigration, pushMySQLSchema, pushSQLiteSchema, pushSchema, pushSingleStoreSchema, upPgSnapshot };
3409
+ 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 };