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