@fengsoft/auth-db 0.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 (16) hide show
  1. package/CHANGELOG.md +7 -0
  2. package/LICENSE +100 -0
  3. package/README.md +24 -0
  4. package/dist/auth-db/src/index.d.ts +2732 -0
  5. package/dist/auth-db/src/index.d.ts.map +1 -0
  6. package/dist/auth-db/src/index.js +54 -0
  7. package/dist/auth-db/src/index.js.map +1 -0
  8. package/dist/auth-db/src/schema.d.ts +2700 -0
  9. package/dist/auth-db/src/schema.d.ts.map +1 -0
  10. package/dist/auth-db/src/schema.js +142 -0
  11. package/dist/auth-db/src/schema.js.map +1 -0
  12. package/dist/foundation-db/src/index.d.ts +16 -0
  13. package/dist/foundation-db/src/index.d.ts.map +1 -0
  14. package/dist/foundation-db/src/index.js +33 -0
  15. package/dist/foundation-db/src/index.js.map +1 -0
  16. package/package.json +38 -0
package/dist/auth-db/src/index.d.ts ADDED
@@ -0,0 +1,2732 @@
1
+ import { type ApiKeyConfigurationOptions, type ApiKeyOptions } from "@better-auth/api-key";
2
+ import { type DatabaseRuntimeConfig } from "@fengsoft/foundation-db";
3
+ import type { BetterAuthPlugin } from "better-auth";
4
+ import { getAuthTables } from "better-auth";
5
+ import { drizzleAdapter } from "better-auth/adapters/drizzle";
6
+ import { type MemoryDB } from "better-auth/adapters/memory";
7
+ import { organization } from "better-auth/plugins";
8
+ import { authSchema } from "./schema";
9
+ export type AuthSchemaOptions = Parameters<typeof getAuthTables>[0];
10
+ export type DrizzleAuthAdapterOptions = Omit<Parameters<typeof drizzleAdapter>[1], "provider">;
11
+ export type ApiKeysFeatureOptions = {
12
+ configurations?: ApiKeyConfigurationOptions | ApiKeyConfigurationOptions[];
13
+ options?: ApiKeyOptions;
14
+ };
15
+ export type FeatureAwareMemoryDatabaseOptions = {
16
+ emailAndPassword?: boolean | NonNullable<AuthSchemaOptions["emailAndPassword"]>;
17
+ organizations?: boolean | Parameters<typeof organization>[0];
18
+ apiKeys?: boolean | ApiKeysFeatureOptions;
19
+ plugins?: BetterAuthPlugin[];
20
+ };
21
+ export declare function buildMemoryAuthTables(options?: AuthSchemaOptions): MemoryDB;
22
+ export declare function createMemoryAuthDatabase(options?: AuthSchemaOptions): (options: import("better-auth").BetterAuthOptions) => import("better-auth").DBAdapter<import("better-auth").BetterAuthOptions>;
23
+ export declare function createFeatureAwareMemoryAuthDatabase(options?: FeatureAwareMemoryDatabaseOptions): (options: import("better-auth").BetterAuthOptions) => import("better-auth").DBAdapter<import("better-auth").BetterAuthOptions>;
24
+ export declare function createPostgresAuthDatabase(config: DatabaseRuntimeConfig, options?: DrizzleAuthAdapterOptions): {
25
+ pool: import("pg").Pool;
26
+ db: import("drizzle-orm/node-postgres").NodePgDatabase<{
27
+ account: import("drizzle-orm/pg-core").PgTableWithColumns<{
28
+ name: "auth_accounts";
29
+ schema: undefined;
30
+ columns: {
31
+ id: import("drizzle-orm/pg-core").PgColumn<{
32
+ name: string;
33
+ tableName: "auth_accounts";
34
+ dataType: "string";
35
+ columnType: "PgText";
36
+ data: string;
37
+ driverParam: string;
38
+ notNull: true;
39
+ hasDefault: true;
40
+ isPrimaryKey: true;
41
+ isAutoincrement: false;
42
+ hasRuntimeDefault: true;
43
+ enumValues: [string, ...string[]];
44
+ baseColumn: never;
45
+ identity: undefined;
46
+ generated: undefined;
47
+ }, {}, {}>;
48
+ accountId: import("drizzle-orm/pg-core").PgColumn<{
49
+ name: "account_id";
50
+ tableName: "auth_accounts";
51
+ dataType: "string";
52
+ columnType: "PgText";
53
+ data: string;
54
+ driverParam: string;
55
+ notNull: true;
56
+ hasDefault: false;
57
+ isPrimaryKey: false;
58
+ isAutoincrement: false;
59
+ hasRuntimeDefault: false;
60
+ enumValues: [string, ...string[]];
61
+ baseColumn: never;
62
+ identity: undefined;
63
+ generated: undefined;
64
+ }, {}, {}>;
65
+ providerId: import("drizzle-orm/pg-core").PgColumn<{
66
+ name: "provider_id";
67
+ tableName: "auth_accounts";
68
+ dataType: "string";
69
+ columnType: "PgText";
70
+ data: string;
71
+ driverParam: string;
72
+ notNull: true;
73
+ hasDefault: false;
74
+ isPrimaryKey: false;
75
+ isAutoincrement: false;
76
+ hasRuntimeDefault: false;
77
+ enumValues: [string, ...string[]];
78
+ baseColumn: never;
79
+ identity: undefined;
80
+ generated: undefined;
81
+ }, {}, {}>;
82
+ userId: import("drizzle-orm/pg-core").PgColumn<{
83
+ name: "user_id";
84
+ tableName: "auth_accounts";
85
+ dataType: "string";
86
+ columnType: "PgText";
87
+ data: string;
88
+ driverParam: string;
89
+ notNull: true;
90
+ hasDefault: false;
91
+ isPrimaryKey: false;
92
+ isAutoincrement: false;
93
+ hasRuntimeDefault: false;
94
+ enumValues: [string, ...string[]];
95
+ baseColumn: never;
96
+ identity: undefined;
97
+ generated: undefined;
98
+ }, {}, {}>;
99
+ accessToken: import("drizzle-orm/pg-core").PgColumn<{
100
+ name: "access_token";
101
+ tableName: "auth_accounts";
102
+ dataType: "string";
103
+ columnType: "PgText";
104
+ data: string;
105
+ driverParam: string;
106
+ notNull: false;
107
+ hasDefault: false;
108
+ isPrimaryKey: false;
109
+ isAutoincrement: false;
110
+ hasRuntimeDefault: false;
111
+ enumValues: [string, ...string[]];
112
+ baseColumn: never;
113
+ identity: undefined;
114
+ generated: undefined;
115
+ }, {}, {}>;
116
+ refreshToken: import("drizzle-orm/pg-core").PgColumn<{
117
+ name: "refresh_token";
118
+ tableName: "auth_accounts";
119
+ dataType: "string";
120
+ columnType: "PgText";
121
+ data: string;
122
+ driverParam: string;
123
+ notNull: false;
124
+ hasDefault: false;
125
+ isPrimaryKey: false;
126
+ isAutoincrement: false;
127
+ hasRuntimeDefault: false;
128
+ enumValues: [string, ...string[]];
129
+ baseColumn: never;
130
+ identity: undefined;
131
+ generated: undefined;
132
+ }, {}, {}>;
133
+ idToken: import("drizzle-orm/pg-core").PgColumn<{
134
+ name: "id_token";
135
+ tableName: "auth_accounts";
136
+ dataType: "string";
137
+ columnType: "PgText";
138
+ data: string;
139
+ driverParam: string;
140
+ notNull: false;
141
+ hasDefault: false;
142
+ isPrimaryKey: false;
143
+ isAutoincrement: false;
144
+ hasRuntimeDefault: false;
145
+ enumValues: [string, ...string[]];
146
+ baseColumn: never;
147
+ identity: undefined;
148
+ generated: undefined;
149
+ }, {}, {}>;
150
+ accessTokenExpiresAt: import("drizzle-orm/pg-core").PgColumn<{
151
+ name: "access_token_expires_at";
152
+ tableName: "auth_accounts";
153
+ dataType: "date";
154
+ columnType: "PgTimestamp";
155
+ data: Date;
156
+ driverParam: string;
157
+ notNull: false;
158
+ hasDefault: false;
159
+ isPrimaryKey: false;
160
+ isAutoincrement: false;
161
+ hasRuntimeDefault: false;
162
+ enumValues: undefined;
163
+ baseColumn: never;
164
+ identity: undefined;
165
+ generated: undefined;
166
+ }, {}, {}>;
167
+ refreshTokenExpiresAt: import("drizzle-orm/pg-core").PgColumn<{
168
+ name: "refresh_token_expires_at";
169
+ tableName: "auth_accounts";
170
+ dataType: "date";
171
+ columnType: "PgTimestamp";
172
+ data: Date;
173
+ driverParam: string;
174
+ notNull: false;
175
+ hasDefault: false;
176
+ isPrimaryKey: false;
177
+ isAutoincrement: false;
178
+ hasRuntimeDefault: false;
179
+ enumValues: undefined;
180
+ baseColumn: never;
181
+ identity: undefined;
182
+ generated: undefined;
183
+ }, {}, {}>;
184
+ scope: import("drizzle-orm/pg-core").PgColumn<{
185
+ name: "scope";
186
+ tableName: "auth_accounts";
187
+ dataType: "string";
188
+ columnType: "PgText";
189
+ data: string;
190
+ driverParam: string;
191
+ notNull: false;
192
+ hasDefault: false;
193
+ isPrimaryKey: false;
194
+ isAutoincrement: false;
195
+ hasRuntimeDefault: false;
196
+ enumValues: [string, ...string[]];
197
+ baseColumn: never;
198
+ identity: undefined;
199
+ generated: undefined;
200
+ }, {}, {}>;
201
+ password: import("drizzle-orm/pg-core").PgColumn<{
202
+ name: "password";
203
+ tableName: "auth_accounts";
204
+ dataType: "string";
205
+ columnType: "PgText";
206
+ data: string;
207
+ driverParam: string;
208
+ notNull: false;
209
+ hasDefault: false;
210
+ isPrimaryKey: false;
211
+ isAutoincrement: false;
212
+ hasRuntimeDefault: false;
213
+ enumValues: [string, ...string[]];
214
+ baseColumn: never;
215
+ identity: undefined;
216
+ generated: undefined;
217
+ }, {}, {}>;
218
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
219
+ name: string;
220
+ tableName: "auth_accounts";
221
+ dataType: "date";
222
+ columnType: "PgTimestamp";
223
+ data: Date;
224
+ driverParam: string;
225
+ notNull: true;
226
+ hasDefault: true;
227
+ isPrimaryKey: false;
228
+ isAutoincrement: false;
229
+ hasRuntimeDefault: false;
230
+ enumValues: undefined;
231
+ baseColumn: never;
232
+ identity: undefined;
233
+ generated: undefined;
234
+ }, {}, {}>;
235
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
236
+ name: string;
237
+ tableName: "auth_accounts";
238
+ dataType: "date";
239
+ columnType: "PgTimestamp";
240
+ data: Date;
241
+ driverParam: string;
242
+ notNull: true;
243
+ hasDefault: true;
244
+ isPrimaryKey: false;
245
+ isAutoincrement: false;
246
+ hasRuntimeDefault: false;
247
+ enumValues: undefined;
248
+ baseColumn: never;
249
+ identity: undefined;
250
+ generated: undefined;
251
+ }, {}, {}>;
252
+ };
253
+ dialect: "pg";
254
+ }>;
255
+ apikey: import("drizzle-orm/pg-core").PgTableWithColumns<{
256
+ name: "auth_api_keys";
257
+ schema: undefined;
258
+ columns: {
259
+ id: import("drizzle-orm/pg-core").PgColumn<{
260
+ name: string;
261
+ tableName: "auth_api_keys";
262
+ dataType: "string";
263
+ columnType: "PgText";
264
+ data: string;
265
+ driverParam: string;
266
+ notNull: true;
267
+ hasDefault: true;
268
+ isPrimaryKey: true;
269
+ isAutoincrement: false;
270
+ hasRuntimeDefault: true;
271
+ enumValues: [string, ...string[]];
272
+ baseColumn: never;
273
+ identity: undefined;
274
+ generated: undefined;
275
+ }, {}, {}>;
276
+ configId: import("drizzle-orm/pg-core").PgColumn<{
277
+ name: "config_id";
278
+ tableName: "auth_api_keys";
279
+ dataType: "string";
280
+ columnType: "PgText";
281
+ data: string;
282
+ driverParam: string;
283
+ notNull: true;
284
+ hasDefault: true;
285
+ isPrimaryKey: false;
286
+ isAutoincrement: false;
287
+ hasRuntimeDefault: false;
288
+ enumValues: [string, ...string[]];
289
+ baseColumn: never;
290
+ identity: undefined;
291
+ generated: undefined;
292
+ }, {}, {}>;
293
+ name: import("drizzle-orm/pg-core").PgColumn<{
294
+ name: "name";
295
+ tableName: "auth_api_keys";
296
+ dataType: "string";
297
+ columnType: "PgText";
298
+ data: string;
299
+ driverParam: string;
300
+ notNull: false;
301
+ hasDefault: false;
302
+ isPrimaryKey: false;
303
+ isAutoincrement: false;
304
+ hasRuntimeDefault: false;
305
+ enumValues: [string, ...string[]];
306
+ baseColumn: never;
307
+ identity: undefined;
308
+ generated: undefined;
309
+ }, {}, {}>;
310
+ start: import("drizzle-orm/pg-core").PgColumn<{
311
+ name: "start";
312
+ tableName: "auth_api_keys";
313
+ dataType: "string";
314
+ columnType: "PgText";
315
+ data: string;
316
+ driverParam: string;
317
+ notNull: false;
318
+ hasDefault: false;
319
+ isPrimaryKey: false;
320
+ isAutoincrement: false;
321
+ hasRuntimeDefault: false;
322
+ enumValues: [string, ...string[]];
323
+ baseColumn: never;
324
+ identity: undefined;
325
+ generated: undefined;
326
+ }, {}, {}>;
327
+ referenceId: import("drizzle-orm/pg-core").PgColumn<{
328
+ name: "reference_id";
329
+ tableName: "auth_api_keys";
330
+ dataType: "string";
331
+ columnType: "PgText";
332
+ data: string;
333
+ driverParam: string;
334
+ notNull: true;
335
+ hasDefault: false;
336
+ isPrimaryKey: false;
337
+ isAutoincrement: false;
338
+ hasRuntimeDefault: false;
339
+ enumValues: [string, ...string[]];
340
+ baseColumn: never;
341
+ identity: undefined;
342
+ generated: undefined;
343
+ }, {}, {}>;
344
+ prefix: import("drizzle-orm/pg-core").PgColumn<{
345
+ name: "prefix";
346
+ tableName: "auth_api_keys";
347
+ dataType: "string";
348
+ columnType: "PgText";
349
+ data: string;
350
+ driverParam: string;
351
+ notNull: false;
352
+ hasDefault: false;
353
+ isPrimaryKey: false;
354
+ isAutoincrement: false;
355
+ hasRuntimeDefault: false;
356
+ enumValues: [string, ...string[]];
357
+ baseColumn: never;
358
+ identity: undefined;
359
+ generated: undefined;
360
+ }, {}, {}>;
361
+ key: import("drizzle-orm/pg-core").PgColumn<{
362
+ name: "key";
363
+ tableName: "auth_api_keys";
364
+ dataType: "string";
365
+ columnType: "PgText";
366
+ data: string;
367
+ driverParam: string;
368
+ notNull: true;
369
+ hasDefault: false;
370
+ isPrimaryKey: false;
371
+ isAutoincrement: false;
372
+ hasRuntimeDefault: false;
373
+ enumValues: [string, ...string[]];
374
+ baseColumn: never;
375
+ identity: undefined;
376
+ generated: undefined;
377
+ }, {}, {}>;
378
+ refillInterval: import("drizzle-orm/pg-core").PgColumn<{
379
+ name: "refill_interval";
380
+ tableName: "auth_api_keys";
381
+ dataType: "number";
382
+ columnType: "PgInteger";
383
+ data: number;
384
+ driverParam: string | number;
385
+ notNull: false;
386
+ hasDefault: false;
387
+ isPrimaryKey: false;
388
+ isAutoincrement: false;
389
+ hasRuntimeDefault: false;
390
+ enumValues: undefined;
391
+ baseColumn: never;
392
+ identity: undefined;
393
+ generated: undefined;
394
+ }, {}, {}>;
395
+ refillAmount: import("drizzle-orm/pg-core").PgColumn<{
396
+ name: "refill_amount";
397
+ tableName: "auth_api_keys";
398
+ dataType: "number";
399
+ columnType: "PgInteger";
400
+ data: number;
401
+ driverParam: string | number;
402
+ notNull: false;
403
+ hasDefault: false;
404
+ isPrimaryKey: false;
405
+ isAutoincrement: false;
406
+ hasRuntimeDefault: false;
407
+ enumValues: undefined;
408
+ baseColumn: never;
409
+ identity: undefined;
410
+ generated: undefined;
411
+ }, {}, {}>;
412
+ lastRefillAt: import("drizzle-orm/pg-core").PgColumn<{
413
+ name: "last_refill_at";
414
+ tableName: "auth_api_keys";
415
+ dataType: "date";
416
+ columnType: "PgTimestamp";
417
+ data: Date;
418
+ driverParam: string;
419
+ notNull: false;
420
+ hasDefault: false;
421
+ isPrimaryKey: false;
422
+ isAutoincrement: false;
423
+ hasRuntimeDefault: false;
424
+ enumValues: undefined;
425
+ baseColumn: never;
426
+ identity: undefined;
427
+ generated: undefined;
428
+ }, {}, {}>;
429
+ enabled: import("drizzle-orm/pg-core").PgColumn<{
430
+ name: "enabled";
431
+ tableName: "auth_api_keys";
432
+ dataType: "boolean";
433
+ columnType: "PgBoolean";
434
+ data: boolean;
435
+ driverParam: boolean;
436
+ notNull: true;
437
+ hasDefault: true;
438
+ isPrimaryKey: false;
439
+ isAutoincrement: false;
440
+ hasRuntimeDefault: false;
441
+ enumValues: undefined;
442
+ baseColumn: never;
443
+ identity: undefined;
444
+ generated: undefined;
445
+ }, {}, {}>;
446
+ rateLimitEnabled: import("drizzle-orm/pg-core").PgColumn<{
447
+ name: "rate_limit_enabled";
448
+ tableName: "auth_api_keys";
449
+ dataType: "boolean";
450
+ columnType: "PgBoolean";
451
+ data: boolean;
452
+ driverParam: boolean;
453
+ notNull: true;
454
+ hasDefault: true;
455
+ isPrimaryKey: false;
456
+ isAutoincrement: false;
457
+ hasRuntimeDefault: false;
458
+ enumValues: undefined;
459
+ baseColumn: never;
460
+ identity: undefined;
461
+ generated: undefined;
462
+ }, {}, {}>;
463
+ rateLimitTimeWindow: import("drizzle-orm/pg-core").PgColumn<{
464
+ name: "rate_limit_time_window";
465
+ tableName: "auth_api_keys";
466
+ dataType: "number";
467
+ columnType: "PgInteger";
468
+ data: number;
469
+ driverParam: string | number;
470
+ notNull: true;
471
+ hasDefault: true;
472
+ isPrimaryKey: false;
473
+ isAutoincrement: false;
474
+ hasRuntimeDefault: false;
475
+ enumValues: undefined;
476
+ baseColumn: never;
477
+ identity: undefined;
478
+ generated: undefined;
479
+ }, {}, {}>;
480
+ rateLimitMax: import("drizzle-orm/pg-core").PgColumn<{
481
+ name: "rate_limit_max";
482
+ tableName: "auth_api_keys";
483
+ dataType: "number";
484
+ columnType: "PgInteger";
485
+ data: number;
486
+ driverParam: string | number;
487
+ notNull: true;
488
+ hasDefault: true;
489
+ isPrimaryKey: false;
490
+ isAutoincrement: false;
491
+ hasRuntimeDefault: false;
492
+ enumValues: undefined;
493
+ baseColumn: never;
494
+ identity: undefined;
495
+ generated: undefined;
496
+ }, {}, {}>;
497
+ requestCount: import("drizzle-orm/pg-core").PgColumn<{
498
+ name: "request_count";
499
+ tableName: "auth_api_keys";
500
+ dataType: "number";
501
+ columnType: "PgInteger";
502
+ data: number;
503
+ driverParam: string | number;
504
+ notNull: true;
505
+ hasDefault: true;
506
+ isPrimaryKey: false;
507
+ isAutoincrement: false;
508
+ hasRuntimeDefault: false;
509
+ enumValues: undefined;
510
+ baseColumn: never;
511
+ identity: undefined;
512
+ generated: undefined;
513
+ }, {}, {}>;
514
+ remaining: import("drizzle-orm/pg-core").PgColumn<{
515
+ name: "remaining";
516
+ tableName: "auth_api_keys";
517
+ dataType: "number";
518
+ columnType: "PgInteger";
519
+ data: number;
520
+ driverParam: string | number;
521
+ notNull: false;
522
+ hasDefault: false;
523
+ isPrimaryKey: false;
524
+ isAutoincrement: false;
525
+ hasRuntimeDefault: false;
526
+ enumValues: undefined;
527
+ baseColumn: never;
528
+ identity: undefined;
529
+ generated: undefined;
530
+ }, {}, {}>;
531
+ lastRequest: import("drizzle-orm/pg-core").PgColumn<{
532
+ name: "last_request";
533
+ tableName: "auth_api_keys";
534
+ dataType: "date";
535
+ columnType: "PgTimestamp";
536
+ data: Date;
537
+ driverParam: string;
538
+ notNull: false;
539
+ hasDefault: false;
540
+ isPrimaryKey: false;
541
+ isAutoincrement: false;
542
+ hasRuntimeDefault: false;
543
+ enumValues: undefined;
544
+ baseColumn: never;
545
+ identity: undefined;
546
+ generated: undefined;
547
+ }, {}, {}>;
548
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
549
+ name: "expires_at";
550
+ tableName: "auth_api_keys";
551
+ dataType: "date";
552
+ columnType: "PgTimestamp";
553
+ data: Date;
554
+ driverParam: string;
555
+ notNull: false;
556
+ hasDefault: false;
557
+ isPrimaryKey: false;
558
+ isAutoincrement: false;
559
+ hasRuntimeDefault: false;
560
+ enumValues: undefined;
561
+ baseColumn: never;
562
+ identity: undefined;
563
+ generated: undefined;
564
+ }, {}, {}>;
565
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
566
+ name: string;
567
+ tableName: "auth_api_keys";
568
+ dataType: "date";
569
+ columnType: "PgTimestamp";
570
+ data: Date;
571
+ driverParam: string;
572
+ notNull: true;
573
+ hasDefault: true;
574
+ isPrimaryKey: false;
575
+ isAutoincrement: false;
576
+ hasRuntimeDefault: false;
577
+ enumValues: undefined;
578
+ baseColumn: never;
579
+ identity: undefined;
580
+ generated: undefined;
581
+ }, {}, {}>;
582
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
583
+ name: string;
584
+ tableName: "auth_api_keys";
585
+ dataType: "date";
586
+ columnType: "PgTimestamp";
587
+ data: Date;
588
+ driverParam: string;
589
+ notNull: true;
590
+ hasDefault: true;
591
+ isPrimaryKey: false;
592
+ isAutoincrement: false;
593
+ hasRuntimeDefault: false;
594
+ enumValues: undefined;
595
+ baseColumn: never;
596
+ identity: undefined;
597
+ generated: undefined;
598
+ }, {}, {}>;
599
+ permissions: import("drizzle-orm/pg-core").PgColumn<{
600
+ name: "permissions";
601
+ tableName: "auth_api_keys";
602
+ dataType: "string";
603
+ columnType: "PgText";
604
+ data: string;
605
+ driverParam: string;
606
+ notNull: false;
607
+ hasDefault: false;
608
+ isPrimaryKey: false;
609
+ isAutoincrement: false;
610
+ hasRuntimeDefault: false;
611
+ enumValues: [string, ...string[]];
612
+ baseColumn: never;
613
+ identity: undefined;
614
+ generated: undefined;
615
+ }, {}, {}>;
616
+ metadata: import("drizzle-orm/pg-core").PgColumn<{
617
+ name: "metadata";
618
+ tableName: "auth_api_keys";
619
+ dataType: "string";
620
+ columnType: "PgText";
621
+ data: string;
622
+ driverParam: string;
623
+ notNull: false;
624
+ hasDefault: false;
625
+ isPrimaryKey: false;
626
+ isAutoincrement: false;
627
+ hasRuntimeDefault: false;
628
+ enumValues: [string, ...string[]];
629
+ baseColumn: never;
630
+ identity: undefined;
631
+ generated: undefined;
632
+ }, {}, {}>;
633
+ };
634
+ dialect: "pg";
635
+ }>;
636
+ invitation: import("drizzle-orm/pg-core").PgTableWithColumns<{
637
+ name: "auth_invitations";
638
+ schema: undefined;
639
+ columns: {
640
+ id: import("drizzle-orm/pg-core").PgColumn<{
641
+ name: string;
642
+ tableName: "auth_invitations";
643
+ dataType: "string";
644
+ columnType: "PgText";
645
+ data: string;
646
+ driverParam: string;
647
+ notNull: true;
648
+ hasDefault: true;
649
+ isPrimaryKey: true;
650
+ isAutoincrement: false;
651
+ hasRuntimeDefault: true;
652
+ enumValues: [string, ...string[]];
653
+ baseColumn: never;
654
+ identity: undefined;
655
+ generated: undefined;
656
+ }, {}, {}>;
657
+ organizationId: import("drizzle-orm/pg-core").PgColumn<{
658
+ name: "organization_id";
659
+ tableName: "auth_invitations";
660
+ dataType: "string";
661
+ columnType: "PgText";
662
+ data: string;
663
+ driverParam: string;
664
+ notNull: true;
665
+ hasDefault: false;
666
+ isPrimaryKey: false;
667
+ isAutoincrement: false;
668
+ hasRuntimeDefault: false;
669
+ enumValues: [string, ...string[]];
670
+ baseColumn: never;
671
+ identity: undefined;
672
+ generated: undefined;
673
+ }, {}, {}>;
674
+ email: import("drizzle-orm/pg-core").PgColumn<{
675
+ name: "email";
676
+ tableName: "auth_invitations";
677
+ dataType: "string";
678
+ columnType: "PgText";
679
+ data: string;
680
+ driverParam: string;
681
+ notNull: true;
682
+ hasDefault: false;
683
+ isPrimaryKey: false;
684
+ isAutoincrement: false;
685
+ hasRuntimeDefault: false;
686
+ enumValues: [string, ...string[]];
687
+ baseColumn: never;
688
+ identity: undefined;
689
+ generated: undefined;
690
+ }, {}, {}>;
691
+ role: import("drizzle-orm/pg-core").PgColumn<{
692
+ name: "role";
693
+ tableName: "auth_invitations";
694
+ dataType: "string";
695
+ columnType: "PgText";
696
+ data: string;
697
+ driverParam: string;
698
+ notNull: false;
699
+ hasDefault: false;
700
+ isPrimaryKey: false;
701
+ isAutoincrement: false;
702
+ hasRuntimeDefault: false;
703
+ enumValues: [string, ...string[]];
704
+ baseColumn: never;
705
+ identity: undefined;
706
+ generated: undefined;
707
+ }, {}, {}>;
708
+ status: import("drizzle-orm/pg-core").PgColumn<{
709
+ name: "status";
710
+ tableName: "auth_invitations";
711
+ dataType: "string";
712
+ columnType: "PgText";
713
+ data: string;
714
+ driverParam: string;
715
+ notNull: true;
716
+ hasDefault: true;
717
+ isPrimaryKey: false;
718
+ isAutoincrement: false;
719
+ hasRuntimeDefault: false;
720
+ enumValues: [string, ...string[]];
721
+ baseColumn: never;
722
+ identity: undefined;
723
+ generated: undefined;
724
+ }, {}, {}>;
725
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
726
+ name: "expires_at";
727
+ tableName: "auth_invitations";
728
+ dataType: "date";
729
+ columnType: "PgTimestamp";
730
+ data: Date;
731
+ driverParam: string;
732
+ notNull: true;
733
+ hasDefault: false;
734
+ isPrimaryKey: false;
735
+ isAutoincrement: false;
736
+ hasRuntimeDefault: false;
737
+ enumValues: undefined;
738
+ baseColumn: never;
739
+ identity: undefined;
740
+ generated: undefined;
741
+ }, {}, {}>;
742
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
743
+ name: string;
744
+ tableName: "auth_invitations";
745
+ dataType: "date";
746
+ columnType: "PgTimestamp";
747
+ data: Date;
748
+ driverParam: string;
749
+ notNull: true;
750
+ hasDefault: true;
751
+ isPrimaryKey: false;
752
+ isAutoincrement: false;
753
+ hasRuntimeDefault: false;
754
+ enumValues: undefined;
755
+ baseColumn: never;
756
+ identity: undefined;
757
+ generated: undefined;
758
+ }, {}, {}>;
759
+ inviterId: import("drizzle-orm/pg-core").PgColumn<{
760
+ name: "inviter_id";
761
+ tableName: "auth_invitations";
762
+ dataType: "string";
763
+ columnType: "PgText";
764
+ data: string;
765
+ driverParam: string;
766
+ notNull: true;
767
+ hasDefault: false;
768
+ isPrimaryKey: false;
769
+ isAutoincrement: false;
770
+ hasRuntimeDefault: false;
771
+ enumValues: [string, ...string[]];
772
+ baseColumn: never;
773
+ identity: undefined;
774
+ generated: undefined;
775
+ }, {}, {}>;
776
+ };
777
+ dialect: "pg";
778
+ }>;
779
+ member: import("drizzle-orm/pg-core").PgTableWithColumns<{
780
+ name: "auth_members";
781
+ schema: undefined;
782
+ columns: {
783
+ id: import("drizzle-orm/pg-core").PgColumn<{
784
+ name: string;
785
+ tableName: "auth_members";
786
+ dataType: "string";
787
+ columnType: "PgText";
788
+ data: string;
789
+ driverParam: string;
790
+ notNull: true;
791
+ hasDefault: true;
792
+ isPrimaryKey: true;
793
+ isAutoincrement: false;
794
+ hasRuntimeDefault: true;
795
+ enumValues: [string, ...string[]];
796
+ baseColumn: never;
797
+ identity: undefined;
798
+ generated: undefined;
799
+ }, {}, {}>;
800
+ organizationId: import("drizzle-orm/pg-core").PgColumn<{
801
+ name: "organization_id";
802
+ tableName: "auth_members";
803
+ dataType: "string";
804
+ columnType: "PgText";
805
+ data: string;
806
+ driverParam: string;
807
+ notNull: true;
808
+ hasDefault: false;
809
+ isPrimaryKey: false;
810
+ isAutoincrement: false;
811
+ hasRuntimeDefault: false;
812
+ enumValues: [string, ...string[]];
813
+ baseColumn: never;
814
+ identity: undefined;
815
+ generated: undefined;
816
+ }, {}, {}>;
817
+ userId: import("drizzle-orm/pg-core").PgColumn<{
818
+ name: "user_id";
819
+ tableName: "auth_members";
820
+ dataType: "string";
821
+ columnType: "PgText";
822
+ data: string;
823
+ driverParam: string;
824
+ notNull: true;
825
+ hasDefault: false;
826
+ isPrimaryKey: false;
827
+ isAutoincrement: false;
828
+ hasRuntimeDefault: false;
829
+ enumValues: [string, ...string[]];
830
+ baseColumn: never;
831
+ identity: undefined;
832
+ generated: undefined;
833
+ }, {}, {}>;
834
+ role: import("drizzle-orm/pg-core").PgColumn<{
835
+ name: "role";
836
+ tableName: "auth_members";
837
+ dataType: "string";
838
+ columnType: "PgText";
839
+ data: string;
840
+ driverParam: string;
841
+ notNull: true;
842
+ hasDefault: true;
843
+ isPrimaryKey: false;
844
+ isAutoincrement: false;
845
+ hasRuntimeDefault: false;
846
+ enumValues: [string, ...string[]];
847
+ baseColumn: never;
848
+ identity: undefined;
849
+ generated: undefined;
850
+ }, {}, {}>;
851
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
852
+ name: string;
853
+ tableName: "auth_members";
854
+ dataType: "date";
855
+ columnType: "PgTimestamp";
856
+ data: Date;
857
+ driverParam: string;
858
+ notNull: true;
859
+ hasDefault: true;
860
+ isPrimaryKey: false;
861
+ isAutoincrement: false;
862
+ hasRuntimeDefault: false;
863
+ enumValues: undefined;
864
+ baseColumn: never;
865
+ identity: undefined;
866
+ generated: undefined;
867
+ }, {}, {}>;
868
+ };
869
+ dialect: "pg";
870
+ }>;
871
+ organization: import("drizzle-orm/pg-core").PgTableWithColumns<{
872
+ name: "auth_organizations";
873
+ schema: undefined;
874
+ columns: {
875
+ id: import("drizzle-orm/pg-core").PgColumn<{
876
+ name: string;
877
+ tableName: "auth_organizations";
878
+ dataType: "string";
879
+ columnType: "PgText";
880
+ data: string;
881
+ driverParam: string;
882
+ notNull: true;
883
+ hasDefault: true;
884
+ isPrimaryKey: true;
885
+ isAutoincrement: false;
886
+ hasRuntimeDefault: true;
887
+ enumValues: [string, ...string[]];
888
+ baseColumn: never;
889
+ identity: undefined;
890
+ generated: undefined;
891
+ }, {}, {}>;
892
+ name: import("drizzle-orm/pg-core").PgColumn<{
893
+ name: "name";
894
+ tableName: "auth_organizations";
895
+ dataType: "string";
896
+ columnType: "PgText";
897
+ data: string;
898
+ driverParam: string;
899
+ notNull: true;
900
+ hasDefault: false;
901
+ isPrimaryKey: false;
902
+ isAutoincrement: false;
903
+ hasRuntimeDefault: false;
904
+ enumValues: [string, ...string[]];
905
+ baseColumn: never;
906
+ identity: undefined;
907
+ generated: undefined;
908
+ }, {}, {}>;
909
+ slug: import("drizzle-orm/pg-core").PgColumn<{
910
+ name: "slug";
911
+ tableName: "auth_organizations";
912
+ dataType: "string";
913
+ columnType: "PgText";
914
+ data: string;
915
+ driverParam: string;
916
+ notNull: true;
917
+ hasDefault: false;
918
+ isPrimaryKey: false;
919
+ isAutoincrement: false;
920
+ hasRuntimeDefault: false;
921
+ enumValues: [string, ...string[]];
922
+ baseColumn: never;
923
+ identity: undefined;
924
+ generated: undefined;
925
+ }, {}, {}>;
926
+ logo: import("drizzle-orm/pg-core").PgColumn<{
927
+ name: "logo";
928
+ tableName: "auth_organizations";
929
+ dataType: "string";
930
+ columnType: "PgText";
931
+ data: string;
932
+ driverParam: string;
933
+ notNull: false;
934
+ hasDefault: false;
935
+ isPrimaryKey: false;
936
+ isAutoincrement: false;
937
+ hasRuntimeDefault: false;
938
+ enumValues: [string, ...string[]];
939
+ baseColumn: never;
940
+ identity: undefined;
941
+ generated: undefined;
942
+ }, {}, {}>;
943
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
944
+ name: string;
945
+ tableName: "auth_organizations";
946
+ dataType: "date";
947
+ columnType: "PgTimestamp";
948
+ data: Date;
949
+ driverParam: string;
950
+ notNull: true;
951
+ hasDefault: true;
952
+ isPrimaryKey: false;
953
+ isAutoincrement: false;
954
+ hasRuntimeDefault: false;
955
+ enumValues: undefined;
956
+ baseColumn: never;
957
+ identity: undefined;
958
+ generated: undefined;
959
+ }, {}, {}>;
960
+ metadata: import("drizzle-orm/pg-core").PgColumn<{
961
+ name: "metadata";
962
+ tableName: "auth_organizations";
963
+ dataType: "string";
964
+ columnType: "PgText";
965
+ data: string;
966
+ driverParam: string;
967
+ notNull: false;
968
+ hasDefault: false;
969
+ isPrimaryKey: false;
970
+ isAutoincrement: false;
971
+ hasRuntimeDefault: false;
972
+ enumValues: [string, ...string[]];
973
+ baseColumn: never;
974
+ identity: undefined;
975
+ generated: undefined;
976
+ }, {}, {}>;
977
+ };
978
+ dialect: "pg";
979
+ }>;
980
+ session: import("drizzle-orm/pg-core").PgTableWithColumns<{
981
+ name: "auth_sessions";
982
+ schema: undefined;
983
+ columns: {
984
+ id: import("drizzle-orm/pg-core").PgColumn<{
985
+ name: string;
986
+ tableName: "auth_sessions";
987
+ dataType: "string";
988
+ columnType: "PgText";
989
+ data: string;
990
+ driverParam: string;
991
+ notNull: true;
992
+ hasDefault: true;
993
+ isPrimaryKey: true;
994
+ isAutoincrement: false;
995
+ hasRuntimeDefault: true;
996
+ enumValues: [string, ...string[]];
997
+ baseColumn: never;
998
+ identity: undefined;
999
+ generated: undefined;
1000
+ }, {}, {}>;
1001
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
1002
+ name: "expires_at";
1003
+ tableName: "auth_sessions";
1004
+ dataType: "date";
1005
+ columnType: "PgTimestamp";
1006
+ data: Date;
1007
+ driverParam: string;
1008
+ notNull: true;
1009
+ hasDefault: false;
1010
+ isPrimaryKey: false;
1011
+ isAutoincrement: false;
1012
+ hasRuntimeDefault: false;
1013
+ enumValues: undefined;
1014
+ baseColumn: never;
1015
+ identity: undefined;
1016
+ generated: undefined;
1017
+ }, {}, {}>;
1018
+ token: import("drizzle-orm/pg-core").PgColumn<{
1019
+ name: "token";
1020
+ tableName: "auth_sessions";
1021
+ dataType: "string";
1022
+ columnType: "PgText";
1023
+ data: string;
1024
+ driverParam: string;
1025
+ notNull: true;
1026
+ hasDefault: false;
1027
+ isPrimaryKey: false;
1028
+ isAutoincrement: false;
1029
+ hasRuntimeDefault: false;
1030
+ enumValues: [string, ...string[]];
1031
+ baseColumn: never;
1032
+ identity: undefined;
1033
+ generated: undefined;
1034
+ }, {}, {}>;
1035
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1036
+ name: string;
1037
+ tableName: "auth_sessions";
1038
+ dataType: "date";
1039
+ columnType: "PgTimestamp";
1040
+ data: Date;
1041
+ driverParam: string;
1042
+ notNull: true;
1043
+ hasDefault: true;
1044
+ isPrimaryKey: false;
1045
+ isAutoincrement: false;
1046
+ hasRuntimeDefault: false;
1047
+ enumValues: undefined;
1048
+ baseColumn: never;
1049
+ identity: undefined;
1050
+ generated: undefined;
1051
+ }, {}, {}>;
1052
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1053
+ name: string;
1054
+ tableName: "auth_sessions";
1055
+ dataType: "date";
1056
+ columnType: "PgTimestamp";
1057
+ data: Date;
1058
+ driverParam: string;
1059
+ notNull: true;
1060
+ hasDefault: true;
1061
+ isPrimaryKey: false;
1062
+ isAutoincrement: false;
1063
+ hasRuntimeDefault: false;
1064
+ enumValues: undefined;
1065
+ baseColumn: never;
1066
+ identity: undefined;
1067
+ generated: undefined;
1068
+ }, {}, {}>;
1069
+ ipAddress: import("drizzle-orm/pg-core").PgColumn<{
1070
+ name: "ip_address";
1071
+ tableName: "auth_sessions";
1072
+ dataType: "string";
1073
+ columnType: "PgText";
1074
+ data: string;
1075
+ driverParam: string;
1076
+ notNull: false;
1077
+ hasDefault: false;
1078
+ isPrimaryKey: false;
1079
+ isAutoincrement: false;
1080
+ hasRuntimeDefault: false;
1081
+ enumValues: [string, ...string[]];
1082
+ baseColumn: never;
1083
+ identity: undefined;
1084
+ generated: undefined;
1085
+ }, {}, {}>;
1086
+ userAgent: import("drizzle-orm/pg-core").PgColumn<{
1087
+ name: "user_agent";
1088
+ tableName: "auth_sessions";
1089
+ dataType: "string";
1090
+ columnType: "PgText";
1091
+ data: string;
1092
+ driverParam: string;
1093
+ notNull: false;
1094
+ hasDefault: false;
1095
+ isPrimaryKey: false;
1096
+ isAutoincrement: false;
1097
+ hasRuntimeDefault: false;
1098
+ enumValues: [string, ...string[]];
1099
+ baseColumn: never;
1100
+ identity: undefined;
1101
+ generated: undefined;
1102
+ }, {}, {}>;
1103
+ userId: import("drizzle-orm/pg-core").PgColumn<{
1104
+ name: "user_id";
1105
+ tableName: "auth_sessions";
1106
+ dataType: "string";
1107
+ columnType: "PgText";
1108
+ data: string;
1109
+ driverParam: string;
1110
+ notNull: true;
1111
+ hasDefault: false;
1112
+ isPrimaryKey: false;
1113
+ isAutoincrement: false;
1114
+ hasRuntimeDefault: false;
1115
+ enumValues: [string, ...string[]];
1116
+ baseColumn: never;
1117
+ identity: undefined;
1118
+ generated: undefined;
1119
+ }, {}, {}>;
1120
+ activeOrganizationId: import("drizzle-orm/pg-core").PgColumn<{
1121
+ name: "active_organization_id";
1122
+ tableName: "auth_sessions";
1123
+ dataType: "string";
1124
+ columnType: "PgText";
1125
+ data: string;
1126
+ driverParam: string;
1127
+ notNull: false;
1128
+ hasDefault: false;
1129
+ isPrimaryKey: false;
1130
+ isAutoincrement: false;
1131
+ hasRuntimeDefault: false;
1132
+ enumValues: [string, ...string[]];
1133
+ baseColumn: never;
1134
+ identity: undefined;
1135
+ generated: undefined;
1136
+ }, {}, {}>;
1137
+ };
1138
+ dialect: "pg";
1139
+ }>;
1140
+ user: import("drizzle-orm/pg-core").PgTableWithColumns<{
1141
+ name: "auth_users";
1142
+ schema: undefined;
1143
+ columns: {
1144
+ id: import("drizzle-orm/pg-core").PgColumn<{
1145
+ name: string;
1146
+ tableName: "auth_users";
1147
+ dataType: "string";
1148
+ columnType: "PgText";
1149
+ data: string;
1150
+ driverParam: string;
1151
+ notNull: true;
1152
+ hasDefault: true;
1153
+ isPrimaryKey: true;
1154
+ isAutoincrement: false;
1155
+ hasRuntimeDefault: true;
1156
+ enumValues: [string, ...string[]];
1157
+ baseColumn: never;
1158
+ identity: undefined;
1159
+ generated: undefined;
1160
+ }, {}, {}>;
1161
+ name: import("drizzle-orm/pg-core").PgColumn<{
1162
+ name: "name";
1163
+ tableName: "auth_users";
1164
+ dataType: "string";
1165
+ columnType: "PgText";
1166
+ data: string;
1167
+ driverParam: string;
1168
+ notNull: true;
1169
+ hasDefault: false;
1170
+ isPrimaryKey: false;
1171
+ isAutoincrement: false;
1172
+ hasRuntimeDefault: false;
1173
+ enumValues: [string, ...string[]];
1174
+ baseColumn: never;
1175
+ identity: undefined;
1176
+ generated: undefined;
1177
+ }, {}, {}>;
1178
+ email: import("drizzle-orm/pg-core").PgColumn<{
1179
+ name: "email";
1180
+ tableName: "auth_users";
1181
+ dataType: "string";
1182
+ columnType: "PgText";
1183
+ data: string;
1184
+ driverParam: string;
1185
+ notNull: true;
1186
+ hasDefault: false;
1187
+ isPrimaryKey: false;
1188
+ isAutoincrement: false;
1189
+ hasRuntimeDefault: false;
1190
+ enumValues: [string, ...string[]];
1191
+ baseColumn: never;
1192
+ identity: undefined;
1193
+ generated: undefined;
1194
+ }, {}, {}>;
1195
+ emailVerified: import("drizzle-orm/pg-core").PgColumn<{
1196
+ name: "email_verified";
1197
+ tableName: "auth_users";
1198
+ dataType: "boolean";
1199
+ columnType: "PgBoolean";
1200
+ data: boolean;
1201
+ driverParam: boolean;
1202
+ notNull: true;
1203
+ hasDefault: true;
1204
+ isPrimaryKey: false;
1205
+ isAutoincrement: false;
1206
+ hasRuntimeDefault: false;
1207
+ enumValues: undefined;
1208
+ baseColumn: never;
1209
+ identity: undefined;
1210
+ generated: undefined;
1211
+ }, {}, {}>;
1212
+ image: import("drizzle-orm/pg-core").PgColumn<{
1213
+ name: "image";
1214
+ tableName: "auth_users";
1215
+ dataType: "string";
1216
+ columnType: "PgText";
1217
+ data: string;
1218
+ driverParam: string;
1219
+ notNull: false;
1220
+ hasDefault: false;
1221
+ isPrimaryKey: false;
1222
+ isAutoincrement: false;
1223
+ hasRuntimeDefault: false;
1224
+ enumValues: [string, ...string[]];
1225
+ baseColumn: never;
1226
+ identity: undefined;
1227
+ generated: undefined;
1228
+ }, {}, {}>;
1229
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1230
+ name: string;
1231
+ tableName: "auth_users";
1232
+ dataType: "date";
1233
+ columnType: "PgTimestamp";
1234
+ data: Date;
1235
+ driverParam: string;
1236
+ notNull: true;
1237
+ hasDefault: true;
1238
+ isPrimaryKey: false;
1239
+ isAutoincrement: false;
1240
+ hasRuntimeDefault: false;
1241
+ enumValues: undefined;
1242
+ baseColumn: never;
1243
+ identity: undefined;
1244
+ generated: undefined;
1245
+ }, {}, {}>;
1246
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1247
+ name: string;
1248
+ tableName: "auth_users";
1249
+ dataType: "date";
1250
+ columnType: "PgTimestamp";
1251
+ data: Date;
1252
+ driverParam: string;
1253
+ notNull: true;
1254
+ hasDefault: true;
1255
+ isPrimaryKey: false;
1256
+ isAutoincrement: false;
1257
+ hasRuntimeDefault: false;
1258
+ enumValues: undefined;
1259
+ baseColumn: never;
1260
+ identity: undefined;
1261
+ generated: undefined;
1262
+ }, {}, {}>;
1263
+ };
1264
+ dialect: "pg";
1265
+ }>;
1266
+ verification: import("drizzle-orm/pg-core").PgTableWithColumns<{
1267
+ name: "auth_verifications";
1268
+ schema: undefined;
1269
+ columns: {
1270
+ id: import("drizzle-orm/pg-core").PgColumn<{
1271
+ name: string;
1272
+ tableName: "auth_verifications";
1273
+ dataType: "string";
1274
+ columnType: "PgText";
1275
+ data: string;
1276
+ driverParam: string;
1277
+ notNull: true;
1278
+ hasDefault: true;
1279
+ isPrimaryKey: true;
1280
+ isAutoincrement: false;
1281
+ hasRuntimeDefault: true;
1282
+ enumValues: [string, ...string[]];
1283
+ baseColumn: never;
1284
+ identity: undefined;
1285
+ generated: undefined;
1286
+ }, {}, {}>;
1287
+ identifier: import("drizzle-orm/pg-core").PgColumn<{
1288
+ name: "identifier";
1289
+ tableName: "auth_verifications";
1290
+ dataType: "string";
1291
+ columnType: "PgText";
1292
+ data: string;
1293
+ driverParam: string;
1294
+ notNull: true;
1295
+ hasDefault: false;
1296
+ isPrimaryKey: false;
1297
+ isAutoincrement: false;
1298
+ hasRuntimeDefault: false;
1299
+ enumValues: [string, ...string[]];
1300
+ baseColumn: never;
1301
+ identity: undefined;
1302
+ generated: undefined;
1303
+ }, {}, {}>;
1304
+ value: import("drizzle-orm/pg-core").PgColumn<{
1305
+ name: "value";
1306
+ tableName: "auth_verifications";
1307
+ dataType: "string";
1308
+ columnType: "PgText";
1309
+ data: string;
1310
+ driverParam: string;
1311
+ notNull: true;
1312
+ hasDefault: false;
1313
+ isPrimaryKey: false;
1314
+ isAutoincrement: false;
1315
+ hasRuntimeDefault: false;
1316
+ enumValues: [string, ...string[]];
1317
+ baseColumn: never;
1318
+ identity: undefined;
1319
+ generated: undefined;
1320
+ }, {}, {}>;
1321
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
1322
+ name: "expires_at";
1323
+ tableName: "auth_verifications";
1324
+ dataType: "date";
1325
+ columnType: "PgTimestamp";
1326
+ data: Date;
1327
+ driverParam: string;
1328
+ notNull: true;
1329
+ hasDefault: false;
1330
+ isPrimaryKey: false;
1331
+ isAutoincrement: false;
1332
+ hasRuntimeDefault: false;
1333
+ enumValues: undefined;
1334
+ baseColumn: never;
1335
+ identity: undefined;
1336
+ generated: undefined;
1337
+ }, {}, {}>;
1338
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1339
+ name: string;
1340
+ tableName: "auth_verifications";
1341
+ dataType: "date";
1342
+ columnType: "PgTimestamp";
1343
+ data: Date;
1344
+ driverParam: string;
1345
+ notNull: true;
1346
+ hasDefault: true;
1347
+ isPrimaryKey: false;
1348
+ isAutoincrement: false;
1349
+ hasRuntimeDefault: false;
1350
+ enumValues: undefined;
1351
+ baseColumn: never;
1352
+ identity: undefined;
1353
+ generated: undefined;
1354
+ }, {}, {}>;
1355
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1356
+ name: string;
1357
+ tableName: "auth_verifications";
1358
+ dataType: "date";
1359
+ columnType: "PgTimestamp";
1360
+ data: Date;
1361
+ driverParam: string;
1362
+ notNull: true;
1363
+ hasDefault: true;
1364
+ isPrimaryKey: false;
1365
+ isAutoincrement: false;
1366
+ hasRuntimeDefault: false;
1367
+ enumValues: undefined;
1368
+ baseColumn: never;
1369
+ identity: undefined;
1370
+ generated: undefined;
1371
+ }, {}, {}>;
1372
+ };
1373
+ dialect: "pg";
1374
+ }>;
1375
+ }> & {
1376
+ $client: import("pg").Pool;
1377
+ };
1378
+ adapter: (options: import("better-auth").BetterAuthOptions) => import("better-auth").DBAdapter<import("better-auth").BetterAuthOptions>;
1379
+ schema: {
1380
+ account: import("drizzle-orm/pg-core").PgTableWithColumns<{
1381
+ name: "auth_accounts";
1382
+ schema: undefined;
1383
+ columns: {
1384
+ id: import("drizzle-orm/pg-core").PgColumn<{
1385
+ name: string;
1386
+ tableName: "auth_accounts";
1387
+ dataType: "string";
1388
+ columnType: "PgText";
1389
+ data: string;
1390
+ driverParam: string;
1391
+ notNull: true;
1392
+ hasDefault: true;
1393
+ isPrimaryKey: true;
1394
+ isAutoincrement: false;
1395
+ hasRuntimeDefault: true;
1396
+ enumValues: [string, ...string[]];
1397
+ baseColumn: never;
1398
+ identity: undefined;
1399
+ generated: undefined;
1400
+ }, {}, {}>;
1401
+ accountId: import("drizzle-orm/pg-core").PgColumn<{
1402
+ name: "account_id";
1403
+ tableName: "auth_accounts";
1404
+ dataType: "string";
1405
+ columnType: "PgText";
1406
+ data: string;
1407
+ driverParam: string;
1408
+ notNull: true;
1409
+ hasDefault: false;
1410
+ isPrimaryKey: false;
1411
+ isAutoincrement: false;
1412
+ hasRuntimeDefault: false;
1413
+ enumValues: [string, ...string[]];
1414
+ baseColumn: never;
1415
+ identity: undefined;
1416
+ generated: undefined;
1417
+ }, {}, {}>;
1418
+ providerId: import("drizzle-orm/pg-core").PgColumn<{
1419
+ name: "provider_id";
1420
+ tableName: "auth_accounts";
1421
+ dataType: "string";
1422
+ columnType: "PgText";
1423
+ data: string;
1424
+ driverParam: string;
1425
+ notNull: true;
1426
+ hasDefault: false;
1427
+ isPrimaryKey: false;
1428
+ isAutoincrement: false;
1429
+ hasRuntimeDefault: false;
1430
+ enumValues: [string, ...string[]];
1431
+ baseColumn: never;
1432
+ identity: undefined;
1433
+ generated: undefined;
1434
+ }, {}, {}>;
1435
+ userId: import("drizzle-orm/pg-core").PgColumn<{
1436
+ name: "user_id";
1437
+ tableName: "auth_accounts";
1438
+ dataType: "string";
1439
+ columnType: "PgText";
1440
+ data: string;
1441
+ driverParam: string;
1442
+ notNull: true;
1443
+ hasDefault: false;
1444
+ isPrimaryKey: false;
1445
+ isAutoincrement: false;
1446
+ hasRuntimeDefault: false;
1447
+ enumValues: [string, ...string[]];
1448
+ baseColumn: never;
1449
+ identity: undefined;
1450
+ generated: undefined;
1451
+ }, {}, {}>;
1452
+ accessToken: import("drizzle-orm/pg-core").PgColumn<{
1453
+ name: "access_token";
1454
+ tableName: "auth_accounts";
1455
+ dataType: "string";
1456
+ columnType: "PgText";
1457
+ data: string;
1458
+ driverParam: string;
1459
+ notNull: false;
1460
+ hasDefault: false;
1461
+ isPrimaryKey: false;
1462
+ isAutoincrement: false;
1463
+ hasRuntimeDefault: false;
1464
+ enumValues: [string, ...string[]];
1465
+ baseColumn: never;
1466
+ identity: undefined;
1467
+ generated: undefined;
1468
+ }, {}, {}>;
1469
+ refreshToken: import("drizzle-orm/pg-core").PgColumn<{
1470
+ name: "refresh_token";
1471
+ tableName: "auth_accounts";
1472
+ dataType: "string";
1473
+ columnType: "PgText";
1474
+ data: string;
1475
+ driverParam: string;
1476
+ notNull: false;
1477
+ hasDefault: false;
1478
+ isPrimaryKey: false;
1479
+ isAutoincrement: false;
1480
+ hasRuntimeDefault: false;
1481
+ enumValues: [string, ...string[]];
1482
+ baseColumn: never;
1483
+ identity: undefined;
1484
+ generated: undefined;
1485
+ }, {}, {}>;
1486
+ idToken: import("drizzle-orm/pg-core").PgColumn<{
1487
+ name: "id_token";
1488
+ tableName: "auth_accounts";
1489
+ dataType: "string";
1490
+ columnType: "PgText";
1491
+ data: string;
1492
+ driverParam: string;
1493
+ notNull: false;
1494
+ hasDefault: false;
1495
+ isPrimaryKey: false;
1496
+ isAutoincrement: false;
1497
+ hasRuntimeDefault: false;
1498
+ enumValues: [string, ...string[]];
1499
+ baseColumn: never;
1500
+ identity: undefined;
1501
+ generated: undefined;
1502
+ }, {}, {}>;
1503
+ accessTokenExpiresAt: import("drizzle-orm/pg-core").PgColumn<{
1504
+ name: "access_token_expires_at";
1505
+ tableName: "auth_accounts";
1506
+ dataType: "date";
1507
+ columnType: "PgTimestamp";
1508
+ data: Date;
1509
+ driverParam: string;
1510
+ notNull: false;
1511
+ hasDefault: false;
1512
+ isPrimaryKey: false;
1513
+ isAutoincrement: false;
1514
+ hasRuntimeDefault: false;
1515
+ enumValues: undefined;
1516
+ baseColumn: never;
1517
+ identity: undefined;
1518
+ generated: undefined;
1519
+ }, {}, {}>;
1520
+ refreshTokenExpiresAt: import("drizzle-orm/pg-core").PgColumn<{
1521
+ name: "refresh_token_expires_at";
1522
+ tableName: "auth_accounts";
1523
+ dataType: "date";
1524
+ columnType: "PgTimestamp";
1525
+ data: Date;
1526
+ driverParam: string;
1527
+ notNull: false;
1528
+ hasDefault: false;
1529
+ isPrimaryKey: false;
1530
+ isAutoincrement: false;
1531
+ hasRuntimeDefault: false;
1532
+ enumValues: undefined;
1533
+ baseColumn: never;
1534
+ identity: undefined;
1535
+ generated: undefined;
1536
+ }, {}, {}>;
1537
+ scope: import("drizzle-orm/pg-core").PgColumn<{
1538
+ name: "scope";
1539
+ tableName: "auth_accounts";
1540
+ dataType: "string";
1541
+ columnType: "PgText";
1542
+ data: string;
1543
+ driverParam: string;
1544
+ notNull: false;
1545
+ hasDefault: false;
1546
+ isPrimaryKey: false;
1547
+ isAutoincrement: false;
1548
+ hasRuntimeDefault: false;
1549
+ enumValues: [string, ...string[]];
1550
+ baseColumn: never;
1551
+ identity: undefined;
1552
+ generated: undefined;
1553
+ }, {}, {}>;
1554
+ password: import("drizzle-orm/pg-core").PgColumn<{
1555
+ name: "password";
1556
+ tableName: "auth_accounts";
1557
+ dataType: "string";
1558
+ columnType: "PgText";
1559
+ data: string;
1560
+ driverParam: string;
1561
+ notNull: false;
1562
+ hasDefault: false;
1563
+ isPrimaryKey: false;
1564
+ isAutoincrement: false;
1565
+ hasRuntimeDefault: false;
1566
+ enumValues: [string, ...string[]];
1567
+ baseColumn: never;
1568
+ identity: undefined;
1569
+ generated: undefined;
1570
+ }, {}, {}>;
1571
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1572
+ name: string;
1573
+ tableName: "auth_accounts";
1574
+ dataType: "date";
1575
+ columnType: "PgTimestamp";
1576
+ data: Date;
1577
+ driverParam: string;
1578
+ notNull: true;
1579
+ hasDefault: true;
1580
+ isPrimaryKey: false;
1581
+ isAutoincrement: false;
1582
+ hasRuntimeDefault: false;
1583
+ enumValues: undefined;
1584
+ baseColumn: never;
1585
+ identity: undefined;
1586
+ generated: undefined;
1587
+ }, {}, {}>;
1588
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1589
+ name: string;
1590
+ tableName: "auth_accounts";
1591
+ dataType: "date";
1592
+ columnType: "PgTimestamp";
1593
+ data: Date;
1594
+ driverParam: string;
1595
+ notNull: true;
1596
+ hasDefault: true;
1597
+ isPrimaryKey: false;
1598
+ isAutoincrement: false;
1599
+ hasRuntimeDefault: false;
1600
+ enumValues: undefined;
1601
+ baseColumn: never;
1602
+ identity: undefined;
1603
+ generated: undefined;
1604
+ }, {}, {}>;
1605
+ };
1606
+ dialect: "pg";
1607
+ }>;
1608
+ apikey: import("drizzle-orm/pg-core").PgTableWithColumns<{
1609
+ name: "auth_api_keys";
1610
+ schema: undefined;
1611
+ columns: {
1612
+ id: import("drizzle-orm/pg-core").PgColumn<{
1613
+ name: string;
1614
+ tableName: "auth_api_keys";
1615
+ dataType: "string";
1616
+ columnType: "PgText";
1617
+ data: string;
1618
+ driverParam: string;
1619
+ notNull: true;
1620
+ hasDefault: true;
1621
+ isPrimaryKey: true;
1622
+ isAutoincrement: false;
1623
+ hasRuntimeDefault: true;
1624
+ enumValues: [string, ...string[]];
1625
+ baseColumn: never;
1626
+ identity: undefined;
1627
+ generated: undefined;
1628
+ }, {}, {}>;
1629
+ configId: import("drizzle-orm/pg-core").PgColumn<{
1630
+ name: "config_id";
1631
+ tableName: "auth_api_keys";
1632
+ dataType: "string";
1633
+ columnType: "PgText";
1634
+ data: string;
1635
+ driverParam: string;
1636
+ notNull: true;
1637
+ hasDefault: true;
1638
+ isPrimaryKey: false;
1639
+ isAutoincrement: false;
1640
+ hasRuntimeDefault: false;
1641
+ enumValues: [string, ...string[]];
1642
+ baseColumn: never;
1643
+ identity: undefined;
1644
+ generated: undefined;
1645
+ }, {}, {}>;
1646
+ name: import("drizzle-orm/pg-core").PgColumn<{
1647
+ name: "name";
1648
+ tableName: "auth_api_keys";
1649
+ dataType: "string";
1650
+ columnType: "PgText";
1651
+ data: string;
1652
+ driverParam: string;
1653
+ notNull: false;
1654
+ hasDefault: false;
1655
+ isPrimaryKey: false;
1656
+ isAutoincrement: false;
1657
+ hasRuntimeDefault: false;
1658
+ enumValues: [string, ...string[]];
1659
+ baseColumn: never;
1660
+ identity: undefined;
1661
+ generated: undefined;
1662
+ }, {}, {}>;
1663
+ start: import("drizzle-orm/pg-core").PgColumn<{
1664
+ name: "start";
1665
+ tableName: "auth_api_keys";
1666
+ dataType: "string";
1667
+ columnType: "PgText";
1668
+ data: string;
1669
+ driverParam: string;
1670
+ notNull: false;
1671
+ hasDefault: false;
1672
+ isPrimaryKey: false;
1673
+ isAutoincrement: false;
1674
+ hasRuntimeDefault: false;
1675
+ enumValues: [string, ...string[]];
1676
+ baseColumn: never;
1677
+ identity: undefined;
1678
+ generated: undefined;
1679
+ }, {}, {}>;
1680
+ referenceId: import("drizzle-orm/pg-core").PgColumn<{
1681
+ name: "reference_id";
1682
+ tableName: "auth_api_keys";
1683
+ dataType: "string";
1684
+ columnType: "PgText";
1685
+ data: string;
1686
+ driverParam: string;
1687
+ notNull: true;
1688
+ hasDefault: false;
1689
+ isPrimaryKey: false;
1690
+ isAutoincrement: false;
1691
+ hasRuntimeDefault: false;
1692
+ enumValues: [string, ...string[]];
1693
+ baseColumn: never;
1694
+ identity: undefined;
1695
+ generated: undefined;
1696
+ }, {}, {}>;
1697
+ prefix: import("drizzle-orm/pg-core").PgColumn<{
1698
+ name: "prefix";
1699
+ tableName: "auth_api_keys";
1700
+ dataType: "string";
1701
+ columnType: "PgText";
1702
+ data: string;
1703
+ driverParam: string;
1704
+ notNull: false;
1705
+ hasDefault: false;
1706
+ isPrimaryKey: false;
1707
+ isAutoincrement: false;
1708
+ hasRuntimeDefault: false;
1709
+ enumValues: [string, ...string[]];
1710
+ baseColumn: never;
1711
+ identity: undefined;
1712
+ generated: undefined;
1713
+ }, {}, {}>;
1714
+ key: import("drizzle-orm/pg-core").PgColumn<{
1715
+ name: "key";
1716
+ tableName: "auth_api_keys";
1717
+ dataType: "string";
1718
+ columnType: "PgText";
1719
+ data: string;
1720
+ driverParam: string;
1721
+ notNull: true;
1722
+ hasDefault: false;
1723
+ isPrimaryKey: false;
1724
+ isAutoincrement: false;
1725
+ hasRuntimeDefault: false;
1726
+ enumValues: [string, ...string[]];
1727
+ baseColumn: never;
1728
+ identity: undefined;
1729
+ generated: undefined;
1730
+ }, {}, {}>;
1731
+ refillInterval: import("drizzle-orm/pg-core").PgColumn<{
1732
+ name: "refill_interval";
1733
+ tableName: "auth_api_keys";
1734
+ dataType: "number";
1735
+ columnType: "PgInteger";
1736
+ data: number;
1737
+ driverParam: string | number;
1738
+ notNull: false;
1739
+ hasDefault: false;
1740
+ isPrimaryKey: false;
1741
+ isAutoincrement: false;
1742
+ hasRuntimeDefault: false;
1743
+ enumValues: undefined;
1744
+ baseColumn: never;
1745
+ identity: undefined;
1746
+ generated: undefined;
1747
+ }, {}, {}>;
1748
+ refillAmount: import("drizzle-orm/pg-core").PgColumn<{
1749
+ name: "refill_amount";
1750
+ tableName: "auth_api_keys";
1751
+ dataType: "number";
1752
+ columnType: "PgInteger";
1753
+ data: number;
1754
+ driverParam: string | number;
1755
+ notNull: false;
1756
+ hasDefault: false;
1757
+ isPrimaryKey: false;
1758
+ isAutoincrement: false;
1759
+ hasRuntimeDefault: false;
1760
+ enumValues: undefined;
1761
+ baseColumn: never;
1762
+ identity: undefined;
1763
+ generated: undefined;
1764
+ }, {}, {}>;
1765
+ lastRefillAt: import("drizzle-orm/pg-core").PgColumn<{
1766
+ name: "last_refill_at";
1767
+ tableName: "auth_api_keys";
1768
+ dataType: "date";
1769
+ columnType: "PgTimestamp";
1770
+ data: Date;
1771
+ driverParam: string;
1772
+ notNull: false;
1773
+ hasDefault: false;
1774
+ isPrimaryKey: false;
1775
+ isAutoincrement: false;
1776
+ hasRuntimeDefault: false;
1777
+ enumValues: undefined;
1778
+ baseColumn: never;
1779
+ identity: undefined;
1780
+ generated: undefined;
1781
+ }, {}, {}>;
1782
+ enabled: import("drizzle-orm/pg-core").PgColumn<{
1783
+ name: "enabled";
1784
+ tableName: "auth_api_keys";
1785
+ dataType: "boolean";
1786
+ columnType: "PgBoolean";
1787
+ data: boolean;
1788
+ driverParam: boolean;
1789
+ notNull: true;
1790
+ hasDefault: true;
1791
+ isPrimaryKey: false;
1792
+ isAutoincrement: false;
1793
+ hasRuntimeDefault: false;
1794
+ enumValues: undefined;
1795
+ baseColumn: never;
1796
+ identity: undefined;
1797
+ generated: undefined;
1798
+ }, {}, {}>;
1799
+ rateLimitEnabled: import("drizzle-orm/pg-core").PgColumn<{
1800
+ name: "rate_limit_enabled";
1801
+ tableName: "auth_api_keys";
1802
+ dataType: "boolean";
1803
+ columnType: "PgBoolean";
1804
+ data: boolean;
1805
+ driverParam: boolean;
1806
+ notNull: true;
1807
+ hasDefault: true;
1808
+ isPrimaryKey: false;
1809
+ isAutoincrement: false;
1810
+ hasRuntimeDefault: false;
1811
+ enumValues: undefined;
1812
+ baseColumn: never;
1813
+ identity: undefined;
1814
+ generated: undefined;
1815
+ }, {}, {}>;
1816
+ rateLimitTimeWindow: import("drizzle-orm/pg-core").PgColumn<{
1817
+ name: "rate_limit_time_window";
1818
+ tableName: "auth_api_keys";
1819
+ dataType: "number";
1820
+ columnType: "PgInteger";
1821
+ data: number;
1822
+ driverParam: string | number;
1823
+ notNull: true;
1824
+ hasDefault: true;
1825
+ isPrimaryKey: false;
1826
+ isAutoincrement: false;
1827
+ hasRuntimeDefault: false;
1828
+ enumValues: undefined;
1829
+ baseColumn: never;
1830
+ identity: undefined;
1831
+ generated: undefined;
1832
+ }, {}, {}>;
1833
+ rateLimitMax: import("drizzle-orm/pg-core").PgColumn<{
1834
+ name: "rate_limit_max";
1835
+ tableName: "auth_api_keys";
1836
+ dataType: "number";
1837
+ columnType: "PgInteger";
1838
+ data: number;
1839
+ driverParam: string | number;
1840
+ notNull: true;
1841
+ hasDefault: true;
1842
+ isPrimaryKey: false;
1843
+ isAutoincrement: false;
1844
+ hasRuntimeDefault: false;
1845
+ enumValues: undefined;
1846
+ baseColumn: never;
1847
+ identity: undefined;
1848
+ generated: undefined;
1849
+ }, {}, {}>;
1850
+ requestCount: import("drizzle-orm/pg-core").PgColumn<{
1851
+ name: "request_count";
1852
+ tableName: "auth_api_keys";
1853
+ dataType: "number";
1854
+ columnType: "PgInteger";
1855
+ data: number;
1856
+ driverParam: string | number;
1857
+ notNull: true;
1858
+ hasDefault: true;
1859
+ isPrimaryKey: false;
1860
+ isAutoincrement: false;
1861
+ hasRuntimeDefault: false;
1862
+ enumValues: undefined;
1863
+ baseColumn: never;
1864
+ identity: undefined;
1865
+ generated: undefined;
1866
+ }, {}, {}>;
1867
+ remaining: import("drizzle-orm/pg-core").PgColumn<{
1868
+ name: "remaining";
1869
+ tableName: "auth_api_keys";
1870
+ dataType: "number";
1871
+ columnType: "PgInteger";
1872
+ data: number;
1873
+ driverParam: string | number;
1874
+ notNull: false;
1875
+ hasDefault: false;
1876
+ isPrimaryKey: false;
1877
+ isAutoincrement: false;
1878
+ hasRuntimeDefault: false;
1879
+ enumValues: undefined;
1880
+ baseColumn: never;
1881
+ identity: undefined;
1882
+ generated: undefined;
1883
+ }, {}, {}>;
1884
+ lastRequest: import("drizzle-orm/pg-core").PgColumn<{
1885
+ name: "last_request";
1886
+ tableName: "auth_api_keys";
1887
+ dataType: "date";
1888
+ columnType: "PgTimestamp";
1889
+ data: Date;
1890
+ driverParam: string;
1891
+ notNull: false;
1892
+ hasDefault: false;
1893
+ isPrimaryKey: false;
1894
+ isAutoincrement: false;
1895
+ hasRuntimeDefault: false;
1896
+ enumValues: undefined;
1897
+ baseColumn: never;
1898
+ identity: undefined;
1899
+ generated: undefined;
1900
+ }, {}, {}>;
1901
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
1902
+ name: "expires_at";
1903
+ tableName: "auth_api_keys";
1904
+ dataType: "date";
1905
+ columnType: "PgTimestamp";
1906
+ data: Date;
1907
+ driverParam: string;
1908
+ notNull: false;
1909
+ hasDefault: false;
1910
+ isPrimaryKey: false;
1911
+ isAutoincrement: false;
1912
+ hasRuntimeDefault: false;
1913
+ enumValues: undefined;
1914
+ baseColumn: never;
1915
+ identity: undefined;
1916
+ generated: undefined;
1917
+ }, {}, {}>;
1918
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1919
+ name: string;
1920
+ tableName: "auth_api_keys";
1921
+ dataType: "date";
1922
+ columnType: "PgTimestamp";
1923
+ data: Date;
1924
+ driverParam: string;
1925
+ notNull: true;
1926
+ hasDefault: true;
1927
+ isPrimaryKey: false;
1928
+ isAutoincrement: false;
1929
+ hasRuntimeDefault: false;
1930
+ enumValues: undefined;
1931
+ baseColumn: never;
1932
+ identity: undefined;
1933
+ generated: undefined;
1934
+ }, {}, {}>;
1935
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1936
+ name: string;
1937
+ tableName: "auth_api_keys";
1938
+ dataType: "date";
1939
+ columnType: "PgTimestamp";
1940
+ data: Date;
1941
+ driverParam: string;
1942
+ notNull: true;
1943
+ hasDefault: true;
1944
+ isPrimaryKey: false;
1945
+ isAutoincrement: false;
1946
+ hasRuntimeDefault: false;
1947
+ enumValues: undefined;
1948
+ baseColumn: never;
1949
+ identity: undefined;
1950
+ generated: undefined;
1951
+ }, {}, {}>;
1952
+ permissions: import("drizzle-orm/pg-core").PgColumn<{
1953
+ name: "permissions";
1954
+ tableName: "auth_api_keys";
1955
+ dataType: "string";
1956
+ columnType: "PgText";
1957
+ data: string;
1958
+ driverParam: string;
1959
+ notNull: false;
1960
+ hasDefault: false;
1961
+ isPrimaryKey: false;
1962
+ isAutoincrement: false;
1963
+ hasRuntimeDefault: false;
1964
+ enumValues: [string, ...string[]];
1965
+ baseColumn: never;
1966
+ identity: undefined;
1967
+ generated: undefined;
1968
+ }, {}, {}>;
1969
+ metadata: import("drizzle-orm/pg-core").PgColumn<{
1970
+ name: "metadata";
1971
+ tableName: "auth_api_keys";
1972
+ dataType: "string";
1973
+ columnType: "PgText";
1974
+ data: string;
1975
+ driverParam: string;
1976
+ notNull: false;
1977
+ hasDefault: false;
1978
+ isPrimaryKey: false;
1979
+ isAutoincrement: false;
1980
+ hasRuntimeDefault: false;
1981
+ enumValues: [string, ...string[]];
1982
+ baseColumn: never;
1983
+ identity: undefined;
1984
+ generated: undefined;
1985
+ }, {}, {}>;
1986
+ };
1987
+ dialect: "pg";
1988
+ }>;
1989
+ invitation: import("drizzle-orm/pg-core").PgTableWithColumns<{
1990
+ name: "auth_invitations";
1991
+ schema: undefined;
1992
+ columns: {
1993
+ id: import("drizzle-orm/pg-core").PgColumn<{
1994
+ name: string;
1995
+ tableName: "auth_invitations";
1996
+ dataType: "string";
1997
+ columnType: "PgText";
1998
+ data: string;
1999
+ driverParam: string;
2000
+ notNull: true;
2001
+ hasDefault: true;
2002
+ isPrimaryKey: true;
2003
+ isAutoincrement: false;
2004
+ hasRuntimeDefault: true;
2005
+ enumValues: [string, ...string[]];
2006
+ baseColumn: never;
2007
+ identity: undefined;
2008
+ generated: undefined;
2009
+ }, {}, {}>;
2010
+ organizationId: import("drizzle-orm/pg-core").PgColumn<{
2011
+ name: "organization_id";
2012
+ tableName: "auth_invitations";
2013
+ dataType: "string";
2014
+ columnType: "PgText";
2015
+ data: string;
2016
+ driverParam: string;
2017
+ notNull: true;
2018
+ hasDefault: false;
2019
+ isPrimaryKey: false;
2020
+ isAutoincrement: false;
2021
+ hasRuntimeDefault: false;
2022
+ enumValues: [string, ...string[]];
2023
+ baseColumn: never;
2024
+ identity: undefined;
2025
+ generated: undefined;
2026
+ }, {}, {}>;
2027
+ email: import("drizzle-orm/pg-core").PgColumn<{
2028
+ name: "email";
2029
+ tableName: "auth_invitations";
2030
+ dataType: "string";
2031
+ columnType: "PgText";
2032
+ data: string;
2033
+ driverParam: string;
2034
+ notNull: true;
2035
+ hasDefault: false;
2036
+ isPrimaryKey: false;
2037
+ isAutoincrement: false;
2038
+ hasRuntimeDefault: false;
2039
+ enumValues: [string, ...string[]];
2040
+ baseColumn: never;
2041
+ identity: undefined;
2042
+ generated: undefined;
2043
+ }, {}, {}>;
2044
+ role: import("drizzle-orm/pg-core").PgColumn<{
2045
+ name: "role";
2046
+ tableName: "auth_invitations";
2047
+ dataType: "string";
2048
+ columnType: "PgText";
2049
+ data: string;
2050
+ driverParam: string;
2051
+ notNull: false;
2052
+ hasDefault: false;
2053
+ isPrimaryKey: false;
2054
+ isAutoincrement: false;
2055
+ hasRuntimeDefault: false;
2056
+ enumValues: [string, ...string[]];
2057
+ baseColumn: never;
2058
+ identity: undefined;
2059
+ generated: undefined;
2060
+ }, {}, {}>;
2061
+ status: import("drizzle-orm/pg-core").PgColumn<{
2062
+ name: "status";
2063
+ tableName: "auth_invitations";
2064
+ dataType: "string";
2065
+ columnType: "PgText";
2066
+ data: string;
2067
+ driverParam: string;
2068
+ notNull: true;
2069
+ hasDefault: true;
2070
+ isPrimaryKey: false;
2071
+ isAutoincrement: false;
2072
+ hasRuntimeDefault: false;
2073
+ enumValues: [string, ...string[]];
2074
+ baseColumn: never;
2075
+ identity: undefined;
2076
+ generated: undefined;
2077
+ }, {}, {}>;
2078
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
2079
+ name: "expires_at";
2080
+ tableName: "auth_invitations";
2081
+ dataType: "date";
2082
+ columnType: "PgTimestamp";
2083
+ data: Date;
2084
+ driverParam: string;
2085
+ notNull: true;
2086
+ hasDefault: false;
2087
+ isPrimaryKey: false;
2088
+ isAutoincrement: false;
2089
+ hasRuntimeDefault: false;
2090
+ enumValues: undefined;
2091
+ baseColumn: never;
2092
+ identity: undefined;
2093
+ generated: undefined;
2094
+ }, {}, {}>;
2095
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2096
+ name: string;
2097
+ tableName: "auth_invitations";
2098
+ dataType: "date";
2099
+ columnType: "PgTimestamp";
2100
+ data: Date;
2101
+ driverParam: string;
2102
+ notNull: true;
2103
+ hasDefault: true;
2104
+ isPrimaryKey: false;
2105
+ isAutoincrement: false;
2106
+ hasRuntimeDefault: false;
2107
+ enumValues: undefined;
2108
+ baseColumn: never;
2109
+ identity: undefined;
2110
+ generated: undefined;
2111
+ }, {}, {}>;
2112
+ inviterId: import("drizzle-orm/pg-core").PgColumn<{
2113
+ name: "inviter_id";
2114
+ tableName: "auth_invitations";
2115
+ dataType: "string";
2116
+ columnType: "PgText";
2117
+ data: string;
2118
+ driverParam: string;
2119
+ notNull: true;
2120
+ hasDefault: false;
2121
+ isPrimaryKey: false;
2122
+ isAutoincrement: false;
2123
+ hasRuntimeDefault: false;
2124
+ enumValues: [string, ...string[]];
2125
+ baseColumn: never;
2126
+ identity: undefined;
2127
+ generated: undefined;
2128
+ }, {}, {}>;
2129
+ };
2130
+ dialect: "pg";
2131
+ }>;
2132
+ member: import("drizzle-orm/pg-core").PgTableWithColumns<{
2133
+ name: "auth_members";
2134
+ schema: undefined;
2135
+ columns: {
2136
+ id: import("drizzle-orm/pg-core").PgColumn<{
2137
+ name: string;
2138
+ tableName: "auth_members";
2139
+ dataType: "string";
2140
+ columnType: "PgText";
2141
+ data: string;
2142
+ driverParam: string;
2143
+ notNull: true;
2144
+ hasDefault: true;
2145
+ isPrimaryKey: true;
2146
+ isAutoincrement: false;
2147
+ hasRuntimeDefault: true;
2148
+ enumValues: [string, ...string[]];
2149
+ baseColumn: never;
2150
+ identity: undefined;
2151
+ generated: undefined;
2152
+ }, {}, {}>;
2153
+ organizationId: import("drizzle-orm/pg-core").PgColumn<{
2154
+ name: "organization_id";
2155
+ tableName: "auth_members";
2156
+ dataType: "string";
2157
+ columnType: "PgText";
2158
+ data: string;
2159
+ driverParam: string;
2160
+ notNull: true;
2161
+ hasDefault: false;
2162
+ isPrimaryKey: false;
2163
+ isAutoincrement: false;
2164
+ hasRuntimeDefault: false;
2165
+ enumValues: [string, ...string[]];
2166
+ baseColumn: never;
2167
+ identity: undefined;
2168
+ generated: undefined;
2169
+ }, {}, {}>;
2170
+ userId: import("drizzle-orm/pg-core").PgColumn<{
2171
+ name: "user_id";
2172
+ tableName: "auth_members";
2173
+ dataType: "string";
2174
+ columnType: "PgText";
2175
+ data: string;
2176
+ driverParam: string;
2177
+ notNull: true;
2178
+ hasDefault: false;
2179
+ isPrimaryKey: false;
2180
+ isAutoincrement: false;
2181
+ hasRuntimeDefault: false;
2182
+ enumValues: [string, ...string[]];
2183
+ baseColumn: never;
2184
+ identity: undefined;
2185
+ generated: undefined;
2186
+ }, {}, {}>;
2187
+ role: import("drizzle-orm/pg-core").PgColumn<{
2188
+ name: "role";
2189
+ tableName: "auth_members";
2190
+ dataType: "string";
2191
+ columnType: "PgText";
2192
+ data: string;
2193
+ driverParam: string;
2194
+ notNull: true;
2195
+ hasDefault: true;
2196
+ isPrimaryKey: false;
2197
+ isAutoincrement: false;
2198
+ hasRuntimeDefault: false;
2199
+ enumValues: [string, ...string[]];
2200
+ baseColumn: never;
2201
+ identity: undefined;
2202
+ generated: undefined;
2203
+ }, {}, {}>;
2204
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2205
+ name: string;
2206
+ tableName: "auth_members";
2207
+ dataType: "date";
2208
+ columnType: "PgTimestamp";
2209
+ data: Date;
2210
+ driverParam: string;
2211
+ notNull: true;
2212
+ hasDefault: true;
2213
+ isPrimaryKey: false;
2214
+ isAutoincrement: false;
2215
+ hasRuntimeDefault: false;
2216
+ enumValues: undefined;
2217
+ baseColumn: never;
2218
+ identity: undefined;
2219
+ generated: undefined;
2220
+ }, {}, {}>;
2221
+ };
2222
+ dialect: "pg";
2223
+ }>;
2224
+ organization: import("drizzle-orm/pg-core").PgTableWithColumns<{
2225
+ name: "auth_organizations";
2226
+ schema: undefined;
2227
+ columns: {
2228
+ id: import("drizzle-orm/pg-core").PgColumn<{
2229
+ name: string;
2230
+ tableName: "auth_organizations";
2231
+ dataType: "string";
2232
+ columnType: "PgText";
2233
+ data: string;
2234
+ driverParam: string;
2235
+ notNull: true;
2236
+ hasDefault: true;
2237
+ isPrimaryKey: true;
2238
+ isAutoincrement: false;
2239
+ hasRuntimeDefault: true;
2240
+ enumValues: [string, ...string[]];
2241
+ baseColumn: never;
2242
+ identity: undefined;
2243
+ generated: undefined;
2244
+ }, {}, {}>;
2245
+ name: import("drizzle-orm/pg-core").PgColumn<{
2246
+ name: "name";
2247
+ tableName: "auth_organizations";
2248
+ dataType: "string";
2249
+ columnType: "PgText";
2250
+ data: string;
2251
+ driverParam: string;
2252
+ notNull: true;
2253
+ hasDefault: false;
2254
+ isPrimaryKey: false;
2255
+ isAutoincrement: false;
2256
+ hasRuntimeDefault: false;
2257
+ enumValues: [string, ...string[]];
2258
+ baseColumn: never;
2259
+ identity: undefined;
2260
+ generated: undefined;
2261
+ }, {}, {}>;
2262
+ slug: import("drizzle-orm/pg-core").PgColumn<{
2263
+ name: "slug";
2264
+ tableName: "auth_organizations";
2265
+ dataType: "string";
2266
+ columnType: "PgText";
2267
+ data: string;
2268
+ driverParam: string;
2269
+ notNull: true;
2270
+ hasDefault: false;
2271
+ isPrimaryKey: false;
2272
+ isAutoincrement: false;
2273
+ hasRuntimeDefault: false;
2274
+ enumValues: [string, ...string[]];
2275
+ baseColumn: never;
2276
+ identity: undefined;
2277
+ generated: undefined;
2278
+ }, {}, {}>;
2279
+ logo: import("drizzle-orm/pg-core").PgColumn<{
2280
+ name: "logo";
2281
+ tableName: "auth_organizations";
2282
+ dataType: "string";
2283
+ columnType: "PgText";
2284
+ data: string;
2285
+ driverParam: string;
2286
+ notNull: false;
2287
+ hasDefault: false;
2288
+ isPrimaryKey: false;
2289
+ isAutoincrement: false;
2290
+ hasRuntimeDefault: false;
2291
+ enumValues: [string, ...string[]];
2292
+ baseColumn: never;
2293
+ identity: undefined;
2294
+ generated: undefined;
2295
+ }, {}, {}>;
2296
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2297
+ name: string;
2298
+ tableName: "auth_organizations";
2299
+ dataType: "date";
2300
+ columnType: "PgTimestamp";
2301
+ data: Date;
2302
+ driverParam: string;
2303
+ notNull: true;
2304
+ hasDefault: true;
2305
+ isPrimaryKey: false;
2306
+ isAutoincrement: false;
2307
+ hasRuntimeDefault: false;
2308
+ enumValues: undefined;
2309
+ baseColumn: never;
2310
+ identity: undefined;
2311
+ generated: undefined;
2312
+ }, {}, {}>;
2313
+ metadata: import("drizzle-orm/pg-core").PgColumn<{
2314
+ name: "metadata";
2315
+ tableName: "auth_organizations";
2316
+ dataType: "string";
2317
+ columnType: "PgText";
2318
+ data: string;
2319
+ driverParam: string;
2320
+ notNull: false;
2321
+ hasDefault: false;
2322
+ isPrimaryKey: false;
2323
+ isAutoincrement: false;
2324
+ hasRuntimeDefault: false;
2325
+ enumValues: [string, ...string[]];
2326
+ baseColumn: never;
2327
+ identity: undefined;
2328
+ generated: undefined;
2329
+ }, {}, {}>;
2330
+ };
2331
+ dialect: "pg";
2332
+ }>;
2333
+ session: import("drizzle-orm/pg-core").PgTableWithColumns<{
2334
+ name: "auth_sessions";
2335
+ schema: undefined;
2336
+ columns: {
2337
+ id: import("drizzle-orm/pg-core").PgColumn<{
2338
+ name: string;
2339
+ tableName: "auth_sessions";
2340
+ dataType: "string";
2341
+ columnType: "PgText";
2342
+ data: string;
2343
+ driverParam: string;
2344
+ notNull: true;
2345
+ hasDefault: true;
2346
+ isPrimaryKey: true;
2347
+ isAutoincrement: false;
2348
+ hasRuntimeDefault: true;
2349
+ enumValues: [string, ...string[]];
2350
+ baseColumn: never;
2351
+ identity: undefined;
2352
+ generated: undefined;
2353
+ }, {}, {}>;
2354
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
2355
+ name: "expires_at";
2356
+ tableName: "auth_sessions";
2357
+ dataType: "date";
2358
+ columnType: "PgTimestamp";
2359
+ data: Date;
2360
+ driverParam: string;
2361
+ notNull: true;
2362
+ hasDefault: false;
2363
+ isPrimaryKey: false;
2364
+ isAutoincrement: false;
2365
+ hasRuntimeDefault: false;
2366
+ enumValues: undefined;
2367
+ baseColumn: never;
2368
+ identity: undefined;
2369
+ generated: undefined;
2370
+ }, {}, {}>;
2371
+ token: import("drizzle-orm/pg-core").PgColumn<{
2372
+ name: "token";
2373
+ tableName: "auth_sessions";
2374
+ dataType: "string";
2375
+ columnType: "PgText";
2376
+ data: string;
2377
+ driverParam: string;
2378
+ notNull: true;
2379
+ hasDefault: false;
2380
+ isPrimaryKey: false;
2381
+ isAutoincrement: false;
2382
+ hasRuntimeDefault: false;
2383
+ enumValues: [string, ...string[]];
2384
+ baseColumn: never;
2385
+ identity: undefined;
2386
+ generated: undefined;
2387
+ }, {}, {}>;
2388
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2389
+ name: string;
2390
+ tableName: "auth_sessions";
2391
+ dataType: "date";
2392
+ columnType: "PgTimestamp";
2393
+ data: Date;
2394
+ driverParam: string;
2395
+ notNull: true;
2396
+ hasDefault: true;
2397
+ isPrimaryKey: false;
2398
+ isAutoincrement: false;
2399
+ hasRuntimeDefault: false;
2400
+ enumValues: undefined;
2401
+ baseColumn: never;
2402
+ identity: undefined;
2403
+ generated: undefined;
2404
+ }, {}, {}>;
2405
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2406
+ name: string;
2407
+ tableName: "auth_sessions";
2408
+ dataType: "date";
2409
+ columnType: "PgTimestamp";
2410
+ data: Date;
2411
+ driverParam: string;
2412
+ notNull: true;
2413
+ hasDefault: true;
2414
+ isPrimaryKey: false;
2415
+ isAutoincrement: false;
2416
+ hasRuntimeDefault: false;
2417
+ enumValues: undefined;
2418
+ baseColumn: never;
2419
+ identity: undefined;
2420
+ generated: undefined;
2421
+ }, {}, {}>;
2422
+ ipAddress: import("drizzle-orm/pg-core").PgColumn<{
2423
+ name: "ip_address";
2424
+ tableName: "auth_sessions";
2425
+ dataType: "string";
2426
+ columnType: "PgText";
2427
+ data: string;
2428
+ driverParam: string;
2429
+ notNull: false;
2430
+ hasDefault: false;
2431
+ isPrimaryKey: false;
2432
+ isAutoincrement: false;
2433
+ hasRuntimeDefault: false;
2434
+ enumValues: [string, ...string[]];
2435
+ baseColumn: never;
2436
+ identity: undefined;
2437
+ generated: undefined;
2438
+ }, {}, {}>;
2439
+ userAgent: import("drizzle-orm/pg-core").PgColumn<{
2440
+ name: "user_agent";
2441
+ tableName: "auth_sessions";
2442
+ dataType: "string";
2443
+ columnType: "PgText";
2444
+ data: string;
2445
+ driverParam: string;
2446
+ notNull: false;
2447
+ hasDefault: false;
2448
+ isPrimaryKey: false;
2449
+ isAutoincrement: false;
2450
+ hasRuntimeDefault: false;
2451
+ enumValues: [string, ...string[]];
2452
+ baseColumn: never;
2453
+ identity: undefined;
2454
+ generated: undefined;
2455
+ }, {}, {}>;
2456
+ userId: import("drizzle-orm/pg-core").PgColumn<{
2457
+ name: "user_id";
2458
+ tableName: "auth_sessions";
2459
+ dataType: "string";
2460
+ columnType: "PgText";
2461
+ data: string;
2462
+ driverParam: string;
2463
+ notNull: true;
2464
+ hasDefault: false;
2465
+ isPrimaryKey: false;
2466
+ isAutoincrement: false;
2467
+ hasRuntimeDefault: false;
2468
+ enumValues: [string, ...string[]];
2469
+ baseColumn: never;
2470
+ identity: undefined;
2471
+ generated: undefined;
2472
+ }, {}, {}>;
2473
+ activeOrganizationId: import("drizzle-orm/pg-core").PgColumn<{
2474
+ name: "active_organization_id";
2475
+ tableName: "auth_sessions";
2476
+ dataType: "string";
2477
+ columnType: "PgText";
2478
+ data: string;
2479
+ driverParam: string;
2480
+ notNull: false;
2481
+ hasDefault: false;
2482
+ isPrimaryKey: false;
2483
+ isAutoincrement: false;
2484
+ hasRuntimeDefault: false;
2485
+ enumValues: [string, ...string[]];
2486
+ baseColumn: never;
2487
+ identity: undefined;
2488
+ generated: undefined;
2489
+ }, {}, {}>;
2490
+ };
2491
+ dialect: "pg";
2492
+ }>;
2493
+ user: import("drizzle-orm/pg-core").PgTableWithColumns<{
2494
+ name: "auth_users";
2495
+ schema: undefined;
2496
+ columns: {
2497
+ id: import("drizzle-orm/pg-core").PgColumn<{
2498
+ name: string;
2499
+ tableName: "auth_users";
2500
+ dataType: "string";
2501
+ columnType: "PgText";
2502
+ data: string;
2503
+ driverParam: string;
2504
+ notNull: true;
2505
+ hasDefault: true;
2506
+ isPrimaryKey: true;
2507
+ isAutoincrement: false;
2508
+ hasRuntimeDefault: true;
2509
+ enumValues: [string, ...string[]];
2510
+ baseColumn: never;
2511
+ identity: undefined;
2512
+ generated: undefined;
2513
+ }, {}, {}>;
2514
+ name: import("drizzle-orm/pg-core").PgColumn<{
2515
+ name: "name";
2516
+ tableName: "auth_users";
2517
+ dataType: "string";
2518
+ columnType: "PgText";
2519
+ data: string;
2520
+ driverParam: string;
2521
+ notNull: true;
2522
+ hasDefault: false;
2523
+ isPrimaryKey: false;
2524
+ isAutoincrement: false;
2525
+ hasRuntimeDefault: false;
2526
+ enumValues: [string, ...string[]];
2527
+ baseColumn: never;
2528
+ identity: undefined;
2529
+ generated: undefined;
2530
+ }, {}, {}>;
2531
+ email: import("drizzle-orm/pg-core").PgColumn<{
2532
+ name: "email";
2533
+ tableName: "auth_users";
2534
+ dataType: "string";
2535
+ columnType: "PgText";
2536
+ data: string;
2537
+ driverParam: string;
2538
+ notNull: true;
2539
+ hasDefault: false;
2540
+ isPrimaryKey: false;
2541
+ isAutoincrement: false;
2542
+ hasRuntimeDefault: false;
2543
+ enumValues: [string, ...string[]];
2544
+ baseColumn: never;
2545
+ identity: undefined;
2546
+ generated: undefined;
2547
+ }, {}, {}>;
2548
+ emailVerified: import("drizzle-orm/pg-core").PgColumn<{
2549
+ name: "email_verified";
2550
+ tableName: "auth_users";
2551
+ dataType: "boolean";
2552
+ columnType: "PgBoolean";
2553
+ data: boolean;
2554
+ driverParam: boolean;
2555
+ notNull: true;
2556
+ hasDefault: true;
2557
+ isPrimaryKey: false;
2558
+ isAutoincrement: false;
2559
+ hasRuntimeDefault: false;
2560
+ enumValues: undefined;
2561
+ baseColumn: never;
2562
+ identity: undefined;
2563
+ generated: undefined;
2564
+ }, {}, {}>;
2565
+ image: import("drizzle-orm/pg-core").PgColumn<{
2566
+ name: "image";
2567
+ tableName: "auth_users";
2568
+ dataType: "string";
2569
+ columnType: "PgText";
2570
+ data: string;
2571
+ driverParam: string;
2572
+ notNull: false;
2573
+ hasDefault: false;
2574
+ isPrimaryKey: false;
2575
+ isAutoincrement: false;
2576
+ hasRuntimeDefault: false;
2577
+ enumValues: [string, ...string[]];
2578
+ baseColumn: never;
2579
+ identity: undefined;
2580
+ generated: undefined;
2581
+ }, {}, {}>;
2582
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2583
+ name: string;
2584
+ tableName: "auth_users";
2585
+ dataType: "date";
2586
+ columnType: "PgTimestamp";
2587
+ data: Date;
2588
+ driverParam: string;
2589
+ notNull: true;
2590
+ hasDefault: true;
2591
+ isPrimaryKey: false;
2592
+ isAutoincrement: false;
2593
+ hasRuntimeDefault: false;
2594
+ enumValues: undefined;
2595
+ baseColumn: never;
2596
+ identity: undefined;
2597
+ generated: undefined;
2598
+ }, {}, {}>;
2599
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2600
+ name: string;
2601
+ tableName: "auth_users";
2602
+ dataType: "date";
2603
+ columnType: "PgTimestamp";
2604
+ data: Date;
2605
+ driverParam: string;
2606
+ notNull: true;
2607
+ hasDefault: true;
2608
+ isPrimaryKey: false;
2609
+ isAutoincrement: false;
2610
+ hasRuntimeDefault: false;
2611
+ enumValues: undefined;
2612
+ baseColumn: never;
2613
+ identity: undefined;
2614
+ generated: undefined;
2615
+ }, {}, {}>;
2616
+ };
2617
+ dialect: "pg";
2618
+ }>;
2619
+ verification: import("drizzle-orm/pg-core").PgTableWithColumns<{
2620
+ name: "auth_verifications";
2621
+ schema: undefined;
2622
+ columns: {
2623
+ id: import("drizzle-orm/pg-core").PgColumn<{
2624
+ name: string;
2625
+ tableName: "auth_verifications";
2626
+ dataType: "string";
2627
+ columnType: "PgText";
2628
+ data: string;
2629
+ driverParam: string;
2630
+ notNull: true;
2631
+ hasDefault: true;
2632
+ isPrimaryKey: true;
2633
+ isAutoincrement: false;
2634
+ hasRuntimeDefault: true;
2635
+ enumValues: [string, ...string[]];
2636
+ baseColumn: never;
2637
+ identity: undefined;
2638
+ generated: undefined;
2639
+ }, {}, {}>;
2640
+ identifier: import("drizzle-orm/pg-core").PgColumn<{
2641
+ name: "identifier";
2642
+ tableName: "auth_verifications";
2643
+ dataType: "string";
2644
+ columnType: "PgText";
2645
+ data: string;
2646
+ driverParam: string;
2647
+ notNull: true;
2648
+ hasDefault: false;
2649
+ isPrimaryKey: false;
2650
+ isAutoincrement: false;
2651
+ hasRuntimeDefault: false;
2652
+ enumValues: [string, ...string[]];
2653
+ baseColumn: never;
2654
+ identity: undefined;
2655
+ generated: undefined;
2656
+ }, {}, {}>;
2657
+ value: import("drizzle-orm/pg-core").PgColumn<{
2658
+ name: "value";
2659
+ tableName: "auth_verifications";
2660
+ dataType: "string";
2661
+ columnType: "PgText";
2662
+ data: string;
2663
+ driverParam: string;
2664
+ notNull: true;
2665
+ hasDefault: false;
2666
+ isPrimaryKey: false;
2667
+ isAutoincrement: false;
2668
+ hasRuntimeDefault: false;
2669
+ enumValues: [string, ...string[]];
2670
+ baseColumn: never;
2671
+ identity: undefined;
2672
+ generated: undefined;
2673
+ }, {}, {}>;
2674
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
2675
+ name: "expires_at";
2676
+ tableName: "auth_verifications";
2677
+ dataType: "date";
2678
+ columnType: "PgTimestamp";
2679
+ data: Date;
2680
+ driverParam: string;
2681
+ notNull: true;
2682
+ hasDefault: false;
2683
+ isPrimaryKey: false;
2684
+ isAutoincrement: false;
2685
+ hasRuntimeDefault: false;
2686
+ enumValues: undefined;
2687
+ baseColumn: never;
2688
+ identity: undefined;
2689
+ generated: undefined;
2690
+ }, {}, {}>;
2691
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2692
+ name: string;
2693
+ tableName: "auth_verifications";
2694
+ dataType: "date";
2695
+ columnType: "PgTimestamp";
2696
+ data: Date;
2697
+ driverParam: string;
2698
+ notNull: true;
2699
+ hasDefault: true;
2700
+ isPrimaryKey: false;
2701
+ isAutoincrement: false;
2702
+ hasRuntimeDefault: false;
2703
+ enumValues: undefined;
2704
+ baseColumn: never;
2705
+ identity: undefined;
2706
+ generated: undefined;
2707
+ }, {}, {}>;
2708
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2709
+ name: string;
2710
+ tableName: "auth_verifications";
2711
+ dataType: "date";
2712
+ columnType: "PgTimestamp";
2713
+ data: Date;
2714
+ driverParam: string;
2715
+ notNull: true;
2716
+ hasDefault: true;
2717
+ isPrimaryKey: false;
2718
+ isAutoincrement: false;
2719
+ hasRuntimeDefault: false;
2720
+ enumValues: undefined;
2721
+ baseColumn: never;
2722
+ identity: undefined;
2723
+ generated: undefined;
2724
+ }, {}, {}>;
2725
+ };
2726
+ dialect: "pg";
2727
+ }>;
2728
+ };
2729
+ };
2730
+ export type { AuthDbSchema } from "./schema";
2731
+ export { authSchema };
2732
+ //# sourceMappingURL=index.d.ts.map