@anthonyalayo/drizzle-kit 1.0.6 → 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 -468
  2. package/api.d.ts +986 -468
  3. package/api.js +54678 -25936
  4. package/api.mjs +54800 -26012
  5. package/bin.cjs +59812 -46379
  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 -442
  11. package/utils.mjs +824 -444
  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;
@@ -571,7 +1038,6 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
571
1038
  name: zod.ZodString;
572
1039
  type: zod.ZodString;
573
1040
  typeSchema: zod.ZodOptional<zod.ZodString>;
574
- domainTypeSchema: zod.ZodOptional<zod.ZodString>;
575
1041
  primaryKey: zod.ZodBoolean;
576
1042
  notNull: zod.ZodBoolean;
577
1043
  default: zod.ZodOptional<zod.ZodAny>;
@@ -588,7 +1054,7 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
588
1054
  type: "stored";
589
1055
  as: string;
590
1056
  }>>;
591
- identity: zod.ZodOptional<zod.ZodObject<zod.objectUtil.extendShape<{
1057
+ identity: zod.ZodOptional<zod.ZodObject<{
592
1058
  name: zod.ZodString;
593
1059
  increment: zod.ZodOptional<zod.ZodString>;
594
1060
  minValue: zod.ZodOptional<zod.ZodString>;
@@ -597,11 +1063,11 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
597
1063
  cache: zod.ZodOptional<zod.ZodString>;
598
1064
  cycle: zod.ZodOptional<zod.ZodBoolean>;
599
1065
  schema: zod.ZodString;
600
- }, {
1066
+ } & {
601
1067
  type: zod.ZodEnum<["always", "byDefault"]>;
602
- }>, "strip", zod.ZodTypeAny, {
603
- name: string;
1068
+ }, "strip", zod.ZodTypeAny, {
604
1069
  type: "always" | "byDefault";
1070
+ name: string;
605
1071
  schema: string;
606
1072
  increment?: string | undefined;
607
1073
  minValue?: string | undefined;
@@ -610,8 +1076,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
610
1076
  cache?: string | undefined;
611
1077
  cycle?: boolean | undefined;
612
1078
  }, {
613
- name: string;
614
1079
  type: "always" | "byDefault";
1080
+ name: string;
615
1081
  schema: string;
616
1082
  increment?: string | undefined;
617
1083
  minValue?: string | undefined;
@@ -621,23 +1087,22 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
621
1087
  cycle?: boolean | undefined;
622
1088
  }>>;
623
1089
  }, "strict", zod.ZodTypeAny, {
624
- name: string;
625
1090
  type: string;
1091
+ name: string;
626
1092
  primaryKey: boolean;
627
1093
  notNull: boolean;
628
- isUnique?: any;
1094
+ typeSchema?: string | undefined;
629
1095
  default?: any;
1096
+ isUnique?: any;
1097
+ uniqueName?: string | undefined;
1098
+ nullsNotDistinct?: boolean | undefined;
630
1099
  generated?: {
631
1100
  type: "stored";
632
1101
  as: string;
633
1102
  } | undefined;
634
- typeSchema?: string | undefined;
635
- domainTypeSchema?: string | undefined;
636
- uniqueName?: string | undefined;
637
- nullsNotDistinct?: boolean | undefined;
638
1103
  identity?: {
639
- name: string;
640
1104
  type: "always" | "byDefault";
1105
+ name: string;
641
1106
  schema: string;
642
1107
  increment?: string | undefined;
643
1108
  minValue?: string | undefined;
@@ -647,23 +1112,22 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
647
1112
  cycle?: boolean | undefined;
648
1113
  } | undefined;
649
1114
  }, {
650
- name: string;
651
1115
  type: string;
1116
+ name: string;
652
1117
  primaryKey: boolean;
653
1118
  notNull: boolean;
654
- isUnique?: any;
1119
+ typeSchema?: string | undefined;
655
1120
  default?: any;
1121
+ isUnique?: any;
1122
+ uniqueName?: string | undefined;
1123
+ nullsNotDistinct?: boolean | undefined;
656
1124
  generated?: {
657
1125
  type: "stored";
658
1126
  as: string;
659
1127
  } | undefined;
660
- typeSchema?: string | undefined;
661
- domainTypeSchema?: string | undefined;
662
- uniqueName?: string | undefined;
663
- nullsNotDistinct?: boolean | undefined;
664
1128
  identity?: {
665
- name: string;
666
1129
  type: "always" | "byDefault";
1130
+ name: string;
667
1131
  schema: string;
668
1132
  increment?: string | undefined;
669
1133
  minValue?: string | undefined;
@@ -682,14 +1146,14 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
682
1146
  nulls: zod.ZodOptional<zod.ZodString>;
683
1147
  opclass: zod.ZodOptional<zod.ZodString>;
684
1148
  }, "strip", zod.ZodTypeAny, {
685
- isExpression: boolean;
686
1149
  expression: string;
1150
+ isExpression: boolean;
687
1151
  asc: boolean;
688
1152
  nulls?: string | undefined;
689
1153
  opclass?: string | undefined;
690
1154
  }, {
691
- isExpression: boolean;
692
1155
  expression: string;
1156
+ isExpression: boolean;
693
1157
  asc: boolean;
694
1158
  nulls?: string | undefined;
695
1159
  opclass?: string | undefined;
@@ -702,8 +1166,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
702
1166
  }, "strict", zod.ZodTypeAny, {
703
1167
  name: string;
704
1168
  columns: {
705
- isExpression: boolean;
706
1169
  expression: string;
1170
+ isExpression: boolean;
707
1171
  asc: boolean;
708
1172
  nulls?: string | undefined;
709
1173
  opclass?: string | undefined;
@@ -716,8 +1180,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
716
1180
  }, {
717
1181
  name: string;
718
1182
  columns: {
719
- isExpression: boolean;
720
1183
  expression: string;
1184
+ isExpression: boolean;
721
1185
  asc: boolean;
722
1186
  nulls?: string | undefined;
723
1187
  opclass?: string | undefined;
@@ -743,18 +1207,18 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
743
1207
  columnsFrom: string[];
744
1208
  tableTo: string;
745
1209
  columnsTo: string[];
1210
+ schemaTo?: string | undefined;
746
1211
  onUpdate?: string | undefined;
747
1212
  onDelete?: string | undefined;
748
- schemaTo?: string | undefined;
749
1213
  }, {
750
1214
  name: string;
751
1215
  tableFrom: string;
752
1216
  columnsFrom: string[];
753
1217
  tableTo: string;
754
1218
  columnsTo: string[];
1219
+ schemaTo?: string | undefined;
755
1220
  onUpdate?: string | undefined;
756
1221
  onDelete?: string | undefined;
757
- schemaTo?: string | undefined;
758
1222
  }>>;
759
1223
  compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
760
1224
  name: zod.ZodString;
@@ -790,20 +1254,20 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
790
1254
  schema: zod.ZodOptional<zod.ZodString>;
791
1255
  }, "strict", zod.ZodTypeAny, {
792
1256
  name: string;
793
- using?: string | undefined;
794
- as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
795
1257
  schema?: string | undefined;
1258
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
796
1259
  for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
797
1260
  to?: string[] | undefined;
1261
+ using?: string | undefined;
798
1262
  withCheck?: string | undefined;
799
1263
  on?: string | undefined;
800
1264
  }, {
801
1265
  name: string;
802
- using?: string | undefined;
803
- as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
804
1266
  schema?: string | undefined;
1267
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
805
1268
  for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
806
1269
  to?: string[] | undefined;
1270
+ using?: string | undefined;
807
1271
  withCheck?: string | undefined;
808
1272
  on?: string | undefined;
809
1273
  }>>>;
@@ -820,24 +1284,24 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
820
1284
  isRLSEnabled: zod.ZodDefault<zod.ZodBoolean>;
821
1285
  }, "strict", zod.ZodTypeAny, {
822
1286
  name: string;
1287
+ schema: string;
823
1288
  columns: Record<string, {
824
- name: string;
825
1289
  type: string;
1290
+ name: string;
826
1291
  primaryKey: boolean;
827
1292
  notNull: boolean;
828
- isUnique?: any;
1293
+ typeSchema?: string | undefined;
829
1294
  default?: any;
1295
+ isUnique?: any;
1296
+ uniqueName?: string | undefined;
1297
+ nullsNotDistinct?: boolean | undefined;
830
1298
  generated?: {
831
1299
  type: "stored";
832
1300
  as: string;
833
1301
  } | undefined;
834
- typeSchema?: string | undefined;
835
- domainTypeSchema?: string | undefined;
836
- uniqueName?: string | undefined;
837
- nullsNotDistinct?: boolean | undefined;
838
1302
  identity?: {
839
- name: string;
840
1303
  type: "always" | "byDefault";
1304
+ name: string;
841
1305
  schema: string;
842
1306
  increment?: string | undefined;
843
1307
  minValue?: string | undefined;
@@ -850,8 +1314,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
850
1314
  indexes: Record<string, {
851
1315
  name: string;
852
1316
  columns: {
853
- isExpression: boolean;
854
1317
  expression: string;
1318
+ isExpression: boolean;
855
1319
  asc: boolean;
856
1320
  nulls?: string | undefined;
857
1321
  opclass?: string | undefined;
@@ -868,11 +1332,10 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
868
1332
  columnsFrom: string[];
869
1333
  tableTo: string;
870
1334
  columnsTo: string[];
1335
+ schemaTo?: string | undefined;
871
1336
  onUpdate?: string | undefined;
872
1337
  onDelete?: string | undefined;
873
- schemaTo?: string | undefined;
874
1338
  }>;
875
- schema: string;
876
1339
  compositePrimaryKeys: Record<string, {
877
1340
  name: string;
878
1341
  columns: string[];
@@ -882,41 +1345,41 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
882
1345
  columns: string[];
883
1346
  nullsNotDistinct: boolean;
884
1347
  }>;
885
- checkConstraints: Record<string, {
886
- value: string;
887
- name?: string | undefined;
888
- }>;
889
1348
  policies: Record<string, {
890
1349
  name: string;
891
- using?: string | undefined;
892
- as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
893
1350
  schema?: string | undefined;
1351
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
894
1352
  for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
895
1353
  to?: string[] | undefined;
1354
+ using?: string | undefined;
896
1355
  withCheck?: string | undefined;
897
1356
  on?: string | undefined;
898
1357
  }>;
1358
+ checkConstraints: Record<string, {
1359
+ value: string;
1360
+ name?: string | undefined;
1361
+ }>;
899
1362
  isRLSEnabled: boolean;
900
1363
  }, {
901
1364
  name: string;
1365
+ schema: string;
902
1366
  columns: Record<string, {
903
- name: string;
904
1367
  type: string;
1368
+ name: string;
905
1369
  primaryKey: boolean;
906
1370
  notNull: boolean;
907
- isUnique?: any;
1371
+ typeSchema?: string | undefined;
908
1372
  default?: any;
1373
+ isUnique?: any;
1374
+ uniqueName?: string | undefined;
1375
+ nullsNotDistinct?: boolean | undefined;
909
1376
  generated?: {
910
1377
  type: "stored";
911
1378
  as: string;
912
1379
  } | undefined;
913
- typeSchema?: string | undefined;
914
- domainTypeSchema?: string | undefined;
915
- uniqueName?: string | undefined;
916
- nullsNotDistinct?: boolean | undefined;
917
1380
  identity?: {
918
- name: string;
919
1381
  type: "always" | "byDefault";
1382
+ name: string;
920
1383
  schema: string;
921
1384
  increment?: string | undefined;
922
1385
  minValue?: string | undefined;
@@ -929,8 +1392,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
929
1392
  indexes: Record<string, {
930
1393
  name: string;
931
1394
  columns: {
932
- isExpression: boolean;
933
1395
  expression: string;
1396
+ isExpression: boolean;
934
1397
  asc: boolean;
935
1398
  nulls?: string | undefined;
936
1399
  opclass?: string | undefined;
@@ -947,11 +1410,10 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
947
1410
  columnsFrom: string[];
948
1411
  tableTo: string;
949
1412
  columnsTo: string[];
1413
+ schemaTo?: string | undefined;
950
1414
  onUpdate?: string | undefined;
951
1415
  onDelete?: string | undefined;
952
- schemaTo?: string | undefined;
953
1416
  }>;
954
- schema: string;
955
1417
  compositePrimaryKeys: Record<string, {
956
1418
  name: string;
957
1419
  columns: string[];
@@ -961,20 +1423,20 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
961
1423
  columns: string[];
962
1424
  nullsNotDistinct: boolean;
963
1425
  }> | undefined;
964
- checkConstraints?: Record<string, {
965
- value: string;
966
- name?: string | undefined;
967
- }> | undefined;
968
1426
  policies?: Record<string, {
969
1427
  name: string;
970
- using?: string | undefined;
971
- as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
972
1428
  schema?: string | undefined;
1429
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
973
1430
  for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
974
1431
  to?: string[] | undefined;
1432
+ using?: string | undefined;
975
1433
  withCheck?: string | undefined;
976
1434
  on?: string | undefined;
977
1435
  }> | undefined;
1436
+ checkConstraints?: Record<string, {
1437
+ value: string;
1438
+ name?: string | undefined;
1439
+ }> | undefined;
978
1440
  isRLSEnabled?: boolean | undefined;
979
1441
  }>>;
980
1442
  enums: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
@@ -982,16 +1444,16 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
982
1444
  schema: zod.ZodString;
983
1445
  values: zod.ZodArray<zod.ZodString, "many">;
984
1446
  }, "strict", zod.ZodTypeAny, {
985
- name: string;
986
1447
  values: string[];
1448
+ name: string;
987
1449
  schema: string;
988
1450
  }, {
989
- name: string;
990
1451
  values: string[];
1452
+ name: string;
991
1453
  schema: string;
992
1454
  }>>;
993
1455
  schemas: zod.ZodRecord<zod.ZodString, zod.ZodString>;
994
- domains: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1456
+ domains: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
995
1457
  name: zod.ZodString;
996
1458
  schema: zod.ZodString;
997
1459
  baseType: zod.ZodString;
@@ -1027,7 +1489,7 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1027
1489
  name?: string | undefined;
1028
1490
  }> | undefined;
1029
1491
  defaultValue?: any;
1030
- }>>;
1492
+ }>>>;
1031
1493
  views: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1032
1494
  name: zod.ZodString;
1033
1495
  schema: zod.ZodString;
@@ -1035,7 +1497,6 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1035
1497
  name: zod.ZodString;
1036
1498
  type: zod.ZodString;
1037
1499
  typeSchema: zod.ZodOptional<zod.ZodString>;
1038
- domainTypeSchema: zod.ZodOptional<zod.ZodString>;
1039
1500
  primaryKey: zod.ZodBoolean;
1040
1501
  notNull: zod.ZodBoolean;
1041
1502
  default: zod.ZodOptional<zod.ZodAny>;
@@ -1052,7 +1513,7 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1052
1513
  type: "stored";
1053
1514
  as: string;
1054
1515
  }>>;
1055
- identity: zod.ZodOptional<zod.ZodObject<zod.objectUtil.extendShape<{
1516
+ identity: zod.ZodOptional<zod.ZodObject<{
1056
1517
  name: zod.ZodString;
1057
1518
  increment: zod.ZodOptional<zod.ZodString>;
1058
1519
  minValue: zod.ZodOptional<zod.ZodString>;
@@ -1061,11 +1522,11 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1061
1522
  cache: zod.ZodOptional<zod.ZodString>;
1062
1523
  cycle: zod.ZodOptional<zod.ZodBoolean>;
1063
1524
  schema: zod.ZodString;
1064
- }, {
1525
+ } & {
1065
1526
  type: zod.ZodEnum<["always", "byDefault"]>;
1066
- }>, "strip", zod.ZodTypeAny, {
1067
- name: string;
1527
+ }, "strip", zod.ZodTypeAny, {
1068
1528
  type: "always" | "byDefault";
1529
+ name: string;
1069
1530
  schema: string;
1070
1531
  increment?: string | undefined;
1071
1532
  minValue?: string | undefined;
@@ -1074,8 +1535,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1074
1535
  cache?: string | undefined;
1075
1536
  cycle?: boolean | undefined;
1076
1537
  }, {
1077
- name: string;
1078
1538
  type: "always" | "byDefault";
1539
+ name: string;
1079
1540
  schema: string;
1080
1541
  increment?: string | undefined;
1081
1542
  minValue?: string | undefined;
@@ -1085,23 +1546,22 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1085
1546
  cycle?: boolean | undefined;
1086
1547
  }>>;
1087
1548
  }, "strict", zod.ZodTypeAny, {
1088
- name: string;
1089
1549
  type: string;
1550
+ name: string;
1090
1551
  primaryKey: boolean;
1091
1552
  notNull: boolean;
1092
- isUnique?: any;
1553
+ typeSchema?: string | undefined;
1093
1554
  default?: any;
1555
+ isUnique?: any;
1556
+ uniqueName?: string | undefined;
1557
+ nullsNotDistinct?: boolean | undefined;
1094
1558
  generated?: {
1095
1559
  type: "stored";
1096
1560
  as: string;
1097
1561
  } | undefined;
1098
- typeSchema?: string | undefined;
1099
- domainTypeSchema?: string | undefined;
1100
- uniqueName?: string | undefined;
1101
- nullsNotDistinct?: boolean | undefined;
1102
1562
  identity?: {
1103
- name: string;
1104
1563
  type: "always" | "byDefault";
1564
+ name: string;
1105
1565
  schema: string;
1106
1566
  increment?: string | undefined;
1107
1567
  minValue?: string | undefined;
@@ -1111,23 +1571,22 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1111
1571
  cycle?: boolean | undefined;
1112
1572
  } | undefined;
1113
1573
  }, {
1114
- name: string;
1115
1574
  type: string;
1575
+ name: string;
1116
1576
  primaryKey: boolean;
1117
1577
  notNull: boolean;
1118
- isUnique?: any;
1578
+ typeSchema?: string | undefined;
1119
1579
  default?: any;
1580
+ isUnique?: any;
1581
+ uniqueName?: string | undefined;
1582
+ nullsNotDistinct?: boolean | undefined;
1120
1583
  generated?: {
1121
1584
  type: "stored";
1122
1585
  as: string;
1123
1586
  } | undefined;
1124
- typeSchema?: string | undefined;
1125
- domainTypeSchema?: string | undefined;
1126
- uniqueName?: string | undefined;
1127
- nullsNotDistinct?: boolean | undefined;
1128
1587
  identity?: {
1129
- name: string;
1130
1588
  type: "always" | "byDefault";
1589
+ name: string;
1131
1590
  schema: string;
1132
1591
  increment?: string | undefined;
1133
1592
  minValue?: string | undefined;
@@ -1139,11 +1598,11 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1139
1598
  }>>;
1140
1599
  definition: zod.ZodOptional<zod.ZodString>;
1141
1600
  materialized: zod.ZodBoolean;
1142
- with: zod.ZodOptional<zod.ZodObject<zod.objectUtil.extendShape<{
1601
+ with: zod.ZodOptional<zod.ZodObject<{
1143
1602
  checkOption: zod.ZodOptional<zod.ZodEnum<["local", "cascaded"]>>;
1144
1603
  securityBarrier: zod.ZodOptional<zod.ZodBoolean>;
1145
1604
  securityInvoker: zod.ZodOptional<zod.ZodBoolean>;
1146
- }, {
1605
+ } & {
1147
1606
  fillfactor: zod.ZodOptional<zod.ZodNumber>;
1148
1607
  toastTupleTarget: zod.ZodOptional<zod.ZodNumber>;
1149
1608
  parallelWorkers: zod.ZodOptional<zod.ZodNumber>;
@@ -1162,7 +1621,7 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1162
1621
  autovacuumMultixactFreezeTableAge: zod.ZodOptional<zod.ZodNumber>;
1163
1622
  logAutovacuumMinDuration: zod.ZodOptional<zod.ZodNumber>;
1164
1623
  userCatalogTable: zod.ZodOptional<zod.ZodBoolean>;
1165
- }>, "strict", zod.ZodTypeAny, {
1624
+ }, "strict", zod.ZodTypeAny, {
1166
1625
  checkOption?: "local" | "cascaded" | undefined;
1167
1626
  securityBarrier?: boolean | undefined;
1168
1627
  securityInvoker?: boolean | undefined;
@@ -1213,24 +1672,24 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1213
1672
  tablespace: zod.ZodOptional<zod.ZodString>;
1214
1673
  }, "strict", zod.ZodTypeAny, {
1215
1674
  name: string;
1675
+ schema: string;
1216
1676
  columns: Record<string, {
1217
- name: string;
1218
1677
  type: string;
1678
+ name: string;
1219
1679
  primaryKey: boolean;
1220
1680
  notNull: boolean;
1221
- isUnique?: any;
1681
+ typeSchema?: string | undefined;
1222
1682
  default?: any;
1683
+ isUnique?: any;
1684
+ uniqueName?: string | undefined;
1685
+ nullsNotDistinct?: boolean | undefined;
1223
1686
  generated?: {
1224
1687
  type: "stored";
1225
1688
  as: string;
1226
1689
  } | undefined;
1227
- typeSchema?: string | undefined;
1228
- domainTypeSchema?: string | undefined;
1229
- uniqueName?: string | undefined;
1230
- nullsNotDistinct?: boolean | undefined;
1231
1690
  identity?: {
1232
- name: string;
1233
1691
  type: "always" | "byDefault";
1692
+ name: string;
1234
1693
  schema: string;
1235
1694
  increment?: string | undefined;
1236
1695
  minValue?: string | undefined;
@@ -1240,11 +1699,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1240
1699
  cycle?: boolean | undefined;
1241
1700
  } | undefined;
1242
1701
  }>;
1243
- schema: string;
1244
- isExisting: boolean;
1245
1702
  materialized: boolean;
1246
- using?: string | undefined;
1247
- definition?: string | undefined;
1703
+ isExisting: boolean;
1248
1704
  with?: {
1249
1705
  checkOption?: "local" | "cascaded" | undefined;
1250
1706
  securityBarrier?: boolean | undefined;
@@ -1268,28 +1724,30 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1268
1724
  logAutovacuumMinDuration?: number | undefined;
1269
1725
  userCatalogTable?: boolean | undefined;
1270
1726
  } | undefined;
1727
+ using?: string | undefined;
1728
+ definition?: string | undefined;
1271
1729
  withNoData?: boolean | undefined;
1272
1730
  tablespace?: string | undefined;
1273
1731
  }, {
1274
1732
  name: string;
1733
+ schema: string;
1275
1734
  columns: Record<string, {
1276
- name: string;
1277
1735
  type: string;
1736
+ name: string;
1278
1737
  primaryKey: boolean;
1279
1738
  notNull: boolean;
1280
- isUnique?: any;
1739
+ typeSchema?: string | undefined;
1281
1740
  default?: any;
1741
+ isUnique?: any;
1742
+ uniqueName?: string | undefined;
1743
+ nullsNotDistinct?: boolean | undefined;
1282
1744
  generated?: {
1283
1745
  type: "stored";
1284
1746
  as: string;
1285
1747
  } | undefined;
1286
- typeSchema?: string | undefined;
1287
- domainTypeSchema?: string | undefined;
1288
- uniqueName?: string | undefined;
1289
- nullsNotDistinct?: boolean | undefined;
1290
1748
  identity?: {
1291
- name: string;
1292
1749
  type: "always" | "byDefault";
1750
+ name: string;
1293
1751
  schema: string;
1294
1752
  increment?: string | undefined;
1295
1753
  minValue?: string | undefined;
@@ -1299,11 +1757,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1299
1757
  cycle?: boolean | undefined;
1300
1758
  } | undefined;
1301
1759
  }>;
1302
- schema: string;
1303
- isExisting: boolean;
1304
1760
  materialized: boolean;
1305
- using?: string | undefined;
1306
- definition?: string | undefined;
1761
+ isExisting: boolean;
1307
1762
  with?: {
1308
1763
  checkOption?: "local" | "cascaded" | undefined;
1309
1764
  securityBarrier?: boolean | undefined;
@@ -1327,6 +1782,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1327
1782
  logAutovacuumMinDuration?: number | undefined;
1328
1783
  userCatalogTable?: boolean | undefined;
1329
1784
  } | undefined;
1785
+ using?: string | undefined;
1786
+ definition?: string | undefined;
1330
1787
  withNoData?: boolean | undefined;
1331
1788
  tablespace?: string | undefined;
1332
1789
  }>>>;
@@ -1385,20 +1842,20 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1385
1842
  schema: zod.ZodOptional<zod.ZodString>;
1386
1843
  }, "strict", zod.ZodTypeAny, {
1387
1844
  name: string;
1388
- using?: string | undefined;
1389
- as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1390
1845
  schema?: string | undefined;
1846
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1391
1847
  for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1392
1848
  to?: string[] | undefined;
1849
+ using?: string | undefined;
1393
1850
  withCheck?: string | undefined;
1394
1851
  on?: string | undefined;
1395
1852
  }, {
1396
1853
  name: string;
1397
- using?: string | undefined;
1398
- as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1399
1854
  schema?: string | undefined;
1855
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1400
1856
  for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1401
1857
  to?: string[] | undefined;
1858
+ using?: string | undefined;
1402
1859
  withCheck?: string | undefined;
1403
1860
  on?: string | undefined;
1404
1861
  }>>>;
@@ -1407,12 +1864,12 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1407
1864
  tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
1408
1865
  columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
1409
1866
  }, "strip", zod.ZodTypeAny, {
1410
- columns: Record<string, string>;
1411
1867
  tables: Record<string, string>;
1868
+ columns: Record<string, string>;
1412
1869
  schemas: Record<string, string>;
1413
1870
  }, {
1414
- columns: Record<string, string>;
1415
1871
  tables: Record<string, string>;
1872
+ columns: Record<string, string>;
1416
1873
  schemas: Record<string, string>;
1417
1874
  }>;
1418
1875
  internal: zod.ZodOptional<zod.ZodObject<{
@@ -1423,74 +1880,76 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1423
1880
  rawType: zod.ZodOptional<zod.ZodString>;
1424
1881
  isDefaultAnExpression: zod.ZodOptional<zod.ZodBoolean>;
1425
1882
  }, "strip", zod.ZodTypeAny, {
1426
- isDefaultAnExpression?: boolean | undefined;
1427
1883
  isArray?: boolean | undefined;
1428
1884
  dimensions?: number | undefined;
1429
1885
  rawType?: string | undefined;
1430
- }, {
1431
1886
  isDefaultAnExpression?: boolean | undefined;
1887
+ }, {
1432
1888
  isArray?: boolean | undefined;
1433
1889
  dimensions?: number | undefined;
1434
1890
  rawType?: string | undefined;
1891
+ isDefaultAnExpression?: boolean | undefined;
1435
1892
  }>>>;
1436
1893
  }, "strip", zod.ZodTypeAny, {
1437
1894
  columns: Record<string, {
1438
- isDefaultAnExpression?: boolean | undefined;
1439
1895
  isArray?: boolean | undefined;
1440
1896
  dimensions?: number | undefined;
1441
1897
  rawType?: string | undefined;
1898
+ isDefaultAnExpression?: boolean | undefined;
1442
1899
  } | undefined>;
1443
1900
  }, {
1444
1901
  columns: Record<string, {
1445
- isDefaultAnExpression?: boolean | undefined;
1446
1902
  isArray?: boolean | undefined;
1447
1903
  dimensions?: number | undefined;
1448
1904
  rawType?: string | undefined;
1905
+ isDefaultAnExpression?: boolean | undefined;
1449
1906
  } | undefined>;
1450
1907
  }>>>;
1451
1908
  }, "strip", zod.ZodTypeAny, {
1452
1909
  tables: Record<string, {
1453
1910
  columns: Record<string, {
1454
- isDefaultAnExpression?: boolean | undefined;
1455
1911
  isArray?: boolean | undefined;
1456
1912
  dimensions?: number | undefined;
1457
1913
  rawType?: string | undefined;
1914
+ isDefaultAnExpression?: boolean | undefined;
1458
1915
  } | undefined>;
1459
1916
  } | undefined>;
1460
1917
  }, {
1461
1918
  tables: Record<string, {
1462
1919
  columns: Record<string, {
1463
- isDefaultAnExpression?: boolean | undefined;
1464
1920
  isArray?: boolean | undefined;
1465
1921
  dimensions?: number | undefined;
1466
1922
  rawType?: string | undefined;
1923
+ isDefaultAnExpression?: boolean | undefined;
1467
1924
  } | undefined>;
1468
1925
  } | undefined>;
1469
1926
  }>>;
1470
- }, {
1927
+ } & {
1471
1928
  id: zod.ZodString;
1472
1929
  prevId: zod.ZodString;
1473
- }>, "strip", zod.ZodTypeAny, {
1930
+ }, "strip", zod.ZodTypeAny, {
1931
+ version: "7";
1932
+ dialect: "postgresql";
1474
1933
  tables: Record<string, {
1475
1934
  name: string;
1935
+ schema: string;
1476
1936
  columns: Record<string, {
1477
- name: string;
1478
1937
  type: string;
1938
+ name: string;
1479
1939
  primaryKey: boolean;
1480
1940
  notNull: boolean;
1481
- isUnique?: any;
1941
+ typeSchema?: string | undefined;
1482
1942
  default?: any;
1943
+ isUnique?: any;
1944
+ uniqueName?: string | undefined;
1945
+ nullsNotDistinct?: boolean | undefined;
1483
1946
  generated?: {
1484
1947
  type: "stored";
1485
1948
  as: string;
1486
1949
  } | undefined;
1487
- typeSchema?: string | undefined;
1488
- domainTypeSchema?: string | undefined;
1489
- uniqueName?: string | undefined;
1490
- nullsNotDistinct?: boolean | undefined;
1491
1950
  identity?: {
1492
- name: string;
1493
1951
  type: "always" | "byDefault";
1952
+ name: string;
1494
1953
  schema: string;
1495
1954
  increment?: string | undefined;
1496
1955
  minValue?: string | undefined;
@@ -1503,8 +1962,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1503
1962
  indexes: Record<string, {
1504
1963
  name: string;
1505
1964
  columns: {
1506
- isExpression: boolean;
1507
1965
  expression: string;
1966
+ isExpression: boolean;
1508
1967
  asc: boolean;
1509
1968
  nulls?: string | undefined;
1510
1969
  opclass?: string | undefined;
@@ -1521,11 +1980,10 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1521
1980
  columnsFrom: string[];
1522
1981
  tableTo: string;
1523
1982
  columnsTo: string[];
1983
+ schemaTo?: string | undefined;
1524
1984
  onUpdate?: string | undefined;
1525
1985
  onDelete?: string | undefined;
1526
- schemaTo?: string | undefined;
1527
1986
  }>;
1528
- schema: string;
1529
1987
  compositePrimaryKeys: Record<string, {
1530
1988
  name: string;
1531
1989
  columns: string[];
@@ -1535,52 +1993,69 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1535
1993
  columns: string[];
1536
1994
  nullsNotDistinct: boolean;
1537
1995
  }>;
1538
- checkConstraints: Record<string, {
1539
- value: string;
1540
- name?: string | undefined;
1541
- }>;
1542
1996
  policies: Record<string, {
1543
1997
  name: string;
1544
- using?: string | undefined;
1545
- as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1546
1998
  schema?: string | undefined;
1999
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1547
2000
  for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1548
2001
  to?: string[] | undefined;
2002
+ using?: string | undefined;
1549
2003
  withCheck?: string | undefined;
1550
2004
  on?: string | undefined;
1551
2005
  }>;
2006
+ checkConstraints: Record<string, {
2007
+ value: string;
2008
+ name?: string | undefined;
2009
+ }>;
1552
2010
  isRLSEnabled: boolean;
1553
2011
  }>;
1554
- id: string;
1555
- prevId: string;
1556
- version: "8";
1557
- 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
+ }>;
1558
2027
  schemas: Record<string, string>;
1559
- _meta: {
1560
- columns: Record<string, string>;
1561
- tables: Record<string, string>;
1562
- schemas: Record<string, string>;
1563
- };
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
+ }>;
1564
2039
  views: Record<string, {
1565
2040
  name: string;
2041
+ schema: string;
1566
2042
  columns: Record<string, {
1567
- name: string;
1568
2043
  type: string;
2044
+ name: string;
1569
2045
  primaryKey: boolean;
1570
2046
  notNull: boolean;
1571
- isUnique?: any;
2047
+ typeSchema?: string | undefined;
1572
2048
  default?: any;
2049
+ isUnique?: any;
2050
+ uniqueName?: string | undefined;
2051
+ nullsNotDistinct?: boolean | undefined;
1573
2052
  generated?: {
1574
2053
  type: "stored";
1575
2054
  as: string;
1576
2055
  } | undefined;
1577
- typeSchema?: string | undefined;
1578
- domainTypeSchema?: string | undefined;
1579
- uniqueName?: string | undefined;
1580
- nullsNotDistinct?: boolean | undefined;
1581
2056
  identity?: {
1582
- name: string;
1583
2057
  type: "always" | "byDefault";
2058
+ name: string;
1584
2059
  schema: string;
1585
2060
  increment?: string | undefined;
1586
2061
  minValue?: string | undefined;
@@ -1590,11 +2065,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1590
2065
  cycle?: boolean | undefined;
1591
2066
  } | undefined;
1592
2067
  }>;
1593
- schema: string;
1594
- isExisting: boolean;
1595
2068
  materialized: boolean;
1596
- using?: string | undefined;
1597
- definition?: string | undefined;
2069
+ isExisting: boolean;
1598
2070
  with?: {
1599
2071
  checkOption?: "local" | "cascaded" | undefined;
1600
2072
  securityBarrier?: boolean | undefined;
@@ -1618,24 +2090,11 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1618
2090
  logAutovacuumMinDuration?: number | undefined;
1619
2091
  userCatalogTable?: boolean | undefined;
1620
2092
  } | undefined;
2093
+ using?: string | undefined;
2094
+ definition?: string | undefined;
1621
2095
  withNoData?: boolean | undefined;
1622
2096
  tablespace?: string | undefined;
1623
2097
  }>;
1624
- enums: Record<string, {
1625
- name: string;
1626
- values: string[];
1627
- schema: string;
1628
- }>;
1629
- policies: Record<string, {
1630
- name: string;
1631
- using?: string | undefined;
1632
- as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1633
- schema?: string | undefined;
1634
- for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1635
- to?: string[] | undefined;
1636
- withCheck?: string | undefined;
1637
- on?: string | undefined;
1638
- }>;
1639
2098
  sequences: Record<string, {
1640
2099
  name: string;
1641
2100
  schema: string;
@@ -1652,48 +2111,46 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1652
2111
  createRole?: boolean | undefined;
1653
2112
  inherit?: boolean | undefined;
1654
2113
  }>;
1655
- domains: Record<string, {
1656
- name: string;
1657
- schema: string;
1658
- baseType: string;
1659
- notNull?: boolean | undefined;
1660
- checkConstraints?: Record<string, {
1661
- value: string;
1662
- name?: string | undefined;
1663
- }> | undefined;
1664
- defaultValue?: any;
1665
- }>;
2114
+ _meta: {
2115
+ tables: Record<string, string>;
2116
+ columns: Record<string, string>;
2117
+ schemas: Record<string, string>;
2118
+ };
2119
+ id: string;
2120
+ prevId: string;
1666
2121
  internal?: {
1667
2122
  tables: Record<string, {
1668
2123
  columns: Record<string, {
1669
- isDefaultAnExpression?: boolean | undefined;
1670
2124
  isArray?: boolean | undefined;
1671
2125
  dimensions?: number | undefined;
1672
2126
  rawType?: string | undefined;
2127
+ isDefaultAnExpression?: boolean | undefined;
1673
2128
  } | undefined>;
1674
2129
  } | undefined>;
1675
2130
  } | undefined;
1676
2131
  }, {
2132
+ version: "7";
2133
+ dialect: "postgresql";
1677
2134
  tables: Record<string, {
1678
2135
  name: string;
2136
+ schema: string;
1679
2137
  columns: Record<string, {
1680
- name: string;
1681
2138
  type: string;
2139
+ name: string;
1682
2140
  primaryKey: boolean;
1683
2141
  notNull: boolean;
1684
- isUnique?: any;
2142
+ typeSchema?: string | undefined;
1685
2143
  default?: any;
2144
+ isUnique?: any;
2145
+ uniqueName?: string | undefined;
2146
+ nullsNotDistinct?: boolean | undefined;
1686
2147
  generated?: {
1687
2148
  type: "stored";
1688
2149
  as: string;
1689
2150
  } | undefined;
1690
- typeSchema?: string | undefined;
1691
- domainTypeSchema?: string | undefined;
1692
- uniqueName?: string | undefined;
1693
- nullsNotDistinct?: boolean | undefined;
1694
2151
  identity?: {
1695
- name: string;
1696
2152
  type: "always" | "byDefault";
2153
+ name: string;
1697
2154
  schema: string;
1698
2155
  increment?: string | undefined;
1699
2156
  minValue?: string | undefined;
@@ -1706,8 +2163,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1706
2163
  indexes: Record<string, {
1707
2164
  name: string;
1708
2165
  columns: {
1709
- isExpression: boolean;
1710
2166
  expression: string;
2167
+ isExpression: boolean;
1711
2168
  asc: boolean;
1712
2169
  nulls?: string | undefined;
1713
2170
  opclass?: string | undefined;
@@ -1724,11 +2181,10 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1724
2181
  columnsFrom: string[];
1725
2182
  tableTo: string;
1726
2183
  columnsTo: string[];
2184
+ schemaTo?: string | undefined;
1727
2185
  onUpdate?: string | undefined;
1728
2186
  onDelete?: string | undefined;
1729
- schemaTo?: string | undefined;
1730
2187
  }>;
1731
- schema: string;
1732
2188
  compositePrimaryKeys: Record<string, {
1733
2189
  name: string;
1734
2190
  columns: string[];
@@ -1738,38 +2194,46 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1738
2194
  columns: string[];
1739
2195
  nullsNotDistinct: boolean;
1740
2196
  }> | undefined;
1741
- checkConstraints?: Record<string, {
1742
- value: string;
1743
- name?: string | undefined;
1744
- }> | undefined;
1745
2197
  policies?: Record<string, {
1746
2198
  name: string;
1747
- using?: string | undefined;
1748
- as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1749
2199
  schema?: string | undefined;
2200
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1750
2201
  for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1751
2202
  to?: string[] | undefined;
2203
+ using?: string | undefined;
1752
2204
  withCheck?: string | undefined;
1753
2205
  on?: string | undefined;
1754
2206
  }> | undefined;
2207
+ checkConstraints?: Record<string, {
2208
+ value: string;
2209
+ name?: string | undefined;
2210
+ }> | undefined;
1755
2211
  isRLSEnabled?: boolean | undefined;
1756
2212
  }>;
1757
- id: string;
1758
- prevId: string;
1759
- version: "8";
1760
- dialect: "postgresql";
2213
+ enums: Record<string, {
2214
+ values: string[];
2215
+ name: string;
2216
+ schema: string;
2217
+ }>;
1761
2218
  schemas: Record<string, string>;
1762
2219
  _meta: {
1763
- columns: Record<string, string>;
1764
2220
  tables: Record<string, string>;
2221
+ columns: Record<string, string>;
1765
2222
  schemas: Record<string, string>;
1766
2223
  };
1767
- enums: Record<string, {
2224
+ id: string;
2225
+ prevId: string;
2226
+ policies?: Record<string, {
1768
2227
  name: string;
1769
- values: string[];
1770
- schema: string;
1771
- }>;
1772
- 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, {
1773
2237
  name: string;
1774
2238
  schema: string;
1775
2239
  baseType: string;
@@ -1779,37 +2243,27 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1779
2243
  name?: string | undefined;
1780
2244
  }> | undefined;
1781
2245
  defaultValue?: any;
1782
- }>;
1783
- internal?: {
1784
- tables: Record<string, {
1785
- columns: Record<string, {
1786
- isDefaultAnExpression?: boolean | undefined;
1787
- isArray?: boolean | undefined;
1788
- dimensions?: number | undefined;
1789
- rawType?: string | undefined;
1790
- } | undefined>;
1791
- } | undefined>;
1792
- } | undefined;
2246
+ }> | undefined;
1793
2247
  views?: Record<string, {
1794
2248
  name: string;
2249
+ schema: string;
1795
2250
  columns: Record<string, {
1796
- name: string;
1797
2251
  type: string;
2252
+ name: string;
1798
2253
  primaryKey: boolean;
1799
2254
  notNull: boolean;
1800
- isUnique?: any;
2255
+ typeSchema?: string | undefined;
1801
2256
  default?: any;
2257
+ isUnique?: any;
2258
+ uniqueName?: string | undefined;
2259
+ nullsNotDistinct?: boolean | undefined;
1802
2260
  generated?: {
1803
2261
  type: "stored";
1804
2262
  as: string;
1805
2263
  } | undefined;
1806
- typeSchema?: string | undefined;
1807
- domainTypeSchema?: string | undefined;
1808
- uniqueName?: string | undefined;
1809
- nullsNotDistinct?: boolean | undefined;
1810
2264
  identity?: {
1811
- name: string;
1812
2265
  type: "always" | "byDefault";
2266
+ name: string;
1813
2267
  schema: string;
1814
2268
  increment?: string | undefined;
1815
2269
  minValue?: string | undefined;
@@ -1819,11 +2273,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1819
2273
  cycle?: boolean | undefined;
1820
2274
  } | undefined;
1821
2275
  }>;
1822
- schema: string;
1823
- isExisting: boolean;
1824
2276
  materialized: boolean;
1825
- using?: string | undefined;
1826
- definition?: string | undefined;
2277
+ isExisting: boolean;
1827
2278
  with?: {
1828
2279
  checkOption?: "local" | "cascaded" | undefined;
1829
2280
  securityBarrier?: boolean | undefined;
@@ -1845,20 +2296,12 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1845
2296
  autovacuumMultixactFreezeMaxAge?: number | undefined;
1846
2297
  autovacuumMultixactFreezeTableAge?: number | undefined;
1847
2298
  logAutovacuumMinDuration?: number | undefined;
1848
- userCatalogTable?: boolean | undefined;
1849
- } | undefined;
1850
- withNoData?: boolean | undefined;
1851
- tablespace?: string | undefined;
1852
- }> | undefined;
1853
- policies?: Record<string, {
1854
- name: string;
1855
- using?: string | undefined;
1856
- as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1857
- schema?: string | undefined;
1858
- for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1859
- to?: string[] | undefined;
1860
- withCheck?: string | undefined;
1861
- 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;
1862
2305
  }> | undefined;
1863
2306
  sequences?: Record<string, {
1864
2307
  name: string;
@@ -1876,10 +2319,20 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
1876
2319
  createRole?: boolean | undefined;
1877
2320
  inherit?: boolean | undefined;
1878
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;
1879
2332
  }>;
1880
2333
  type PgSchema = TypeOf<typeof pgSchema>;
1881
2334
 
1882
- declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
2335
+ declare const schema$1: zod.ZodObject<{
1883
2336
  version: zod.ZodLiteral<"1">;
1884
2337
  dialect: zod.ZodLiteral<"singlestore">;
1885
2338
  tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
@@ -1903,29 +2356,29 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
1903
2356
  as: string;
1904
2357
  }>>;
1905
2358
  }, "strict", zod.ZodTypeAny, {
1906
- name: string;
1907
2359
  type: string;
2360
+ name: string;
1908
2361
  primaryKey: boolean;
1909
2362
  notNull: boolean;
1910
2363
  default?: any;
1911
- onUpdate?: any;
1912
- autoincrement?: boolean | undefined;
1913
2364
  generated?: {
1914
2365
  type: "stored" | "virtual";
1915
2366
  as: string;
1916
2367
  } | undefined;
2368
+ onUpdate?: any;
2369
+ autoincrement?: boolean | undefined;
1917
2370
  }, {
1918
- name: string;
1919
2371
  type: string;
2372
+ name: string;
1920
2373
  primaryKey: boolean;
1921
2374
  notNull: boolean;
1922
2375
  default?: any;
1923
- onUpdate?: any;
1924
- autoincrement?: boolean | undefined;
1925
2376
  generated?: {
1926
2377
  type: "stored" | "virtual";
1927
2378
  as: string;
1928
2379
  } | undefined;
2380
+ onUpdate?: any;
2381
+ autoincrement?: boolean | undefined;
1929
2382
  }>>;
1930
2383
  indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1931
2384
  name: zod.ZodString;
@@ -1940,14 +2393,14 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
1940
2393
  isUnique: boolean;
1941
2394
  using?: "btree" | "hash" | undefined;
1942
2395
  algorithm?: "default" | "inplace" | "copy" | undefined;
1943
- lock?: "none" | "default" | "shared" | "exclusive" | undefined;
2396
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1944
2397
  }, {
1945
2398
  name: string;
1946
2399
  columns: string[];
1947
2400
  isUnique: boolean;
1948
2401
  using?: "btree" | "hash" | undefined;
1949
2402
  algorithm?: "default" | "inplace" | "copy" | undefined;
1950
- lock?: "none" | "default" | "shared" | "exclusive" | undefined;
2403
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1951
2404
  }>>;
1952
2405
  compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1953
2406
  name: zod.ZodString;
@@ -1972,17 +2425,17 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
1972
2425
  }, "strict", zod.ZodTypeAny, {
1973
2426
  name: string;
1974
2427
  columns: Record<string, {
1975
- name: string;
1976
2428
  type: string;
2429
+ name: string;
1977
2430
  primaryKey: boolean;
1978
2431
  notNull: boolean;
1979
2432
  default?: any;
1980
- onUpdate?: any;
1981
- autoincrement?: boolean | undefined;
1982
2433
  generated?: {
1983
2434
  type: "stored" | "virtual";
1984
2435
  as: string;
1985
2436
  } | undefined;
2437
+ onUpdate?: any;
2438
+ autoincrement?: boolean | undefined;
1986
2439
  }>;
1987
2440
  indexes: Record<string, {
1988
2441
  name: string;
@@ -1990,7 +2443,7 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
1990
2443
  isUnique: boolean;
1991
2444
  using?: "btree" | "hash" | undefined;
1992
2445
  algorithm?: "default" | "inplace" | "copy" | undefined;
1993
- lock?: "none" | "default" | "shared" | "exclusive" | undefined;
2446
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1994
2447
  }>;
1995
2448
  compositePrimaryKeys: Record<string, {
1996
2449
  name: string;
@@ -2003,17 +2456,17 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
2003
2456
  }, {
2004
2457
  name: string;
2005
2458
  columns: Record<string, {
2006
- name: string;
2007
2459
  type: string;
2460
+ name: string;
2008
2461
  primaryKey: boolean;
2009
2462
  notNull: boolean;
2010
2463
  default?: any;
2011
- onUpdate?: any;
2012
- autoincrement?: boolean | undefined;
2013
2464
  generated?: {
2014
2465
  type: "stored" | "virtual";
2015
2466
  as: string;
2016
2467
  } | undefined;
2468
+ onUpdate?: any;
2469
+ autoincrement?: boolean | undefined;
2017
2470
  }>;
2018
2471
  indexes: Record<string, {
2019
2472
  name: string;
@@ -2021,7 +2474,7 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
2021
2474
  isUnique: boolean;
2022
2475
  using?: "btree" | "hash" | undefined;
2023
2476
  algorithm?: "default" | "inplace" | "copy" | undefined;
2024
- lock?: "none" | "default" | "shared" | "exclusive" | undefined;
2477
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2025
2478
  }>;
2026
2479
  compositePrimaryKeys: Record<string, {
2027
2480
  name: string;
@@ -2036,11 +2489,11 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
2036
2489
  tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
2037
2490
  columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
2038
2491
  }, "strip", zod.ZodTypeAny, {
2039
- columns: Record<string, string>;
2040
2492
  tables: Record<string, string>;
2041
- }, {
2042
2493
  columns: Record<string, string>;
2494
+ }, {
2043
2495
  tables: Record<string, string>;
2496
+ columns: Record<string, string>;
2044
2497
  }>;
2045
2498
  internal: zod.ZodOptional<zod.ZodObject<{
2046
2499
  tables: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
@@ -2078,46 +2531,48 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
2078
2531
  } | undefined>;
2079
2532
  }>>>>;
2080
2533
  }, "strip", zod.ZodTypeAny, {
2081
- indexes?: Record<string, {
2082
- columns: Record<string, {
2083
- isExpression?: boolean | undefined;
2084
- } | undefined>;
2085
- } | undefined> | undefined;
2086
2534
  tables?: Record<string, {
2087
2535
  columns: Record<string, {
2088
2536
  isDefaultAnExpression?: boolean | undefined;
2089
2537
  } | undefined>;
2090
2538
  } | undefined> | undefined;
2091
- }, {
2092
2539
  indexes?: Record<string, {
2093
2540
  columns: Record<string, {
2094
2541
  isExpression?: boolean | undefined;
2095
2542
  } | undefined>;
2096
2543
  } | undefined> | undefined;
2544
+ }, {
2097
2545
  tables?: Record<string, {
2098
2546
  columns: Record<string, {
2099
2547
  isDefaultAnExpression?: boolean | undefined;
2100
2548
  } | undefined>;
2101
2549
  } | undefined> | undefined;
2550
+ indexes?: Record<string, {
2551
+ columns: Record<string, {
2552
+ isExpression?: boolean | undefined;
2553
+ } | undefined>;
2554
+ } | undefined> | undefined;
2102
2555
  }>>;
2103
- }, {
2556
+ } & {
2104
2557
  id: zod.ZodString;
2105
2558
  prevId: zod.ZodString;
2106
- }>, "strip", zod.ZodTypeAny, {
2559
+ }, "strip", zod.ZodTypeAny, {
2560
+ version: "1";
2561
+ dialect: "singlestore";
2107
2562
  tables: Record<string, {
2108
2563
  name: string;
2109
2564
  columns: Record<string, {
2110
- name: string;
2111
2565
  type: string;
2566
+ name: string;
2112
2567
  primaryKey: boolean;
2113
2568
  notNull: boolean;
2114
2569
  default?: any;
2115
- onUpdate?: any;
2116
- autoincrement?: boolean | undefined;
2117
2570
  generated?: {
2118
2571
  type: "stored" | "virtual";
2119
2572
  as: string;
2120
2573
  } | undefined;
2574
+ onUpdate?: any;
2575
+ autoincrement?: boolean | undefined;
2121
2576
  }>;
2122
2577
  indexes: Record<string, {
2123
2578
  name: string;
@@ -2125,7 +2580,7 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
2125
2580
  isUnique: boolean;
2126
2581
  using?: "btree" | "hash" | undefined;
2127
2582
  algorithm?: "default" | "inplace" | "copy" | undefined;
2128
- lock?: "none" | "default" | "shared" | "exclusive" | undefined;
2583
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2129
2584
  }>;
2130
2585
  compositePrimaryKeys: Record<string, {
2131
2586
  name: string;
@@ -2136,41 +2591,41 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
2136
2591
  columns: string[];
2137
2592
  }>;
2138
2593
  }>;
2139
- id: string;
2140
- prevId: string;
2141
- version: "1";
2142
- dialect: "singlestore";
2143
2594
  _meta: {
2144
- columns: Record<string, string>;
2145
2595
  tables: Record<string, string>;
2596
+ columns: Record<string, string>;
2146
2597
  };
2598
+ id: string;
2599
+ prevId: string;
2147
2600
  internal?: {
2148
- indexes?: Record<string, {
2601
+ tables?: Record<string, {
2149
2602
  columns: Record<string, {
2150
- isExpression?: boolean | undefined;
2603
+ isDefaultAnExpression?: boolean | undefined;
2151
2604
  } | undefined>;
2152
2605
  } | undefined> | undefined;
2153
- tables?: Record<string, {
2606
+ indexes?: Record<string, {
2154
2607
  columns: Record<string, {
2155
- isDefaultAnExpression?: boolean | undefined;
2608
+ isExpression?: boolean | undefined;
2156
2609
  } | undefined>;
2157
2610
  } | undefined> | undefined;
2158
2611
  } | undefined;
2159
2612
  }, {
2613
+ version: "1";
2614
+ dialect: "singlestore";
2160
2615
  tables: Record<string, {
2161
2616
  name: string;
2162
2617
  columns: Record<string, {
2163
- name: string;
2164
2618
  type: string;
2619
+ name: string;
2165
2620
  primaryKey: boolean;
2166
2621
  notNull: boolean;
2167
2622
  default?: any;
2168
- onUpdate?: any;
2169
- autoincrement?: boolean | undefined;
2170
2623
  generated?: {
2171
2624
  type: "stored" | "virtual";
2172
2625
  as: string;
2173
2626
  } | undefined;
2627
+ onUpdate?: any;
2628
+ autoincrement?: boolean | undefined;
2174
2629
  }>;
2175
2630
  indexes: Record<string, {
2176
2631
  name: string;
@@ -2178,7 +2633,7 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
2178
2633
  isUnique: boolean;
2179
2634
  using?: "btree" | "hash" | undefined;
2180
2635
  algorithm?: "default" | "inplace" | "copy" | undefined;
2181
- lock?: "none" | "default" | "shared" | "exclusive" | undefined;
2636
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2182
2637
  }>;
2183
2638
  compositePrimaryKeys: Record<string, {
2184
2639
  name: string;
@@ -2189,30 +2644,28 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
2189
2644
  columns: string[];
2190
2645
  }> | undefined;
2191
2646
  }>;
2192
- id: string;
2193
- prevId: string;
2194
- version: "1";
2195
- dialect: "singlestore";
2196
2647
  _meta: {
2197
- columns: Record<string, string>;
2198
2648
  tables: Record<string, string>;
2649
+ columns: Record<string, string>;
2199
2650
  };
2651
+ id: string;
2652
+ prevId: string;
2200
2653
  internal?: {
2201
- indexes?: Record<string, {
2654
+ tables?: Record<string, {
2202
2655
  columns: Record<string, {
2203
- isExpression?: boolean | undefined;
2656
+ isDefaultAnExpression?: boolean | undefined;
2204
2657
  } | undefined>;
2205
2658
  } | undefined> | undefined;
2206
- tables?: Record<string, {
2659
+ indexes?: Record<string, {
2207
2660
  columns: Record<string, {
2208
- isDefaultAnExpression?: boolean | undefined;
2661
+ isExpression?: boolean | undefined;
2209
2662
  } | undefined>;
2210
2663
  } | undefined> | undefined;
2211
2664
  } | undefined;
2212
2665
  }>;
2213
2666
  type SingleStoreSchema = TypeOf<typeof schema$1>;
2214
2667
 
2215
- declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
2668
+ declare const schema: zod.ZodObject<{
2216
2669
  version: zod.ZodLiteral<"6">;
2217
2670
  dialect: zod.ZodEnum<["sqlite"]>;
2218
2671
  tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
@@ -2235,27 +2688,27 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
2235
2688
  as: string;
2236
2689
  }>>;
2237
2690
  }, "strict", zod.ZodTypeAny, {
2238
- name: string;
2239
2691
  type: string;
2692
+ name: string;
2240
2693
  primaryKey: boolean;
2241
2694
  notNull: boolean;
2242
2695
  default?: any;
2243
- autoincrement?: boolean | undefined;
2244
2696
  generated?: {
2245
2697
  type: "stored" | "virtual";
2246
2698
  as: string;
2247
2699
  } | undefined;
2700
+ autoincrement?: boolean | undefined;
2248
2701
  }, {
2249
- name: string;
2250
2702
  type: string;
2703
+ name: string;
2251
2704
  primaryKey: boolean;
2252
2705
  notNull: boolean;
2253
2706
  default?: any;
2254
- autoincrement?: boolean | undefined;
2255
2707
  generated?: {
2256
2708
  type: "stored" | "virtual";
2257
2709
  as: string;
2258
2710
  } | undefined;
2711
+ autoincrement?: boolean | undefined;
2259
2712
  }>>;
2260
2713
  indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
2261
2714
  name: zod.ZodString;
@@ -2322,25 +2775,25 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
2322
2775
  name: zod.ZodString;
2323
2776
  value: zod.ZodString;
2324
2777
  }, "strict", zod.ZodTypeAny, {
2325
- name: string;
2326
2778
  value: string;
2327
- }, {
2328
2779
  name: string;
2780
+ }, {
2329
2781
  value: string;
2782
+ name: string;
2330
2783
  }>>>;
2331
2784
  }, "strict", zod.ZodTypeAny, {
2332
2785
  name: string;
2333
2786
  columns: Record<string, {
2334
- name: string;
2335
2787
  type: string;
2788
+ name: string;
2336
2789
  primaryKey: boolean;
2337
2790
  notNull: boolean;
2338
2791
  default?: any;
2339
- autoincrement?: boolean | undefined;
2340
2792
  generated?: {
2341
2793
  type: "stored" | "virtual";
2342
2794
  as: string;
2343
2795
  } | undefined;
2796
+ autoincrement?: boolean | undefined;
2344
2797
  }>;
2345
2798
  indexes: Record<string, {
2346
2799
  name: string;
@@ -2366,22 +2819,22 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
2366
2819
  columns: string[];
2367
2820
  }>;
2368
2821
  checkConstraints: Record<string, {
2369
- name: string;
2370
2822
  value: string;
2823
+ name: string;
2371
2824
  }>;
2372
2825
  }, {
2373
2826
  name: string;
2374
2827
  columns: Record<string, {
2375
- name: string;
2376
2828
  type: string;
2829
+ name: string;
2377
2830
  primaryKey: boolean;
2378
2831
  notNull: boolean;
2379
2832
  default?: any;
2380
- autoincrement?: boolean | undefined;
2381
2833
  generated?: {
2382
2834
  type: "stored" | "virtual";
2383
2835
  as: string;
2384
2836
  } | undefined;
2837
+ autoincrement?: boolean | undefined;
2385
2838
  }>;
2386
2839
  indexes: Record<string, {
2387
2840
  name: string;
@@ -2407,8 +2860,8 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
2407
2860
  columns: string[];
2408
2861
  }> | undefined;
2409
2862
  checkConstraints?: Record<string, {
2410
- name: string;
2411
2863
  value: string;
2864
+ name: string;
2412
2865
  }> | undefined;
2413
2866
  }>>;
2414
2867
  views: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
@@ -2431,59 +2884,59 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
2431
2884
  as: string;
2432
2885
  }>>;
2433
2886
  }, "strict", zod.ZodTypeAny, {
2434
- name: string;
2435
2887
  type: string;
2888
+ name: string;
2436
2889
  primaryKey: boolean;
2437
2890
  notNull: boolean;
2438
2891
  default?: any;
2439
- autoincrement?: boolean | undefined;
2440
2892
  generated?: {
2441
2893
  type: "stored" | "virtual";
2442
2894
  as: string;
2443
2895
  } | undefined;
2896
+ autoincrement?: boolean | undefined;
2444
2897
  }, {
2445
- name: string;
2446
2898
  type: string;
2899
+ name: string;
2447
2900
  primaryKey: boolean;
2448
2901
  notNull: boolean;
2449
2902
  default?: any;
2450
- autoincrement?: boolean | undefined;
2451
2903
  generated?: {
2452
2904
  type: "stored" | "virtual";
2453
2905
  as: string;
2454
2906
  } | undefined;
2907
+ autoincrement?: boolean | undefined;
2455
2908
  }>>;
2456
2909
  definition: zod.ZodOptional<zod.ZodString>;
2457
2910
  isExisting: zod.ZodBoolean;
2458
2911
  }, "strict", zod.ZodTypeAny, {
2459
2912
  name: string;
2460
2913
  columns: Record<string, {
2461
- name: string;
2462
2914
  type: string;
2915
+ name: string;
2463
2916
  primaryKey: boolean;
2464
2917
  notNull: boolean;
2465
2918
  default?: any;
2466
- autoincrement?: boolean | undefined;
2467
2919
  generated?: {
2468
2920
  type: "stored" | "virtual";
2469
2921
  as: string;
2470
2922
  } | undefined;
2923
+ autoincrement?: boolean | undefined;
2471
2924
  }>;
2472
2925
  isExisting: boolean;
2473
2926
  definition?: string | undefined;
2474
2927
  }, {
2475
2928
  name: string;
2476
2929
  columns: Record<string, {
2477
- name: string;
2478
2930
  type: string;
2931
+ name: string;
2479
2932
  primaryKey: boolean;
2480
2933
  notNull: boolean;
2481
2934
  default?: any;
2482
- autoincrement?: boolean | undefined;
2483
2935
  generated?: {
2484
2936
  type: "stored" | "virtual";
2485
2937
  as: string;
2486
2938
  } | undefined;
2939
+ autoincrement?: boolean | undefined;
2487
2940
  }>;
2488
2941
  isExisting: boolean;
2489
2942
  definition?: string | undefined;
@@ -2493,11 +2946,11 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
2493
2946
  tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
2494
2947
  columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
2495
2948
  }, "strip", zod.ZodTypeAny, {
2496
- columns: Record<string, string>;
2497
2949
  tables: Record<string, string>;
2498
- }, {
2499
2950
  columns: Record<string, string>;
2951
+ }, {
2500
2952
  tables: Record<string, string>;
2953
+ columns: Record<string, string>;
2501
2954
  }>;
2502
2955
  internal: zod.ZodOptional<zod.ZodObject<{
2503
2956
  indexes: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
@@ -2530,23 +2983,25 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
2530
2983
  } | undefined>;
2531
2984
  } | undefined> | undefined;
2532
2985
  }>>;
2533
- }, {
2986
+ } & {
2534
2987
  id: zod.ZodString;
2535
2988
  prevId: zod.ZodString;
2536
- }>, "strict", zod.ZodTypeAny, {
2989
+ }, "strict", zod.ZodTypeAny, {
2990
+ version: "6";
2991
+ dialect: "sqlite";
2537
2992
  tables: Record<string, {
2538
2993
  name: string;
2539
2994
  columns: Record<string, {
2540
- name: string;
2541
2995
  type: string;
2996
+ name: string;
2542
2997
  primaryKey: boolean;
2543
2998
  notNull: boolean;
2544
2999
  default?: any;
2545
- autoincrement?: boolean | undefined;
2546
3000
  generated?: {
2547
3001
  type: "stored" | "virtual";
2548
3002
  as: string;
2549
3003
  } | undefined;
3004
+ autoincrement?: boolean | undefined;
2550
3005
  }>;
2551
3006
  indexes: Record<string, {
2552
3007
  name: string;
@@ -2572,36 +3027,34 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
2572
3027
  columns: string[];
2573
3028
  }>;
2574
3029
  checkConstraints: Record<string, {
2575
- name: string;
2576
3030
  value: string;
3031
+ name: string;
2577
3032
  }>;
2578
3033
  }>;
2579
- id: string;
2580
- prevId: string;
2581
- version: "6";
2582
- dialect: "sqlite";
2583
- _meta: {
2584
- columns: Record<string, string>;
2585
- tables: Record<string, string>;
2586
- };
3034
+ enums: {};
2587
3035
  views: Record<string, {
2588
3036
  name: string;
2589
3037
  columns: Record<string, {
2590
- name: string;
2591
3038
  type: string;
3039
+ name: string;
2592
3040
  primaryKey: boolean;
2593
3041
  notNull: boolean;
2594
3042
  default?: any;
2595
- autoincrement?: boolean | undefined;
2596
3043
  generated?: {
2597
3044
  type: "stored" | "virtual";
2598
3045
  as: string;
2599
3046
  } | undefined;
3047
+ autoincrement?: boolean | undefined;
2600
3048
  }>;
2601
3049
  isExisting: boolean;
2602
3050
  definition?: string | undefined;
2603
3051
  }>;
2604
- enums: {};
3052
+ _meta: {
3053
+ tables: Record<string, string>;
3054
+ columns: Record<string, string>;
3055
+ };
3056
+ id: string;
3057
+ prevId: string;
2605
3058
  internal?: {
2606
3059
  indexes?: Record<string, {
2607
3060
  columns: Record<string, {
@@ -2610,19 +3063,21 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
2610
3063
  } | undefined> | undefined;
2611
3064
  } | undefined;
2612
3065
  }, {
3066
+ version: "6";
3067
+ dialect: "sqlite";
2613
3068
  tables: Record<string, {
2614
3069
  name: string;
2615
3070
  columns: Record<string, {
2616
- name: string;
2617
3071
  type: string;
3072
+ name: string;
2618
3073
  primaryKey: boolean;
2619
3074
  notNull: boolean;
2620
3075
  default?: any;
2621
- autoincrement?: boolean | undefined;
2622
3076
  generated?: {
2623
3077
  type: "stored" | "virtual";
2624
3078
  as: string;
2625
3079
  } | undefined;
3080
+ autoincrement?: boolean | undefined;
2626
3081
  }>;
2627
3082
  indexes: Record<string, {
2628
3083
  name: string;
@@ -2648,43 +3103,41 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
2648
3103
  columns: string[];
2649
3104
  }> | undefined;
2650
3105
  checkConstraints?: Record<string, {
2651
- name: string;
2652
3106
  value: string;
3107
+ name: string;
2653
3108
  }> | undefined;
2654
3109
  }>;
2655
- id: string;
2656
- prevId: string;
2657
- version: "6";
2658
- dialect: "sqlite";
3110
+ enums: {};
2659
3111
  _meta: {
2660
- columns: Record<string, string>;
2661
3112
  tables: Record<string, string>;
3113
+ columns: Record<string, string>;
2662
3114
  };
2663
- enums: {};
2664
- internal?: {
2665
- indexes?: Record<string, {
2666
- columns: Record<string, {
2667
- isExpression?: boolean | undefined;
2668
- } | undefined>;
2669
- } | undefined> | undefined;
2670
- } | undefined;
3115
+ id: string;
3116
+ prevId: string;
2671
3117
  views?: Record<string, {
2672
3118
  name: string;
2673
3119
  columns: Record<string, {
2674
- name: string;
2675
3120
  type: string;
3121
+ name: string;
2676
3122
  primaryKey: boolean;
2677
3123
  notNull: boolean;
2678
3124
  default?: any;
2679
- autoincrement?: boolean | undefined;
2680
3125
  generated?: {
2681
3126
  type: "stored" | "virtual";
2682
3127
  as: string;
2683
3128
  } | undefined;
3129
+ autoincrement?: boolean | undefined;
2684
3130
  }>;
2685
3131
  isExisting: boolean;
2686
3132
  definition?: string | undefined;
2687
3133
  }> | undefined;
3134
+ internal?: {
3135
+ indexes?: Record<string, {
3136
+ columns: Record<string, {
3137
+ isExpression?: boolean | undefined;
3138
+ } | undefined>;
3139
+ } | undefined> | undefined;
3140
+ } | undefined;
2688
3141
  }>;
2689
3142
  type SQLiteSchema = TypeOf<typeof schema>;
2690
3143
 
@@ -2700,6 +3153,14 @@ declare const pushSchema: (imports: Record<string, unknown>, drizzleInstance: Pg
2700
3153
  statementsToExecute: string[];
2701
3154
  apply: () => Promise<void>;
2702
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>;
2703
3164
  declare const generateSQLiteDrizzleJson: (imports: Record<string, unknown>, prevId?: string, casing?: CasingType) => Promise<SQLiteSchema>;
2704
3165
  declare const generateSQLiteMigration: (prev: DrizzleSQLiteSnapshotJSON, cur: DrizzleSQLiteSnapshotJSON) => Promise<string[]>;
2705
3166
  declare const pushSQLiteSchema: (imports: Record<string, unknown>, drizzleInstance: LibSQLDatabase<any>) => Promise<{
@@ -2708,6 +3169,14 @@ declare const pushSQLiteSchema: (imports: Record<string, unknown>, drizzleInstan
2708
3169
  statementsToExecute: string[];
2709
3170
  apply: () => Promise<void>;
2710
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>;
2711
3180
  declare const generateMySQLDrizzleJson: (imports: Record<string, unknown>, prevId?: string, casing?: CasingType) => Promise<MySqlSchema>;
2712
3181
  declare const generateMySQLMigration: (prev: DrizzleMySQLSnapshotJSON, cur: DrizzleMySQLSnapshotJSON) => Promise<string[]>;
2713
3182
  declare const pushMySQLSchema: (imports: Record<string, unknown>, drizzleInstance: MySql2Database<any>, databaseName: string) => Promise<{
@@ -2716,6 +3185,11 @@ declare const pushMySQLSchema: (imports: Record<string, unknown>, drizzleInstanc
2716
3185
  statementsToExecute: string[];
2717
3186
  apply: () => Promise<void>;
2718
3187
  }>;
3188
+ declare const startStudioMySQLServer: (imports: Record<string, unknown>, credentials: MysqlCredentials, options?: {
3189
+ host?: string;
3190
+ port?: number;
3191
+ casing?: CasingType;
3192
+ }) => Promise<void>;
2719
3193
  declare const generateSingleStoreDrizzleJson: (imports: Record<string, unknown>, prevId?: string, casing?: CasingType) => Promise<SingleStoreSchema>;
2720
3194
  declare const generateSingleStoreMigration: (prev: DrizzleSingleStoreSnapshotJSON, cur: DrizzleSingleStoreSnapshotJSON) => Promise<string[]>;
2721
3195
  declare const pushSingleStoreSchema: (imports: Record<string, unknown>, drizzleInstance: SingleStoreDriverDatabase<any>, databaseName: string) => Promise<{
@@ -2724,7 +3198,12 @@ declare const pushSingleStoreSchema: (imports: Record<string, unknown>, drizzleI
2724
3198
  statementsToExecute: string[];
2725
3199
  apply: () => Promise<void>;
2726
3200
  }>;
2727
- 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>) => {
2728
3207
  version: "7";
2729
3208
  dialect: "postgresql";
2730
3209
  tables: Record<string, {
@@ -2736,11 +3215,25 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => Record<string
2736
3215
  primaryKey: boolean;
2737
3216
  notNull: boolean;
2738
3217
  typeSchema?: string | undefined;
2739
- domainTypeSchema?: string | undefined;
2740
3218
  default?: any;
2741
3219
  isUnique?: any;
2742
3220
  uniqueName?: string | undefined;
2743
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;
2744
3237
  }>;
2745
3238
  indexes: Record<string, {
2746
3239
  name: string;
@@ -2776,6 +3269,21 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => Record<string
2776
3269
  columns: string[];
2777
3270
  nullsNotDistinct: boolean;
2778
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;
2779
3287
  }>;
2780
3288
  policies: Record<string, {
2781
3289
  name: string;
@@ -2793,6 +3301,17 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => Record<string
2793
3301
  schema: string;
2794
3302
  }>;
2795
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
+ }>;
2796
3315
  views: Record<string, {
2797
3316
  name: string;
2798
3317
  schema: string;
@@ -2802,7 +3321,6 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => Record<string
2802
3321
  primaryKey: boolean;
2803
3322
  notNull: boolean;
2804
3323
  typeSchema?: string | undefined;
2805
- domainTypeSchema?: string | undefined;
2806
3324
  default?: any;
2807
3325
  isUnique?: any;
2808
3326
  uniqueName?: string | undefined;
@@ -2886,6 +3404,6 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => Record<string
2886
3404
  } | undefined>;
2887
3405
  } | undefined>;
2888
3406
  } | undefined;
2889
- };
3407
+ } | Record<string, unknown>;
2890
3408
 
2891
- 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 };