@viktorbarzin/auth 0.0.0-stage → 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (26) hide show
  1. package/README.md +63 -2
  2. package/dist/app-auth.d.ts +160 -0
  3. package/dist/app-auth.js +588 -0
  4. package/dist/authentik.d.ts +44 -0
  5. package/dist/authentik.js +115 -0
  6. package/dist/config.d.ts +120 -0
  7. package/dist/config.js +15 -0
  8. package/dist/csrf.d.ts +7 -0
  9. package/dist/csrf.js +45 -0
  10. package/dist/index.d.ts +8 -0
  11. package/dist/index.js +7 -0
  12. package/dist/membership.d.ts +59 -0
  13. package/dist/membership.js +118 -0
  14. package/dist/metrics.d.ts +14 -0
  15. package/dist/metrics.js +19 -0
  16. package/dist/return-path.d.ts +16 -0
  17. package/dist/return-path.js +40 -0
  18. package/dist/schema.d.ts +2367 -0
  19. package/dist/schema.js +110 -0
  20. package/dist/testing/built-server.d.ts +50 -0
  21. package/dist/testing/built-server.js +157 -0
  22. package/dist/testing/index.d.ts +7 -0
  23. package/dist/testing/index.js +7 -0
  24. package/dist/testing/mock-authentik.d.ts +70 -0
  25. package/dist/testing/mock-authentik.js +299 -0
  26. package/package.json +66 -5
package/dist/schema.d.ts ADDED
@@ -0,0 +1,2367 @@
1
+ export declare const authUser: import("drizzle-orm/pg-core").PgTableWithColumns<{
2
+ name: "auth_user";
3
+ schema: undefined;
4
+ columns: {
5
+ id: import("drizzle-orm/pg-core").PgColumn<{
6
+ name: "id";
7
+ tableName: "auth_user";
8
+ dataType: "string";
9
+ columnType: "PgText";
10
+ data: string;
11
+ driverParam: string;
12
+ notNull: true;
13
+ hasDefault: false;
14
+ isPrimaryKey: true;
15
+ isAutoincrement: false;
16
+ hasRuntimeDefault: false;
17
+ enumValues: [string, ...string[]];
18
+ baseColumn: never;
19
+ identity: undefined;
20
+ generated: undefined;
21
+ }, {}, {}>;
22
+ name: import("drizzle-orm/pg-core").PgColumn<{
23
+ name: "name";
24
+ tableName: "auth_user";
25
+ dataType: "string";
26
+ columnType: "PgText";
27
+ data: string;
28
+ driverParam: string;
29
+ notNull: true;
30
+ hasDefault: false;
31
+ isPrimaryKey: false;
32
+ isAutoincrement: false;
33
+ hasRuntimeDefault: false;
34
+ enumValues: [string, ...string[]];
35
+ baseColumn: never;
36
+ identity: undefined;
37
+ generated: undefined;
38
+ }, {}, {}>;
39
+ email: import("drizzle-orm/pg-core").PgColumn<{
40
+ name: "email";
41
+ tableName: "auth_user";
42
+ dataType: "string";
43
+ columnType: "PgText";
44
+ data: string;
45
+ driverParam: string;
46
+ notNull: true;
47
+ hasDefault: false;
48
+ isPrimaryKey: false;
49
+ isAutoincrement: false;
50
+ hasRuntimeDefault: false;
51
+ enumValues: [string, ...string[]];
52
+ baseColumn: never;
53
+ identity: undefined;
54
+ generated: undefined;
55
+ }, {}, {}>;
56
+ emailVerified: import("drizzle-orm/pg-core").PgColumn<{
57
+ name: "email_verified";
58
+ tableName: "auth_user";
59
+ dataType: "boolean";
60
+ columnType: "PgBoolean";
61
+ data: boolean;
62
+ driverParam: boolean;
63
+ notNull: true;
64
+ hasDefault: true;
65
+ isPrimaryKey: false;
66
+ isAutoincrement: false;
67
+ hasRuntimeDefault: false;
68
+ enumValues: undefined;
69
+ baseColumn: never;
70
+ identity: undefined;
71
+ generated: undefined;
72
+ }, {}, {}>;
73
+ image: import("drizzle-orm/pg-core").PgColumn<{
74
+ name: "image";
75
+ tableName: "auth_user";
76
+ dataType: "string";
77
+ columnType: "PgText";
78
+ data: string;
79
+ driverParam: string;
80
+ notNull: false;
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
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
91
+ name: "created_at";
92
+ tableName: "auth_user";
93
+ dataType: "date";
94
+ columnType: "PgTimestamp";
95
+ data: Date;
96
+ driverParam: string;
97
+ notNull: true;
98
+ hasDefault: false;
99
+ isPrimaryKey: false;
100
+ isAutoincrement: false;
101
+ hasRuntimeDefault: false;
102
+ enumValues: undefined;
103
+ baseColumn: never;
104
+ identity: undefined;
105
+ generated: undefined;
106
+ }, {}, {}>;
107
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
108
+ name: "updated_at";
109
+ tableName: "auth_user";
110
+ dataType: "date";
111
+ columnType: "PgTimestamp";
112
+ data: Date;
113
+ driverParam: string;
114
+ notNull: true;
115
+ hasDefault: true;
116
+ isPrimaryKey: false;
117
+ isAutoincrement: false;
118
+ hasRuntimeDefault: false;
119
+ enumValues: undefined;
120
+ baseColumn: never;
121
+ identity: undefined;
122
+ generated: undefined;
123
+ }, {}, {}>;
124
+ };
125
+ dialect: "pg";
126
+ }>;
127
+ export declare const authSession: import("drizzle-orm/pg-core").PgTableWithColumns<{
128
+ name: "auth_session";
129
+ schema: undefined;
130
+ columns: {
131
+ id: import("drizzle-orm/pg-core").PgColumn<{
132
+ name: "id";
133
+ tableName: "auth_session";
134
+ dataType: "string";
135
+ columnType: "PgText";
136
+ data: string;
137
+ driverParam: string;
138
+ notNull: true;
139
+ hasDefault: false;
140
+ isPrimaryKey: true;
141
+ isAutoincrement: false;
142
+ hasRuntimeDefault: false;
143
+ enumValues: [string, ...string[]];
144
+ baseColumn: never;
145
+ identity: undefined;
146
+ generated: undefined;
147
+ }, {}, {}>;
148
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
149
+ name: "expires_at";
150
+ tableName: "auth_session";
151
+ dataType: "date";
152
+ columnType: "PgTimestamp";
153
+ data: Date;
154
+ driverParam: string;
155
+ notNull: true;
156
+ hasDefault: false;
157
+ isPrimaryKey: false;
158
+ isAutoincrement: false;
159
+ hasRuntimeDefault: false;
160
+ enumValues: undefined;
161
+ baseColumn: never;
162
+ identity: undefined;
163
+ generated: undefined;
164
+ }, {}, {}>;
165
+ token: import("drizzle-orm/pg-core").PgColumn<{
166
+ name: "token";
167
+ tableName: "auth_session";
168
+ dataType: "string";
169
+ columnType: "PgText";
170
+ data: string;
171
+ driverParam: string;
172
+ notNull: true;
173
+ hasDefault: false;
174
+ isPrimaryKey: false;
175
+ isAutoincrement: false;
176
+ hasRuntimeDefault: false;
177
+ enumValues: [string, ...string[]];
178
+ baseColumn: never;
179
+ identity: undefined;
180
+ generated: undefined;
181
+ }, {}, {}>;
182
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
183
+ name: "created_at";
184
+ tableName: "auth_session";
185
+ dataType: "date";
186
+ columnType: "PgTimestamp";
187
+ data: Date;
188
+ driverParam: string;
189
+ notNull: true;
190
+ hasDefault: false;
191
+ isPrimaryKey: false;
192
+ isAutoincrement: false;
193
+ hasRuntimeDefault: false;
194
+ enumValues: undefined;
195
+ baseColumn: never;
196
+ identity: undefined;
197
+ generated: undefined;
198
+ }, {}, {}>;
199
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
200
+ name: "updated_at";
201
+ tableName: "auth_session";
202
+ dataType: "date";
203
+ columnType: "PgTimestamp";
204
+ data: Date;
205
+ driverParam: string;
206
+ notNull: true;
207
+ hasDefault: true;
208
+ isPrimaryKey: false;
209
+ isAutoincrement: false;
210
+ hasRuntimeDefault: false;
211
+ enumValues: undefined;
212
+ baseColumn: never;
213
+ identity: undefined;
214
+ generated: undefined;
215
+ }, {}, {}>;
216
+ ipAddress: import("drizzle-orm/pg-core").PgColumn<{
217
+ name: "ip_address";
218
+ tableName: "auth_session";
219
+ dataType: "string";
220
+ columnType: "PgText";
221
+ data: string;
222
+ driverParam: string;
223
+ notNull: false;
224
+ hasDefault: false;
225
+ isPrimaryKey: false;
226
+ isAutoincrement: false;
227
+ hasRuntimeDefault: false;
228
+ enumValues: [string, ...string[]];
229
+ baseColumn: never;
230
+ identity: undefined;
231
+ generated: undefined;
232
+ }, {}, {}>;
233
+ userAgent: import("drizzle-orm/pg-core").PgColumn<{
234
+ name: "user_agent";
235
+ tableName: "auth_session";
236
+ dataType: "string";
237
+ columnType: "PgText";
238
+ data: string;
239
+ driverParam: string;
240
+ notNull: false;
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
+ userId: import("drizzle-orm/pg-core").PgColumn<{
251
+ name: "user_id";
252
+ tableName: "auth_session";
253
+ dataType: "string";
254
+ columnType: "PgText";
255
+ data: string;
256
+ driverParam: string;
257
+ notNull: true;
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
+ };
268
+ dialect: "pg";
269
+ }>;
270
+ export declare const authAccount: import("drizzle-orm/pg-core").PgTableWithColumns<{
271
+ name: "auth_account";
272
+ schema: undefined;
273
+ columns: {
274
+ id: import("drizzle-orm/pg-core").PgColumn<{
275
+ name: "id";
276
+ tableName: "auth_account";
277
+ dataType: "string";
278
+ columnType: "PgText";
279
+ data: string;
280
+ driverParam: string;
281
+ notNull: true;
282
+ hasDefault: false;
283
+ isPrimaryKey: true;
284
+ isAutoincrement: false;
285
+ hasRuntimeDefault: false;
286
+ enumValues: [string, ...string[]];
287
+ baseColumn: never;
288
+ identity: undefined;
289
+ generated: undefined;
290
+ }, {}, {}>;
291
+ accountId: import("drizzle-orm/pg-core").PgColumn<{
292
+ name: "account_id";
293
+ tableName: "auth_account";
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
+ providerId: import("drizzle-orm/pg-core").PgColumn<{
309
+ name: "provider_id";
310
+ tableName: "auth_account";
311
+ dataType: "string";
312
+ columnType: "PgText";
313
+ data: string;
314
+ driverParam: string;
315
+ notNull: true;
316
+ hasDefault: false;
317
+ isPrimaryKey: false;
318
+ isAutoincrement: false;
319
+ hasRuntimeDefault: false;
320
+ enumValues: [string, ...string[]];
321
+ baseColumn: never;
322
+ identity: undefined;
323
+ generated: undefined;
324
+ }, {}, {}>;
325
+ userId: import("drizzle-orm/pg-core").PgColumn<{
326
+ name: "user_id";
327
+ tableName: "auth_account";
328
+ dataType: "string";
329
+ columnType: "PgText";
330
+ data: string;
331
+ driverParam: string;
332
+ notNull: true;
333
+ hasDefault: false;
334
+ isPrimaryKey: false;
335
+ isAutoincrement: false;
336
+ hasRuntimeDefault: false;
337
+ enumValues: [string, ...string[]];
338
+ baseColumn: never;
339
+ identity: undefined;
340
+ generated: undefined;
341
+ }, {}, {}>;
342
+ accessToken: import("drizzle-orm/pg-core").PgColumn<{
343
+ name: "access_token";
344
+ tableName: "auth_account";
345
+ dataType: "string";
346
+ columnType: "PgText";
347
+ data: string;
348
+ driverParam: string;
349
+ notNull: false;
350
+ hasDefault: false;
351
+ isPrimaryKey: false;
352
+ isAutoincrement: false;
353
+ hasRuntimeDefault: false;
354
+ enumValues: [string, ...string[]];
355
+ baseColumn: never;
356
+ identity: undefined;
357
+ generated: undefined;
358
+ }, {}, {}>;
359
+ refreshToken: import("drizzle-orm/pg-core").PgColumn<{
360
+ name: "refresh_token";
361
+ tableName: "auth_account";
362
+ dataType: "string";
363
+ columnType: "PgText";
364
+ data: string;
365
+ driverParam: string;
366
+ notNull: false;
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
+ idToken: import("drizzle-orm/pg-core").PgColumn<{
377
+ name: "id_token";
378
+ tableName: "auth_account";
379
+ dataType: "string";
380
+ columnType: "PgText";
381
+ data: string;
382
+ driverParam: string;
383
+ notNull: false;
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
+ accessTokenExpiresAt: import("drizzle-orm/pg-core").PgColumn<{
394
+ name: "access_token_expires_at";
395
+ tableName: "auth_account";
396
+ dataType: "date";
397
+ columnType: "PgTimestamp";
398
+ data: Date;
399
+ driverParam: string;
400
+ notNull: false;
401
+ hasDefault: false;
402
+ isPrimaryKey: false;
403
+ isAutoincrement: false;
404
+ hasRuntimeDefault: false;
405
+ enumValues: undefined;
406
+ baseColumn: never;
407
+ identity: undefined;
408
+ generated: undefined;
409
+ }, {}, {}>;
410
+ refreshTokenExpiresAt: import("drizzle-orm/pg-core").PgColumn<{
411
+ name: "refresh_token_expires_at";
412
+ tableName: "auth_account";
413
+ dataType: "date";
414
+ columnType: "PgTimestamp";
415
+ data: Date;
416
+ driverParam: string;
417
+ notNull: false;
418
+ hasDefault: false;
419
+ isPrimaryKey: false;
420
+ isAutoincrement: false;
421
+ hasRuntimeDefault: false;
422
+ enumValues: undefined;
423
+ baseColumn: never;
424
+ identity: undefined;
425
+ generated: undefined;
426
+ }, {}, {}>;
427
+ scope: import("drizzle-orm/pg-core").PgColumn<{
428
+ name: "scope";
429
+ tableName: "auth_account";
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
+ password: import("drizzle-orm/pg-core").PgColumn<{
445
+ name: "password";
446
+ tableName: "auth_account";
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
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
462
+ name: "created_at";
463
+ tableName: "auth_account";
464
+ dataType: "date";
465
+ columnType: "PgTimestamp";
466
+ data: Date;
467
+ driverParam: string;
468
+ notNull: true;
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
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
479
+ name: "updated_at";
480
+ tableName: "auth_account";
481
+ dataType: "date";
482
+ columnType: "PgTimestamp";
483
+ data: Date;
484
+ driverParam: string;
485
+ notNull: true;
486
+ hasDefault: true;
487
+ isPrimaryKey: false;
488
+ isAutoincrement: false;
489
+ hasRuntimeDefault: false;
490
+ enumValues: undefined;
491
+ baseColumn: never;
492
+ identity: undefined;
493
+ generated: undefined;
494
+ }, {}, {}>;
495
+ };
496
+ dialect: "pg";
497
+ }>;
498
+ export declare const authVerification: import("drizzle-orm/pg-core").PgTableWithColumns<{
499
+ name: "auth_verification";
500
+ schema: undefined;
501
+ columns: {
502
+ id: import("drizzle-orm/pg-core").PgColumn<{
503
+ name: "id";
504
+ tableName: "auth_verification";
505
+ dataType: "string";
506
+ columnType: "PgText";
507
+ data: string;
508
+ driverParam: string;
509
+ notNull: true;
510
+ hasDefault: false;
511
+ isPrimaryKey: true;
512
+ isAutoincrement: false;
513
+ hasRuntimeDefault: false;
514
+ enumValues: [string, ...string[]];
515
+ baseColumn: never;
516
+ identity: undefined;
517
+ generated: undefined;
518
+ }, {}, {}>;
519
+ identifier: import("drizzle-orm/pg-core").PgColumn<{
520
+ name: "identifier";
521
+ tableName: "auth_verification";
522
+ dataType: "string";
523
+ columnType: "PgText";
524
+ data: string;
525
+ driverParam: string;
526
+ notNull: true;
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
+ value: import("drizzle-orm/pg-core").PgColumn<{
537
+ name: "value";
538
+ tableName: "auth_verification";
539
+ dataType: "string";
540
+ columnType: "PgText";
541
+ data: string;
542
+ driverParam: string;
543
+ notNull: true;
544
+ hasDefault: false;
545
+ isPrimaryKey: false;
546
+ isAutoincrement: false;
547
+ hasRuntimeDefault: false;
548
+ enumValues: [string, ...string[]];
549
+ baseColumn: never;
550
+ identity: undefined;
551
+ generated: undefined;
552
+ }, {}, {}>;
553
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
554
+ name: "expires_at";
555
+ tableName: "auth_verification";
556
+ dataType: "date";
557
+ columnType: "PgTimestamp";
558
+ data: Date;
559
+ driverParam: string;
560
+ notNull: true;
561
+ hasDefault: false;
562
+ isPrimaryKey: false;
563
+ isAutoincrement: false;
564
+ hasRuntimeDefault: false;
565
+ enumValues: undefined;
566
+ baseColumn: never;
567
+ identity: undefined;
568
+ generated: undefined;
569
+ }, {}, {}>;
570
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
571
+ name: "created_at";
572
+ tableName: "auth_verification";
573
+ dataType: "date";
574
+ columnType: "PgTimestamp";
575
+ data: Date;
576
+ driverParam: string;
577
+ notNull: true;
578
+ hasDefault: false;
579
+ isPrimaryKey: false;
580
+ isAutoincrement: false;
581
+ hasRuntimeDefault: false;
582
+ enumValues: undefined;
583
+ baseColumn: never;
584
+ identity: undefined;
585
+ generated: undefined;
586
+ }, {}, {}>;
587
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
588
+ name: "updated_at";
589
+ tableName: "auth_verification";
590
+ dataType: "date";
591
+ columnType: "PgTimestamp";
592
+ data: Date;
593
+ driverParam: string;
594
+ notNull: true;
595
+ hasDefault: true;
596
+ isPrimaryKey: false;
597
+ isAutoincrement: false;
598
+ hasRuntimeDefault: false;
599
+ enumValues: undefined;
600
+ baseColumn: never;
601
+ identity: undefined;
602
+ generated: undefined;
603
+ }, {}, {}>;
604
+ };
605
+ dialect: "pg";
606
+ }>;
607
+ /** The last membership answer for a subject, from the id_token, a bearer token or the provider's API. */
608
+ export declare const memberChecks: import("drizzle-orm/pg-core").PgTableWithColumns<{
609
+ name: "member_checks";
610
+ schema: undefined;
611
+ columns: {
612
+ sub: import("drizzle-orm/pg-core").PgColumn<{
613
+ name: "sub";
614
+ tableName: "member_checks";
615
+ dataType: "string";
616
+ columnType: "PgVarchar";
617
+ data: string;
618
+ driverParam: string;
619
+ notNull: true;
620
+ hasDefault: false;
621
+ isPrimaryKey: true;
622
+ isAutoincrement: false;
623
+ hasRuntimeDefault: false;
624
+ enumValues: [string, ...string[]];
625
+ baseColumn: never;
626
+ identity: undefined;
627
+ generated: undefined;
628
+ }, {}, {
629
+ length: 255;
630
+ }>;
631
+ username: import("drizzle-orm/pg-core").PgColumn<{
632
+ name: "username";
633
+ tableName: "member_checks";
634
+ dataType: "string";
635
+ columnType: "PgVarchar";
636
+ data: string;
637
+ driverParam: string;
638
+ notNull: true;
639
+ hasDefault: false;
640
+ isPrimaryKey: false;
641
+ isAutoincrement: false;
642
+ hasRuntimeDefault: false;
643
+ enumValues: [string, ...string[]];
644
+ baseColumn: never;
645
+ identity: undefined;
646
+ generated: undefined;
647
+ }, {}, {
648
+ length: 255;
649
+ }>;
650
+ member: import("drizzle-orm/pg-core").PgColumn<{
651
+ name: "member";
652
+ tableName: "member_checks";
653
+ dataType: "boolean";
654
+ columnType: "PgBoolean";
655
+ data: boolean;
656
+ driverParam: boolean;
657
+ notNull: true;
658
+ hasDefault: false;
659
+ isPrimaryKey: false;
660
+ isAutoincrement: false;
661
+ hasRuntimeDefault: false;
662
+ enumValues: undefined;
663
+ baseColumn: never;
664
+ identity: undefined;
665
+ generated: undefined;
666
+ }, {}, {}>;
667
+ admin: import("drizzle-orm/pg-core").PgColumn<{
668
+ name: "admin";
669
+ tableName: "member_checks";
670
+ dataType: "boolean";
671
+ columnType: "PgBoolean";
672
+ data: boolean;
673
+ driverParam: boolean;
674
+ notNull: true;
675
+ hasDefault: false;
676
+ isPrimaryKey: false;
677
+ isAutoincrement: false;
678
+ hasRuntimeDefault: false;
679
+ enumValues: undefined;
680
+ baseColumn: never;
681
+ identity: undefined;
682
+ generated: undefined;
683
+ }, {}, {}>;
684
+ source: import("drizzle-orm/pg-core").PgColumn<{
685
+ name: "source";
686
+ tableName: "member_checks";
687
+ dataType: "string";
688
+ columnType: "PgVarchar";
689
+ data: string;
690
+ driverParam: string;
691
+ notNull: true;
692
+ hasDefault: false;
693
+ isPrimaryKey: false;
694
+ isAutoincrement: false;
695
+ hasRuntimeDefault: false;
696
+ enumValues: [string, ...string[]];
697
+ baseColumn: never;
698
+ identity: undefined;
699
+ generated: undefined;
700
+ }, {}, {
701
+ length: 16;
702
+ }>;
703
+ checkedAt: import("drizzle-orm/pg-core").PgColumn<{
704
+ name: "checked_at";
705
+ tableName: "member_checks";
706
+ dataType: "date";
707
+ columnType: "PgTimestamp";
708
+ data: Date;
709
+ driverParam: string;
710
+ notNull: true;
711
+ hasDefault: false;
712
+ isPrimaryKey: false;
713
+ isAutoincrement: false;
714
+ hasRuntimeDefault: false;
715
+ enumValues: undefined;
716
+ baseColumn: never;
717
+ identity: undefined;
718
+ generated: undefined;
719
+ }, {}, {}>;
720
+ };
721
+ dialect: "pg";
722
+ }>;
723
+ /** A signed-in person who is not in the app's users group yet. */
724
+ export declare const accessRequests: import("drizzle-orm/pg-core").PgTableWithColumns<{
725
+ name: "access_requests";
726
+ schema: undefined;
727
+ columns: {
728
+ sub: import("drizzle-orm/pg-core").PgColumn<{
729
+ name: "sub";
730
+ tableName: "access_requests";
731
+ dataType: "string";
732
+ columnType: "PgVarchar";
733
+ data: string;
734
+ driverParam: string;
735
+ notNull: true;
736
+ hasDefault: false;
737
+ isPrimaryKey: true;
738
+ isAutoincrement: false;
739
+ hasRuntimeDefault: false;
740
+ enumValues: [string, ...string[]];
741
+ baseColumn: never;
742
+ identity: undefined;
743
+ generated: undefined;
744
+ }, {}, {
745
+ length: 255;
746
+ }>;
747
+ username: import("drizzle-orm/pg-core").PgColumn<{
748
+ name: "username";
749
+ tableName: "access_requests";
750
+ dataType: "string";
751
+ columnType: "PgVarchar";
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
+ length: 255;
765
+ }>;
766
+ email: import("drizzle-orm/pg-core").PgColumn<{
767
+ name: "email";
768
+ tableName: "access_requests";
769
+ dataType: "string";
770
+ columnType: "PgVarchar";
771
+ data: string;
772
+ driverParam: string;
773
+ notNull: false;
774
+ hasDefault: false;
775
+ isPrimaryKey: false;
776
+ isAutoincrement: false;
777
+ hasRuntimeDefault: false;
778
+ enumValues: [string, ...string[]];
779
+ baseColumn: never;
780
+ identity: undefined;
781
+ generated: undefined;
782
+ }, {}, {
783
+ length: 320;
784
+ }>;
785
+ name: import("drizzle-orm/pg-core").PgColumn<{
786
+ name: "name";
787
+ tableName: "access_requests";
788
+ dataType: "string";
789
+ columnType: "PgVarchar";
790
+ data: string;
791
+ driverParam: string;
792
+ notNull: false;
793
+ hasDefault: false;
794
+ isPrimaryKey: false;
795
+ isAutoincrement: false;
796
+ hasRuntimeDefault: false;
797
+ enumValues: [string, ...string[]];
798
+ baseColumn: never;
799
+ identity: undefined;
800
+ generated: undefined;
801
+ }, {}, {
802
+ length: 255;
803
+ }>;
804
+ status: import("drizzle-orm/pg-core").PgColumn<{
805
+ name: "status";
806
+ tableName: "access_requests";
807
+ dataType: "string";
808
+ columnType: "PgVarchar";
809
+ data: string;
810
+ driverParam: string;
811
+ notNull: true;
812
+ hasDefault: false;
813
+ isPrimaryKey: false;
814
+ isAutoincrement: false;
815
+ hasRuntimeDefault: false;
816
+ enumValues: [string, ...string[]];
817
+ baseColumn: never;
818
+ identity: undefined;
819
+ generated: undefined;
820
+ }, {}, {
821
+ length: 16;
822
+ }>;
823
+ requestedAt: import("drizzle-orm/pg-core").PgColumn<{
824
+ name: "requested_at";
825
+ tableName: "access_requests";
826
+ dataType: "date";
827
+ columnType: "PgTimestamp";
828
+ data: Date;
829
+ driverParam: string;
830
+ notNull: true;
831
+ hasDefault: true;
832
+ isPrimaryKey: false;
833
+ isAutoincrement: false;
834
+ hasRuntimeDefault: false;
835
+ enumValues: undefined;
836
+ baseColumn: never;
837
+ identity: undefined;
838
+ generated: undefined;
839
+ }, {}, {}>;
840
+ decidedBy: import("drizzle-orm/pg-core").PgColumn<{
841
+ name: "decided_by";
842
+ tableName: "access_requests";
843
+ dataType: "string";
844
+ columnType: "PgVarchar";
845
+ data: string;
846
+ driverParam: string;
847
+ notNull: false;
848
+ hasDefault: false;
849
+ isPrimaryKey: false;
850
+ isAutoincrement: false;
851
+ hasRuntimeDefault: false;
852
+ enumValues: [string, ...string[]];
853
+ baseColumn: never;
854
+ identity: undefined;
855
+ generated: undefined;
856
+ }, {}, {
857
+ length: 255;
858
+ }>;
859
+ decidedAt: import("drizzle-orm/pg-core").PgColumn<{
860
+ name: "decided_at";
861
+ tableName: "access_requests";
862
+ dataType: "date";
863
+ columnType: "PgTimestamp";
864
+ data: Date;
865
+ driverParam: string;
866
+ notNull: false;
867
+ hasDefault: false;
868
+ isPrimaryKey: false;
869
+ isAutoincrement: false;
870
+ hasRuntimeDefault: false;
871
+ enumValues: undefined;
872
+ baseColumn: never;
873
+ identity: undefined;
874
+ generated: undefined;
875
+ }, {}, {}>;
876
+ };
877
+ dialect: "pg";
878
+ }>;
879
+ export declare const authSchema: {
880
+ authUser: import("drizzle-orm/pg-core").PgTableWithColumns<{
881
+ name: "auth_user";
882
+ schema: undefined;
883
+ columns: {
884
+ id: import("drizzle-orm/pg-core").PgColumn<{
885
+ name: "id";
886
+ tableName: "auth_user";
887
+ dataType: "string";
888
+ columnType: "PgText";
889
+ data: string;
890
+ driverParam: string;
891
+ notNull: true;
892
+ hasDefault: false;
893
+ isPrimaryKey: true;
894
+ isAutoincrement: false;
895
+ hasRuntimeDefault: false;
896
+ enumValues: [string, ...string[]];
897
+ baseColumn: never;
898
+ identity: undefined;
899
+ generated: undefined;
900
+ }, {}, {}>;
901
+ name: import("drizzle-orm/pg-core").PgColumn<{
902
+ name: "name";
903
+ tableName: "auth_user";
904
+ dataType: "string";
905
+ columnType: "PgText";
906
+ data: string;
907
+ driverParam: string;
908
+ notNull: true;
909
+ hasDefault: false;
910
+ isPrimaryKey: false;
911
+ isAutoincrement: false;
912
+ hasRuntimeDefault: false;
913
+ enumValues: [string, ...string[]];
914
+ baseColumn: never;
915
+ identity: undefined;
916
+ generated: undefined;
917
+ }, {}, {}>;
918
+ email: import("drizzle-orm/pg-core").PgColumn<{
919
+ name: "email";
920
+ tableName: "auth_user";
921
+ dataType: "string";
922
+ columnType: "PgText";
923
+ data: string;
924
+ driverParam: string;
925
+ notNull: true;
926
+ hasDefault: false;
927
+ isPrimaryKey: false;
928
+ isAutoincrement: false;
929
+ hasRuntimeDefault: false;
930
+ enumValues: [string, ...string[]];
931
+ baseColumn: never;
932
+ identity: undefined;
933
+ generated: undefined;
934
+ }, {}, {}>;
935
+ emailVerified: import("drizzle-orm/pg-core").PgColumn<{
936
+ name: "email_verified";
937
+ tableName: "auth_user";
938
+ dataType: "boolean";
939
+ columnType: "PgBoolean";
940
+ data: boolean;
941
+ driverParam: boolean;
942
+ notNull: true;
943
+ hasDefault: true;
944
+ isPrimaryKey: false;
945
+ isAutoincrement: false;
946
+ hasRuntimeDefault: false;
947
+ enumValues: undefined;
948
+ baseColumn: never;
949
+ identity: undefined;
950
+ generated: undefined;
951
+ }, {}, {}>;
952
+ image: import("drizzle-orm/pg-core").PgColumn<{
953
+ name: "image";
954
+ tableName: "auth_user";
955
+ dataType: "string";
956
+ columnType: "PgText";
957
+ data: string;
958
+ driverParam: string;
959
+ notNull: false;
960
+ hasDefault: false;
961
+ isPrimaryKey: false;
962
+ isAutoincrement: false;
963
+ hasRuntimeDefault: false;
964
+ enumValues: [string, ...string[]];
965
+ baseColumn: never;
966
+ identity: undefined;
967
+ generated: undefined;
968
+ }, {}, {}>;
969
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
970
+ name: "created_at";
971
+ tableName: "auth_user";
972
+ dataType: "date";
973
+ columnType: "PgTimestamp";
974
+ data: Date;
975
+ driverParam: string;
976
+ notNull: true;
977
+ hasDefault: false;
978
+ isPrimaryKey: false;
979
+ isAutoincrement: false;
980
+ hasRuntimeDefault: false;
981
+ enumValues: undefined;
982
+ baseColumn: never;
983
+ identity: undefined;
984
+ generated: undefined;
985
+ }, {}, {}>;
986
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
987
+ name: "updated_at";
988
+ tableName: "auth_user";
989
+ dataType: "date";
990
+ columnType: "PgTimestamp";
991
+ data: Date;
992
+ driverParam: string;
993
+ notNull: true;
994
+ hasDefault: true;
995
+ isPrimaryKey: false;
996
+ isAutoincrement: false;
997
+ hasRuntimeDefault: false;
998
+ enumValues: undefined;
999
+ baseColumn: never;
1000
+ identity: undefined;
1001
+ generated: undefined;
1002
+ }, {}, {}>;
1003
+ };
1004
+ dialect: "pg";
1005
+ }>;
1006
+ authSession: import("drizzle-orm/pg-core").PgTableWithColumns<{
1007
+ name: "auth_session";
1008
+ schema: undefined;
1009
+ columns: {
1010
+ id: import("drizzle-orm/pg-core").PgColumn<{
1011
+ name: "id";
1012
+ tableName: "auth_session";
1013
+ dataType: "string";
1014
+ columnType: "PgText";
1015
+ data: string;
1016
+ driverParam: string;
1017
+ notNull: true;
1018
+ hasDefault: false;
1019
+ isPrimaryKey: true;
1020
+ isAutoincrement: false;
1021
+ hasRuntimeDefault: false;
1022
+ enumValues: [string, ...string[]];
1023
+ baseColumn: never;
1024
+ identity: undefined;
1025
+ generated: undefined;
1026
+ }, {}, {}>;
1027
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
1028
+ name: "expires_at";
1029
+ tableName: "auth_session";
1030
+ dataType: "date";
1031
+ columnType: "PgTimestamp";
1032
+ data: Date;
1033
+ driverParam: string;
1034
+ notNull: true;
1035
+ hasDefault: false;
1036
+ isPrimaryKey: false;
1037
+ isAutoincrement: false;
1038
+ hasRuntimeDefault: false;
1039
+ enumValues: undefined;
1040
+ baseColumn: never;
1041
+ identity: undefined;
1042
+ generated: undefined;
1043
+ }, {}, {}>;
1044
+ token: import("drizzle-orm/pg-core").PgColumn<{
1045
+ name: "token";
1046
+ tableName: "auth_session";
1047
+ dataType: "string";
1048
+ columnType: "PgText";
1049
+ data: string;
1050
+ driverParam: string;
1051
+ notNull: true;
1052
+ hasDefault: false;
1053
+ isPrimaryKey: false;
1054
+ isAutoincrement: false;
1055
+ hasRuntimeDefault: false;
1056
+ enumValues: [string, ...string[]];
1057
+ baseColumn: never;
1058
+ identity: undefined;
1059
+ generated: undefined;
1060
+ }, {}, {}>;
1061
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1062
+ name: "created_at";
1063
+ tableName: "auth_session";
1064
+ dataType: "date";
1065
+ columnType: "PgTimestamp";
1066
+ data: Date;
1067
+ driverParam: string;
1068
+ notNull: true;
1069
+ hasDefault: false;
1070
+ isPrimaryKey: false;
1071
+ isAutoincrement: false;
1072
+ hasRuntimeDefault: false;
1073
+ enumValues: undefined;
1074
+ baseColumn: never;
1075
+ identity: undefined;
1076
+ generated: undefined;
1077
+ }, {}, {}>;
1078
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1079
+ name: "updated_at";
1080
+ tableName: "auth_session";
1081
+ dataType: "date";
1082
+ columnType: "PgTimestamp";
1083
+ data: Date;
1084
+ driverParam: string;
1085
+ notNull: true;
1086
+ hasDefault: true;
1087
+ isPrimaryKey: false;
1088
+ isAutoincrement: false;
1089
+ hasRuntimeDefault: false;
1090
+ enumValues: undefined;
1091
+ baseColumn: never;
1092
+ identity: undefined;
1093
+ generated: undefined;
1094
+ }, {}, {}>;
1095
+ ipAddress: import("drizzle-orm/pg-core").PgColumn<{
1096
+ name: "ip_address";
1097
+ tableName: "auth_session";
1098
+ dataType: "string";
1099
+ columnType: "PgText";
1100
+ data: string;
1101
+ driverParam: string;
1102
+ notNull: false;
1103
+ hasDefault: false;
1104
+ isPrimaryKey: false;
1105
+ isAutoincrement: false;
1106
+ hasRuntimeDefault: false;
1107
+ enumValues: [string, ...string[]];
1108
+ baseColumn: never;
1109
+ identity: undefined;
1110
+ generated: undefined;
1111
+ }, {}, {}>;
1112
+ userAgent: import("drizzle-orm/pg-core").PgColumn<{
1113
+ name: "user_agent";
1114
+ tableName: "auth_session";
1115
+ dataType: "string";
1116
+ columnType: "PgText";
1117
+ data: string;
1118
+ driverParam: string;
1119
+ notNull: false;
1120
+ hasDefault: false;
1121
+ isPrimaryKey: false;
1122
+ isAutoincrement: false;
1123
+ hasRuntimeDefault: false;
1124
+ enumValues: [string, ...string[]];
1125
+ baseColumn: never;
1126
+ identity: undefined;
1127
+ generated: undefined;
1128
+ }, {}, {}>;
1129
+ userId: import("drizzle-orm/pg-core").PgColumn<{
1130
+ name: "user_id";
1131
+ tableName: "auth_session";
1132
+ dataType: "string";
1133
+ columnType: "PgText";
1134
+ data: string;
1135
+ driverParam: string;
1136
+ notNull: true;
1137
+ hasDefault: false;
1138
+ isPrimaryKey: false;
1139
+ isAutoincrement: false;
1140
+ hasRuntimeDefault: false;
1141
+ enumValues: [string, ...string[]];
1142
+ baseColumn: never;
1143
+ identity: undefined;
1144
+ generated: undefined;
1145
+ }, {}, {}>;
1146
+ };
1147
+ dialect: "pg";
1148
+ }>;
1149
+ authAccount: import("drizzle-orm/pg-core").PgTableWithColumns<{
1150
+ name: "auth_account";
1151
+ schema: undefined;
1152
+ columns: {
1153
+ id: import("drizzle-orm/pg-core").PgColumn<{
1154
+ name: "id";
1155
+ tableName: "auth_account";
1156
+ dataType: "string";
1157
+ columnType: "PgText";
1158
+ data: string;
1159
+ driverParam: string;
1160
+ notNull: true;
1161
+ hasDefault: false;
1162
+ isPrimaryKey: true;
1163
+ isAutoincrement: false;
1164
+ hasRuntimeDefault: false;
1165
+ enumValues: [string, ...string[]];
1166
+ baseColumn: never;
1167
+ identity: undefined;
1168
+ generated: undefined;
1169
+ }, {}, {}>;
1170
+ accountId: import("drizzle-orm/pg-core").PgColumn<{
1171
+ name: "account_id";
1172
+ tableName: "auth_account";
1173
+ dataType: "string";
1174
+ columnType: "PgText";
1175
+ data: string;
1176
+ driverParam: string;
1177
+ notNull: true;
1178
+ hasDefault: false;
1179
+ isPrimaryKey: false;
1180
+ isAutoincrement: false;
1181
+ hasRuntimeDefault: false;
1182
+ enumValues: [string, ...string[]];
1183
+ baseColumn: never;
1184
+ identity: undefined;
1185
+ generated: undefined;
1186
+ }, {}, {}>;
1187
+ providerId: import("drizzle-orm/pg-core").PgColumn<{
1188
+ name: "provider_id";
1189
+ tableName: "auth_account";
1190
+ dataType: "string";
1191
+ columnType: "PgText";
1192
+ data: string;
1193
+ driverParam: string;
1194
+ notNull: true;
1195
+ hasDefault: false;
1196
+ isPrimaryKey: false;
1197
+ isAutoincrement: false;
1198
+ hasRuntimeDefault: false;
1199
+ enumValues: [string, ...string[]];
1200
+ baseColumn: never;
1201
+ identity: undefined;
1202
+ generated: undefined;
1203
+ }, {}, {}>;
1204
+ userId: import("drizzle-orm/pg-core").PgColumn<{
1205
+ name: "user_id";
1206
+ tableName: "auth_account";
1207
+ dataType: "string";
1208
+ columnType: "PgText";
1209
+ data: string;
1210
+ driverParam: string;
1211
+ notNull: true;
1212
+ hasDefault: false;
1213
+ isPrimaryKey: false;
1214
+ isAutoincrement: false;
1215
+ hasRuntimeDefault: false;
1216
+ enumValues: [string, ...string[]];
1217
+ baseColumn: never;
1218
+ identity: undefined;
1219
+ generated: undefined;
1220
+ }, {}, {}>;
1221
+ accessToken: import("drizzle-orm/pg-core").PgColumn<{
1222
+ name: "access_token";
1223
+ tableName: "auth_account";
1224
+ dataType: "string";
1225
+ columnType: "PgText";
1226
+ data: string;
1227
+ driverParam: string;
1228
+ notNull: false;
1229
+ hasDefault: false;
1230
+ isPrimaryKey: false;
1231
+ isAutoincrement: false;
1232
+ hasRuntimeDefault: false;
1233
+ enumValues: [string, ...string[]];
1234
+ baseColumn: never;
1235
+ identity: undefined;
1236
+ generated: undefined;
1237
+ }, {}, {}>;
1238
+ refreshToken: import("drizzle-orm/pg-core").PgColumn<{
1239
+ name: "refresh_token";
1240
+ tableName: "auth_account";
1241
+ dataType: "string";
1242
+ columnType: "PgText";
1243
+ data: string;
1244
+ driverParam: string;
1245
+ notNull: false;
1246
+ hasDefault: false;
1247
+ isPrimaryKey: false;
1248
+ isAutoincrement: false;
1249
+ hasRuntimeDefault: false;
1250
+ enumValues: [string, ...string[]];
1251
+ baseColumn: never;
1252
+ identity: undefined;
1253
+ generated: undefined;
1254
+ }, {}, {}>;
1255
+ idToken: import("drizzle-orm/pg-core").PgColumn<{
1256
+ name: "id_token";
1257
+ tableName: "auth_account";
1258
+ dataType: "string";
1259
+ columnType: "PgText";
1260
+ data: string;
1261
+ driverParam: string;
1262
+ notNull: false;
1263
+ hasDefault: false;
1264
+ isPrimaryKey: false;
1265
+ isAutoincrement: false;
1266
+ hasRuntimeDefault: false;
1267
+ enumValues: [string, ...string[]];
1268
+ baseColumn: never;
1269
+ identity: undefined;
1270
+ generated: undefined;
1271
+ }, {}, {}>;
1272
+ accessTokenExpiresAt: import("drizzle-orm/pg-core").PgColumn<{
1273
+ name: "access_token_expires_at";
1274
+ tableName: "auth_account";
1275
+ dataType: "date";
1276
+ columnType: "PgTimestamp";
1277
+ data: Date;
1278
+ driverParam: string;
1279
+ notNull: false;
1280
+ hasDefault: false;
1281
+ isPrimaryKey: false;
1282
+ isAutoincrement: false;
1283
+ hasRuntimeDefault: false;
1284
+ enumValues: undefined;
1285
+ baseColumn: never;
1286
+ identity: undefined;
1287
+ generated: undefined;
1288
+ }, {}, {}>;
1289
+ refreshTokenExpiresAt: import("drizzle-orm/pg-core").PgColumn<{
1290
+ name: "refresh_token_expires_at";
1291
+ tableName: "auth_account";
1292
+ dataType: "date";
1293
+ columnType: "PgTimestamp";
1294
+ data: Date;
1295
+ driverParam: string;
1296
+ notNull: false;
1297
+ hasDefault: false;
1298
+ isPrimaryKey: false;
1299
+ isAutoincrement: false;
1300
+ hasRuntimeDefault: false;
1301
+ enumValues: undefined;
1302
+ baseColumn: never;
1303
+ identity: undefined;
1304
+ generated: undefined;
1305
+ }, {}, {}>;
1306
+ scope: import("drizzle-orm/pg-core").PgColumn<{
1307
+ name: "scope";
1308
+ tableName: "auth_account";
1309
+ dataType: "string";
1310
+ columnType: "PgText";
1311
+ data: string;
1312
+ driverParam: string;
1313
+ notNull: false;
1314
+ hasDefault: false;
1315
+ isPrimaryKey: false;
1316
+ isAutoincrement: false;
1317
+ hasRuntimeDefault: false;
1318
+ enumValues: [string, ...string[]];
1319
+ baseColumn: never;
1320
+ identity: undefined;
1321
+ generated: undefined;
1322
+ }, {}, {}>;
1323
+ password: import("drizzle-orm/pg-core").PgColumn<{
1324
+ name: "password";
1325
+ tableName: "auth_account";
1326
+ dataType: "string";
1327
+ columnType: "PgText";
1328
+ data: string;
1329
+ driverParam: string;
1330
+ notNull: false;
1331
+ hasDefault: false;
1332
+ isPrimaryKey: false;
1333
+ isAutoincrement: false;
1334
+ hasRuntimeDefault: false;
1335
+ enumValues: [string, ...string[]];
1336
+ baseColumn: never;
1337
+ identity: undefined;
1338
+ generated: undefined;
1339
+ }, {}, {}>;
1340
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1341
+ name: "created_at";
1342
+ tableName: "auth_account";
1343
+ dataType: "date";
1344
+ columnType: "PgTimestamp";
1345
+ data: Date;
1346
+ driverParam: string;
1347
+ notNull: true;
1348
+ hasDefault: false;
1349
+ isPrimaryKey: false;
1350
+ isAutoincrement: false;
1351
+ hasRuntimeDefault: false;
1352
+ enumValues: undefined;
1353
+ baseColumn: never;
1354
+ identity: undefined;
1355
+ generated: undefined;
1356
+ }, {}, {}>;
1357
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1358
+ name: "updated_at";
1359
+ tableName: "auth_account";
1360
+ dataType: "date";
1361
+ columnType: "PgTimestamp";
1362
+ data: Date;
1363
+ driverParam: string;
1364
+ notNull: true;
1365
+ hasDefault: true;
1366
+ isPrimaryKey: false;
1367
+ isAutoincrement: false;
1368
+ hasRuntimeDefault: false;
1369
+ enumValues: undefined;
1370
+ baseColumn: never;
1371
+ identity: undefined;
1372
+ generated: undefined;
1373
+ }, {}, {}>;
1374
+ };
1375
+ dialect: "pg";
1376
+ }>;
1377
+ authVerification: import("drizzle-orm/pg-core").PgTableWithColumns<{
1378
+ name: "auth_verification";
1379
+ schema: undefined;
1380
+ columns: {
1381
+ id: import("drizzle-orm/pg-core").PgColumn<{
1382
+ name: "id";
1383
+ tableName: "auth_verification";
1384
+ dataType: "string";
1385
+ columnType: "PgText";
1386
+ data: string;
1387
+ driverParam: string;
1388
+ notNull: true;
1389
+ hasDefault: false;
1390
+ isPrimaryKey: true;
1391
+ isAutoincrement: false;
1392
+ hasRuntimeDefault: false;
1393
+ enumValues: [string, ...string[]];
1394
+ baseColumn: never;
1395
+ identity: undefined;
1396
+ generated: undefined;
1397
+ }, {}, {}>;
1398
+ identifier: import("drizzle-orm/pg-core").PgColumn<{
1399
+ name: "identifier";
1400
+ tableName: "auth_verification";
1401
+ dataType: "string";
1402
+ columnType: "PgText";
1403
+ data: string;
1404
+ driverParam: string;
1405
+ notNull: true;
1406
+ hasDefault: false;
1407
+ isPrimaryKey: false;
1408
+ isAutoincrement: false;
1409
+ hasRuntimeDefault: false;
1410
+ enumValues: [string, ...string[]];
1411
+ baseColumn: never;
1412
+ identity: undefined;
1413
+ generated: undefined;
1414
+ }, {}, {}>;
1415
+ value: import("drizzle-orm/pg-core").PgColumn<{
1416
+ name: "value";
1417
+ tableName: "auth_verification";
1418
+ dataType: "string";
1419
+ columnType: "PgText";
1420
+ data: string;
1421
+ driverParam: string;
1422
+ notNull: true;
1423
+ hasDefault: false;
1424
+ isPrimaryKey: false;
1425
+ isAutoincrement: false;
1426
+ hasRuntimeDefault: false;
1427
+ enumValues: [string, ...string[]];
1428
+ baseColumn: never;
1429
+ identity: undefined;
1430
+ generated: undefined;
1431
+ }, {}, {}>;
1432
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
1433
+ name: "expires_at";
1434
+ tableName: "auth_verification";
1435
+ dataType: "date";
1436
+ columnType: "PgTimestamp";
1437
+ data: Date;
1438
+ driverParam: string;
1439
+ notNull: true;
1440
+ hasDefault: false;
1441
+ isPrimaryKey: false;
1442
+ isAutoincrement: false;
1443
+ hasRuntimeDefault: false;
1444
+ enumValues: undefined;
1445
+ baseColumn: never;
1446
+ identity: undefined;
1447
+ generated: undefined;
1448
+ }, {}, {}>;
1449
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1450
+ name: "created_at";
1451
+ tableName: "auth_verification";
1452
+ dataType: "date";
1453
+ columnType: "PgTimestamp";
1454
+ data: Date;
1455
+ driverParam: string;
1456
+ notNull: true;
1457
+ hasDefault: false;
1458
+ isPrimaryKey: false;
1459
+ isAutoincrement: false;
1460
+ hasRuntimeDefault: false;
1461
+ enumValues: undefined;
1462
+ baseColumn: never;
1463
+ identity: undefined;
1464
+ generated: undefined;
1465
+ }, {}, {}>;
1466
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1467
+ name: "updated_at";
1468
+ tableName: "auth_verification";
1469
+ dataType: "date";
1470
+ columnType: "PgTimestamp";
1471
+ data: Date;
1472
+ driverParam: string;
1473
+ notNull: true;
1474
+ hasDefault: true;
1475
+ isPrimaryKey: false;
1476
+ isAutoincrement: false;
1477
+ hasRuntimeDefault: false;
1478
+ enumValues: undefined;
1479
+ baseColumn: never;
1480
+ identity: undefined;
1481
+ generated: undefined;
1482
+ }, {}, {}>;
1483
+ };
1484
+ dialect: "pg";
1485
+ }>;
1486
+ memberChecks: import("drizzle-orm/pg-core").PgTableWithColumns<{
1487
+ name: "member_checks";
1488
+ schema: undefined;
1489
+ columns: {
1490
+ sub: import("drizzle-orm/pg-core").PgColumn<{
1491
+ name: "sub";
1492
+ tableName: "member_checks";
1493
+ dataType: "string";
1494
+ columnType: "PgVarchar";
1495
+ data: string;
1496
+ driverParam: string;
1497
+ notNull: true;
1498
+ hasDefault: false;
1499
+ isPrimaryKey: true;
1500
+ isAutoincrement: false;
1501
+ hasRuntimeDefault: false;
1502
+ enumValues: [string, ...string[]];
1503
+ baseColumn: never;
1504
+ identity: undefined;
1505
+ generated: undefined;
1506
+ }, {}, {
1507
+ length: 255;
1508
+ }>;
1509
+ username: import("drizzle-orm/pg-core").PgColumn<{
1510
+ name: "username";
1511
+ tableName: "member_checks";
1512
+ dataType: "string";
1513
+ columnType: "PgVarchar";
1514
+ data: string;
1515
+ driverParam: string;
1516
+ notNull: true;
1517
+ hasDefault: false;
1518
+ isPrimaryKey: false;
1519
+ isAutoincrement: false;
1520
+ hasRuntimeDefault: false;
1521
+ enumValues: [string, ...string[]];
1522
+ baseColumn: never;
1523
+ identity: undefined;
1524
+ generated: undefined;
1525
+ }, {}, {
1526
+ length: 255;
1527
+ }>;
1528
+ member: import("drizzle-orm/pg-core").PgColumn<{
1529
+ name: "member";
1530
+ tableName: "member_checks";
1531
+ dataType: "boolean";
1532
+ columnType: "PgBoolean";
1533
+ data: boolean;
1534
+ driverParam: boolean;
1535
+ notNull: true;
1536
+ hasDefault: false;
1537
+ isPrimaryKey: false;
1538
+ isAutoincrement: false;
1539
+ hasRuntimeDefault: false;
1540
+ enumValues: undefined;
1541
+ baseColumn: never;
1542
+ identity: undefined;
1543
+ generated: undefined;
1544
+ }, {}, {}>;
1545
+ admin: import("drizzle-orm/pg-core").PgColumn<{
1546
+ name: "admin";
1547
+ tableName: "member_checks";
1548
+ dataType: "boolean";
1549
+ columnType: "PgBoolean";
1550
+ data: boolean;
1551
+ driverParam: boolean;
1552
+ notNull: true;
1553
+ hasDefault: false;
1554
+ isPrimaryKey: false;
1555
+ isAutoincrement: false;
1556
+ hasRuntimeDefault: false;
1557
+ enumValues: undefined;
1558
+ baseColumn: never;
1559
+ identity: undefined;
1560
+ generated: undefined;
1561
+ }, {}, {}>;
1562
+ source: import("drizzle-orm/pg-core").PgColumn<{
1563
+ name: "source";
1564
+ tableName: "member_checks";
1565
+ dataType: "string";
1566
+ columnType: "PgVarchar";
1567
+ data: string;
1568
+ driverParam: string;
1569
+ notNull: true;
1570
+ hasDefault: false;
1571
+ isPrimaryKey: false;
1572
+ isAutoincrement: false;
1573
+ hasRuntimeDefault: false;
1574
+ enumValues: [string, ...string[]];
1575
+ baseColumn: never;
1576
+ identity: undefined;
1577
+ generated: undefined;
1578
+ }, {}, {
1579
+ length: 16;
1580
+ }>;
1581
+ checkedAt: import("drizzle-orm/pg-core").PgColumn<{
1582
+ name: "checked_at";
1583
+ tableName: "member_checks";
1584
+ dataType: "date";
1585
+ columnType: "PgTimestamp";
1586
+ data: Date;
1587
+ driverParam: string;
1588
+ notNull: true;
1589
+ hasDefault: false;
1590
+ isPrimaryKey: false;
1591
+ isAutoincrement: false;
1592
+ hasRuntimeDefault: false;
1593
+ enumValues: undefined;
1594
+ baseColumn: never;
1595
+ identity: undefined;
1596
+ generated: undefined;
1597
+ }, {}, {}>;
1598
+ };
1599
+ dialect: "pg";
1600
+ }>;
1601
+ accessRequests: import("drizzle-orm/pg-core").PgTableWithColumns<{
1602
+ name: "access_requests";
1603
+ schema: undefined;
1604
+ columns: {
1605
+ sub: import("drizzle-orm/pg-core").PgColumn<{
1606
+ name: "sub";
1607
+ tableName: "access_requests";
1608
+ dataType: "string";
1609
+ columnType: "PgVarchar";
1610
+ data: string;
1611
+ driverParam: string;
1612
+ notNull: true;
1613
+ hasDefault: false;
1614
+ isPrimaryKey: true;
1615
+ isAutoincrement: false;
1616
+ hasRuntimeDefault: false;
1617
+ enumValues: [string, ...string[]];
1618
+ baseColumn: never;
1619
+ identity: undefined;
1620
+ generated: undefined;
1621
+ }, {}, {
1622
+ length: 255;
1623
+ }>;
1624
+ username: import("drizzle-orm/pg-core").PgColumn<{
1625
+ name: "username";
1626
+ tableName: "access_requests";
1627
+ dataType: "string";
1628
+ columnType: "PgVarchar";
1629
+ data: string;
1630
+ driverParam: string;
1631
+ notNull: true;
1632
+ hasDefault: false;
1633
+ isPrimaryKey: false;
1634
+ isAutoincrement: false;
1635
+ hasRuntimeDefault: false;
1636
+ enumValues: [string, ...string[]];
1637
+ baseColumn: never;
1638
+ identity: undefined;
1639
+ generated: undefined;
1640
+ }, {}, {
1641
+ length: 255;
1642
+ }>;
1643
+ email: import("drizzle-orm/pg-core").PgColumn<{
1644
+ name: "email";
1645
+ tableName: "access_requests";
1646
+ dataType: "string";
1647
+ columnType: "PgVarchar";
1648
+ data: string;
1649
+ driverParam: string;
1650
+ notNull: false;
1651
+ hasDefault: false;
1652
+ isPrimaryKey: false;
1653
+ isAutoincrement: false;
1654
+ hasRuntimeDefault: false;
1655
+ enumValues: [string, ...string[]];
1656
+ baseColumn: never;
1657
+ identity: undefined;
1658
+ generated: undefined;
1659
+ }, {}, {
1660
+ length: 320;
1661
+ }>;
1662
+ name: import("drizzle-orm/pg-core").PgColumn<{
1663
+ name: "name";
1664
+ tableName: "access_requests";
1665
+ dataType: "string";
1666
+ columnType: "PgVarchar";
1667
+ data: string;
1668
+ driverParam: string;
1669
+ notNull: false;
1670
+ hasDefault: false;
1671
+ isPrimaryKey: false;
1672
+ isAutoincrement: false;
1673
+ hasRuntimeDefault: false;
1674
+ enumValues: [string, ...string[]];
1675
+ baseColumn: never;
1676
+ identity: undefined;
1677
+ generated: undefined;
1678
+ }, {}, {
1679
+ length: 255;
1680
+ }>;
1681
+ status: import("drizzle-orm/pg-core").PgColumn<{
1682
+ name: "status";
1683
+ tableName: "access_requests";
1684
+ dataType: "string";
1685
+ columnType: "PgVarchar";
1686
+ data: string;
1687
+ driverParam: string;
1688
+ notNull: true;
1689
+ hasDefault: false;
1690
+ isPrimaryKey: false;
1691
+ isAutoincrement: false;
1692
+ hasRuntimeDefault: false;
1693
+ enumValues: [string, ...string[]];
1694
+ baseColumn: never;
1695
+ identity: undefined;
1696
+ generated: undefined;
1697
+ }, {}, {
1698
+ length: 16;
1699
+ }>;
1700
+ requestedAt: import("drizzle-orm/pg-core").PgColumn<{
1701
+ name: "requested_at";
1702
+ tableName: "access_requests";
1703
+ dataType: "date";
1704
+ columnType: "PgTimestamp";
1705
+ data: Date;
1706
+ driverParam: string;
1707
+ notNull: true;
1708
+ hasDefault: true;
1709
+ isPrimaryKey: false;
1710
+ isAutoincrement: false;
1711
+ hasRuntimeDefault: false;
1712
+ enumValues: undefined;
1713
+ baseColumn: never;
1714
+ identity: undefined;
1715
+ generated: undefined;
1716
+ }, {}, {}>;
1717
+ decidedBy: import("drizzle-orm/pg-core").PgColumn<{
1718
+ name: "decided_by";
1719
+ tableName: "access_requests";
1720
+ dataType: "string";
1721
+ columnType: "PgVarchar";
1722
+ data: string;
1723
+ driverParam: string;
1724
+ notNull: false;
1725
+ hasDefault: false;
1726
+ isPrimaryKey: false;
1727
+ isAutoincrement: false;
1728
+ hasRuntimeDefault: false;
1729
+ enumValues: [string, ...string[]];
1730
+ baseColumn: never;
1731
+ identity: undefined;
1732
+ generated: undefined;
1733
+ }, {}, {
1734
+ length: 255;
1735
+ }>;
1736
+ decidedAt: import("drizzle-orm/pg-core").PgColumn<{
1737
+ name: "decided_at";
1738
+ tableName: "access_requests";
1739
+ dataType: "date";
1740
+ columnType: "PgTimestamp";
1741
+ data: Date;
1742
+ driverParam: string;
1743
+ notNull: false;
1744
+ hasDefault: false;
1745
+ isPrimaryKey: false;
1746
+ isAutoincrement: false;
1747
+ hasRuntimeDefault: false;
1748
+ enumValues: undefined;
1749
+ baseColumn: never;
1750
+ identity: undefined;
1751
+ generated: undefined;
1752
+ }, {}, {}>;
1753
+ };
1754
+ dialect: "pg";
1755
+ }>;
1756
+ };
1757
+ /** The Better Auth Drizzle adapter's schema map, keyed by model name. */
1758
+ export declare const betterAuthModels: {
1759
+ auth_user: import("drizzle-orm/pg-core").PgTableWithColumns<{
1760
+ name: "auth_user";
1761
+ schema: undefined;
1762
+ columns: {
1763
+ id: import("drizzle-orm/pg-core").PgColumn<{
1764
+ name: "id";
1765
+ tableName: "auth_user";
1766
+ dataType: "string";
1767
+ columnType: "PgText";
1768
+ data: string;
1769
+ driverParam: string;
1770
+ notNull: true;
1771
+ hasDefault: false;
1772
+ isPrimaryKey: true;
1773
+ isAutoincrement: false;
1774
+ hasRuntimeDefault: false;
1775
+ enumValues: [string, ...string[]];
1776
+ baseColumn: never;
1777
+ identity: undefined;
1778
+ generated: undefined;
1779
+ }, {}, {}>;
1780
+ name: import("drizzle-orm/pg-core").PgColumn<{
1781
+ name: "name";
1782
+ tableName: "auth_user";
1783
+ dataType: "string";
1784
+ columnType: "PgText";
1785
+ data: string;
1786
+ driverParam: string;
1787
+ notNull: true;
1788
+ hasDefault: false;
1789
+ isPrimaryKey: false;
1790
+ isAutoincrement: false;
1791
+ hasRuntimeDefault: false;
1792
+ enumValues: [string, ...string[]];
1793
+ baseColumn: never;
1794
+ identity: undefined;
1795
+ generated: undefined;
1796
+ }, {}, {}>;
1797
+ email: import("drizzle-orm/pg-core").PgColumn<{
1798
+ name: "email";
1799
+ tableName: "auth_user";
1800
+ dataType: "string";
1801
+ columnType: "PgText";
1802
+ data: string;
1803
+ driverParam: string;
1804
+ notNull: true;
1805
+ hasDefault: false;
1806
+ isPrimaryKey: false;
1807
+ isAutoincrement: false;
1808
+ hasRuntimeDefault: false;
1809
+ enumValues: [string, ...string[]];
1810
+ baseColumn: never;
1811
+ identity: undefined;
1812
+ generated: undefined;
1813
+ }, {}, {}>;
1814
+ emailVerified: import("drizzle-orm/pg-core").PgColumn<{
1815
+ name: "email_verified";
1816
+ tableName: "auth_user";
1817
+ dataType: "boolean";
1818
+ columnType: "PgBoolean";
1819
+ data: boolean;
1820
+ driverParam: boolean;
1821
+ notNull: true;
1822
+ hasDefault: true;
1823
+ isPrimaryKey: false;
1824
+ isAutoincrement: false;
1825
+ hasRuntimeDefault: false;
1826
+ enumValues: undefined;
1827
+ baseColumn: never;
1828
+ identity: undefined;
1829
+ generated: undefined;
1830
+ }, {}, {}>;
1831
+ image: import("drizzle-orm/pg-core").PgColumn<{
1832
+ name: "image";
1833
+ tableName: "auth_user";
1834
+ dataType: "string";
1835
+ columnType: "PgText";
1836
+ data: string;
1837
+ driverParam: string;
1838
+ notNull: false;
1839
+ hasDefault: false;
1840
+ isPrimaryKey: false;
1841
+ isAutoincrement: false;
1842
+ hasRuntimeDefault: false;
1843
+ enumValues: [string, ...string[]];
1844
+ baseColumn: never;
1845
+ identity: undefined;
1846
+ generated: undefined;
1847
+ }, {}, {}>;
1848
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1849
+ name: "created_at";
1850
+ tableName: "auth_user";
1851
+ dataType: "date";
1852
+ columnType: "PgTimestamp";
1853
+ data: Date;
1854
+ driverParam: string;
1855
+ notNull: true;
1856
+ hasDefault: false;
1857
+ isPrimaryKey: false;
1858
+ isAutoincrement: false;
1859
+ hasRuntimeDefault: false;
1860
+ enumValues: undefined;
1861
+ baseColumn: never;
1862
+ identity: undefined;
1863
+ generated: undefined;
1864
+ }, {}, {}>;
1865
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1866
+ name: "updated_at";
1867
+ tableName: "auth_user";
1868
+ dataType: "date";
1869
+ columnType: "PgTimestamp";
1870
+ data: Date;
1871
+ driverParam: string;
1872
+ notNull: true;
1873
+ hasDefault: true;
1874
+ isPrimaryKey: false;
1875
+ isAutoincrement: false;
1876
+ hasRuntimeDefault: false;
1877
+ enumValues: undefined;
1878
+ baseColumn: never;
1879
+ identity: undefined;
1880
+ generated: undefined;
1881
+ }, {}, {}>;
1882
+ };
1883
+ dialect: "pg";
1884
+ }>;
1885
+ auth_session: import("drizzle-orm/pg-core").PgTableWithColumns<{
1886
+ name: "auth_session";
1887
+ schema: undefined;
1888
+ columns: {
1889
+ id: import("drizzle-orm/pg-core").PgColumn<{
1890
+ name: "id";
1891
+ tableName: "auth_session";
1892
+ dataType: "string";
1893
+ columnType: "PgText";
1894
+ data: string;
1895
+ driverParam: string;
1896
+ notNull: true;
1897
+ hasDefault: false;
1898
+ isPrimaryKey: true;
1899
+ isAutoincrement: false;
1900
+ hasRuntimeDefault: false;
1901
+ enumValues: [string, ...string[]];
1902
+ baseColumn: never;
1903
+ identity: undefined;
1904
+ generated: undefined;
1905
+ }, {}, {}>;
1906
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
1907
+ name: "expires_at";
1908
+ tableName: "auth_session";
1909
+ dataType: "date";
1910
+ columnType: "PgTimestamp";
1911
+ data: Date;
1912
+ driverParam: string;
1913
+ notNull: true;
1914
+ hasDefault: false;
1915
+ isPrimaryKey: false;
1916
+ isAutoincrement: false;
1917
+ hasRuntimeDefault: false;
1918
+ enumValues: undefined;
1919
+ baseColumn: never;
1920
+ identity: undefined;
1921
+ generated: undefined;
1922
+ }, {}, {}>;
1923
+ token: import("drizzle-orm/pg-core").PgColumn<{
1924
+ name: "token";
1925
+ tableName: "auth_session";
1926
+ dataType: "string";
1927
+ columnType: "PgText";
1928
+ data: string;
1929
+ driverParam: string;
1930
+ notNull: true;
1931
+ hasDefault: false;
1932
+ isPrimaryKey: false;
1933
+ isAutoincrement: false;
1934
+ hasRuntimeDefault: false;
1935
+ enumValues: [string, ...string[]];
1936
+ baseColumn: never;
1937
+ identity: undefined;
1938
+ generated: undefined;
1939
+ }, {}, {}>;
1940
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1941
+ name: "created_at";
1942
+ tableName: "auth_session";
1943
+ dataType: "date";
1944
+ columnType: "PgTimestamp";
1945
+ data: Date;
1946
+ driverParam: string;
1947
+ notNull: true;
1948
+ hasDefault: false;
1949
+ isPrimaryKey: false;
1950
+ isAutoincrement: false;
1951
+ hasRuntimeDefault: false;
1952
+ enumValues: undefined;
1953
+ baseColumn: never;
1954
+ identity: undefined;
1955
+ generated: undefined;
1956
+ }, {}, {}>;
1957
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1958
+ name: "updated_at";
1959
+ tableName: "auth_session";
1960
+ dataType: "date";
1961
+ columnType: "PgTimestamp";
1962
+ data: Date;
1963
+ driverParam: string;
1964
+ notNull: true;
1965
+ hasDefault: true;
1966
+ isPrimaryKey: false;
1967
+ isAutoincrement: false;
1968
+ hasRuntimeDefault: false;
1969
+ enumValues: undefined;
1970
+ baseColumn: never;
1971
+ identity: undefined;
1972
+ generated: undefined;
1973
+ }, {}, {}>;
1974
+ ipAddress: import("drizzle-orm/pg-core").PgColumn<{
1975
+ name: "ip_address";
1976
+ tableName: "auth_session";
1977
+ dataType: "string";
1978
+ columnType: "PgText";
1979
+ data: string;
1980
+ driverParam: string;
1981
+ notNull: false;
1982
+ hasDefault: false;
1983
+ isPrimaryKey: false;
1984
+ isAutoincrement: false;
1985
+ hasRuntimeDefault: false;
1986
+ enumValues: [string, ...string[]];
1987
+ baseColumn: never;
1988
+ identity: undefined;
1989
+ generated: undefined;
1990
+ }, {}, {}>;
1991
+ userAgent: import("drizzle-orm/pg-core").PgColumn<{
1992
+ name: "user_agent";
1993
+ tableName: "auth_session";
1994
+ dataType: "string";
1995
+ columnType: "PgText";
1996
+ data: string;
1997
+ driverParam: string;
1998
+ notNull: false;
1999
+ hasDefault: false;
2000
+ isPrimaryKey: false;
2001
+ isAutoincrement: false;
2002
+ hasRuntimeDefault: false;
2003
+ enumValues: [string, ...string[]];
2004
+ baseColumn: never;
2005
+ identity: undefined;
2006
+ generated: undefined;
2007
+ }, {}, {}>;
2008
+ userId: import("drizzle-orm/pg-core").PgColumn<{
2009
+ name: "user_id";
2010
+ tableName: "auth_session";
2011
+ dataType: "string";
2012
+ columnType: "PgText";
2013
+ data: string;
2014
+ driverParam: string;
2015
+ notNull: true;
2016
+ hasDefault: false;
2017
+ isPrimaryKey: false;
2018
+ isAutoincrement: false;
2019
+ hasRuntimeDefault: false;
2020
+ enumValues: [string, ...string[]];
2021
+ baseColumn: never;
2022
+ identity: undefined;
2023
+ generated: undefined;
2024
+ }, {}, {}>;
2025
+ };
2026
+ dialect: "pg";
2027
+ }>;
2028
+ auth_account: import("drizzle-orm/pg-core").PgTableWithColumns<{
2029
+ name: "auth_account";
2030
+ schema: undefined;
2031
+ columns: {
2032
+ id: import("drizzle-orm/pg-core").PgColumn<{
2033
+ name: "id";
2034
+ tableName: "auth_account";
2035
+ dataType: "string";
2036
+ columnType: "PgText";
2037
+ data: string;
2038
+ driverParam: string;
2039
+ notNull: true;
2040
+ hasDefault: false;
2041
+ isPrimaryKey: true;
2042
+ isAutoincrement: false;
2043
+ hasRuntimeDefault: false;
2044
+ enumValues: [string, ...string[]];
2045
+ baseColumn: never;
2046
+ identity: undefined;
2047
+ generated: undefined;
2048
+ }, {}, {}>;
2049
+ accountId: import("drizzle-orm/pg-core").PgColumn<{
2050
+ name: "account_id";
2051
+ tableName: "auth_account";
2052
+ dataType: "string";
2053
+ columnType: "PgText";
2054
+ data: string;
2055
+ driverParam: string;
2056
+ notNull: true;
2057
+ hasDefault: false;
2058
+ isPrimaryKey: false;
2059
+ isAutoincrement: false;
2060
+ hasRuntimeDefault: false;
2061
+ enumValues: [string, ...string[]];
2062
+ baseColumn: never;
2063
+ identity: undefined;
2064
+ generated: undefined;
2065
+ }, {}, {}>;
2066
+ providerId: import("drizzle-orm/pg-core").PgColumn<{
2067
+ name: "provider_id";
2068
+ tableName: "auth_account";
2069
+ dataType: "string";
2070
+ columnType: "PgText";
2071
+ data: string;
2072
+ driverParam: string;
2073
+ notNull: true;
2074
+ hasDefault: false;
2075
+ isPrimaryKey: false;
2076
+ isAutoincrement: false;
2077
+ hasRuntimeDefault: false;
2078
+ enumValues: [string, ...string[]];
2079
+ baseColumn: never;
2080
+ identity: undefined;
2081
+ generated: undefined;
2082
+ }, {}, {}>;
2083
+ userId: import("drizzle-orm/pg-core").PgColumn<{
2084
+ name: "user_id";
2085
+ tableName: "auth_account";
2086
+ dataType: "string";
2087
+ columnType: "PgText";
2088
+ data: string;
2089
+ driverParam: string;
2090
+ notNull: true;
2091
+ hasDefault: false;
2092
+ isPrimaryKey: false;
2093
+ isAutoincrement: false;
2094
+ hasRuntimeDefault: false;
2095
+ enumValues: [string, ...string[]];
2096
+ baseColumn: never;
2097
+ identity: undefined;
2098
+ generated: undefined;
2099
+ }, {}, {}>;
2100
+ accessToken: import("drizzle-orm/pg-core").PgColumn<{
2101
+ name: "access_token";
2102
+ tableName: "auth_account";
2103
+ dataType: "string";
2104
+ columnType: "PgText";
2105
+ data: string;
2106
+ driverParam: string;
2107
+ notNull: false;
2108
+ hasDefault: false;
2109
+ isPrimaryKey: false;
2110
+ isAutoincrement: false;
2111
+ hasRuntimeDefault: false;
2112
+ enumValues: [string, ...string[]];
2113
+ baseColumn: never;
2114
+ identity: undefined;
2115
+ generated: undefined;
2116
+ }, {}, {}>;
2117
+ refreshToken: import("drizzle-orm/pg-core").PgColumn<{
2118
+ name: "refresh_token";
2119
+ tableName: "auth_account";
2120
+ dataType: "string";
2121
+ columnType: "PgText";
2122
+ data: string;
2123
+ driverParam: string;
2124
+ notNull: false;
2125
+ hasDefault: false;
2126
+ isPrimaryKey: false;
2127
+ isAutoincrement: false;
2128
+ hasRuntimeDefault: false;
2129
+ enumValues: [string, ...string[]];
2130
+ baseColumn: never;
2131
+ identity: undefined;
2132
+ generated: undefined;
2133
+ }, {}, {}>;
2134
+ idToken: import("drizzle-orm/pg-core").PgColumn<{
2135
+ name: "id_token";
2136
+ tableName: "auth_account";
2137
+ dataType: "string";
2138
+ columnType: "PgText";
2139
+ data: string;
2140
+ driverParam: string;
2141
+ notNull: false;
2142
+ hasDefault: false;
2143
+ isPrimaryKey: false;
2144
+ isAutoincrement: false;
2145
+ hasRuntimeDefault: false;
2146
+ enumValues: [string, ...string[]];
2147
+ baseColumn: never;
2148
+ identity: undefined;
2149
+ generated: undefined;
2150
+ }, {}, {}>;
2151
+ accessTokenExpiresAt: import("drizzle-orm/pg-core").PgColumn<{
2152
+ name: "access_token_expires_at";
2153
+ tableName: "auth_account";
2154
+ dataType: "date";
2155
+ columnType: "PgTimestamp";
2156
+ data: Date;
2157
+ driverParam: string;
2158
+ notNull: false;
2159
+ hasDefault: false;
2160
+ isPrimaryKey: false;
2161
+ isAutoincrement: false;
2162
+ hasRuntimeDefault: false;
2163
+ enumValues: undefined;
2164
+ baseColumn: never;
2165
+ identity: undefined;
2166
+ generated: undefined;
2167
+ }, {}, {}>;
2168
+ refreshTokenExpiresAt: import("drizzle-orm/pg-core").PgColumn<{
2169
+ name: "refresh_token_expires_at";
2170
+ tableName: "auth_account";
2171
+ dataType: "date";
2172
+ columnType: "PgTimestamp";
2173
+ data: Date;
2174
+ driverParam: string;
2175
+ notNull: false;
2176
+ hasDefault: false;
2177
+ isPrimaryKey: false;
2178
+ isAutoincrement: false;
2179
+ hasRuntimeDefault: false;
2180
+ enumValues: undefined;
2181
+ baseColumn: never;
2182
+ identity: undefined;
2183
+ generated: undefined;
2184
+ }, {}, {}>;
2185
+ scope: import("drizzle-orm/pg-core").PgColumn<{
2186
+ name: "scope";
2187
+ tableName: "auth_account";
2188
+ dataType: "string";
2189
+ columnType: "PgText";
2190
+ data: string;
2191
+ driverParam: string;
2192
+ notNull: false;
2193
+ hasDefault: false;
2194
+ isPrimaryKey: false;
2195
+ isAutoincrement: false;
2196
+ hasRuntimeDefault: false;
2197
+ enumValues: [string, ...string[]];
2198
+ baseColumn: never;
2199
+ identity: undefined;
2200
+ generated: undefined;
2201
+ }, {}, {}>;
2202
+ password: import("drizzle-orm/pg-core").PgColumn<{
2203
+ name: "password";
2204
+ tableName: "auth_account";
2205
+ dataType: "string";
2206
+ columnType: "PgText";
2207
+ data: string;
2208
+ driverParam: string;
2209
+ notNull: false;
2210
+ hasDefault: false;
2211
+ isPrimaryKey: false;
2212
+ isAutoincrement: false;
2213
+ hasRuntimeDefault: false;
2214
+ enumValues: [string, ...string[]];
2215
+ baseColumn: never;
2216
+ identity: undefined;
2217
+ generated: undefined;
2218
+ }, {}, {}>;
2219
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2220
+ name: "created_at";
2221
+ tableName: "auth_account";
2222
+ dataType: "date";
2223
+ columnType: "PgTimestamp";
2224
+ data: Date;
2225
+ driverParam: string;
2226
+ notNull: true;
2227
+ hasDefault: false;
2228
+ isPrimaryKey: false;
2229
+ isAutoincrement: false;
2230
+ hasRuntimeDefault: false;
2231
+ enumValues: undefined;
2232
+ baseColumn: never;
2233
+ identity: undefined;
2234
+ generated: undefined;
2235
+ }, {}, {}>;
2236
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2237
+ name: "updated_at";
2238
+ tableName: "auth_account";
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
+ };
2254
+ dialect: "pg";
2255
+ }>;
2256
+ auth_verification: import("drizzle-orm/pg-core").PgTableWithColumns<{
2257
+ name: "auth_verification";
2258
+ schema: undefined;
2259
+ columns: {
2260
+ id: import("drizzle-orm/pg-core").PgColumn<{
2261
+ name: "id";
2262
+ tableName: "auth_verification";
2263
+ dataType: "string";
2264
+ columnType: "PgText";
2265
+ data: string;
2266
+ driverParam: string;
2267
+ notNull: true;
2268
+ hasDefault: false;
2269
+ isPrimaryKey: true;
2270
+ isAutoincrement: false;
2271
+ hasRuntimeDefault: false;
2272
+ enumValues: [string, ...string[]];
2273
+ baseColumn: never;
2274
+ identity: undefined;
2275
+ generated: undefined;
2276
+ }, {}, {}>;
2277
+ identifier: import("drizzle-orm/pg-core").PgColumn<{
2278
+ name: "identifier";
2279
+ tableName: "auth_verification";
2280
+ dataType: "string";
2281
+ columnType: "PgText";
2282
+ data: string;
2283
+ driverParam: string;
2284
+ notNull: true;
2285
+ hasDefault: false;
2286
+ isPrimaryKey: false;
2287
+ isAutoincrement: false;
2288
+ hasRuntimeDefault: false;
2289
+ enumValues: [string, ...string[]];
2290
+ baseColumn: never;
2291
+ identity: undefined;
2292
+ generated: undefined;
2293
+ }, {}, {}>;
2294
+ value: import("drizzle-orm/pg-core").PgColumn<{
2295
+ name: "value";
2296
+ tableName: "auth_verification";
2297
+ dataType: "string";
2298
+ columnType: "PgText";
2299
+ data: string;
2300
+ driverParam: string;
2301
+ notNull: true;
2302
+ hasDefault: false;
2303
+ isPrimaryKey: false;
2304
+ isAutoincrement: false;
2305
+ hasRuntimeDefault: false;
2306
+ enumValues: [string, ...string[]];
2307
+ baseColumn: never;
2308
+ identity: undefined;
2309
+ generated: undefined;
2310
+ }, {}, {}>;
2311
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
2312
+ name: "expires_at";
2313
+ tableName: "auth_verification";
2314
+ dataType: "date";
2315
+ columnType: "PgTimestamp";
2316
+ data: Date;
2317
+ driverParam: string;
2318
+ notNull: true;
2319
+ hasDefault: false;
2320
+ isPrimaryKey: false;
2321
+ isAutoincrement: false;
2322
+ hasRuntimeDefault: false;
2323
+ enumValues: undefined;
2324
+ baseColumn: never;
2325
+ identity: undefined;
2326
+ generated: undefined;
2327
+ }, {}, {}>;
2328
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2329
+ name: "created_at";
2330
+ tableName: "auth_verification";
2331
+ dataType: "date";
2332
+ columnType: "PgTimestamp";
2333
+ data: Date;
2334
+ driverParam: string;
2335
+ notNull: true;
2336
+ hasDefault: false;
2337
+ isPrimaryKey: false;
2338
+ isAutoincrement: false;
2339
+ hasRuntimeDefault: false;
2340
+ enumValues: undefined;
2341
+ baseColumn: never;
2342
+ identity: undefined;
2343
+ generated: undefined;
2344
+ }, {}, {}>;
2345
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2346
+ name: "updated_at";
2347
+ tableName: "auth_verification";
2348
+ dataType: "date";
2349
+ columnType: "PgTimestamp";
2350
+ data: Date;
2351
+ driverParam: string;
2352
+ notNull: true;
2353
+ hasDefault: true;
2354
+ isPrimaryKey: false;
2355
+ isAutoincrement: false;
2356
+ hasRuntimeDefault: false;
2357
+ enumValues: undefined;
2358
+ baseColumn: never;
2359
+ identity: undefined;
2360
+ generated: undefined;
2361
+ }, {}, {}>;
2362
+ };
2363
+ dialect: "pg";
2364
+ }>;
2365
+ };
2366
+ export type MemberCheck = typeof memberChecks.$inferSelect;
2367
+ export type AccessRequest = typeof accessRequests.$inferSelect;