@vonall/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 (62) hide show
  1. package/CHANGELOG.md +12 -0
  2. package/LICENSE +21 -0
  3. package/README.md +33 -2
  4. package/dist/client/index.d.ts +17 -0
  5. package/dist/client/index.js +18 -0
  6. package/dist/index.d.ts +8 -0
  7. package/dist/index.js +10 -0
  8. package/dist/messages.d.ts +50 -0
  9. package/dist/messages.js +88 -0
  10. package/dist/permissions.d.ts +48 -0
  11. package/dist/permissions.js +17 -0
  12. package/dist/remote/app_user.remote.d.ts +66 -0
  13. package/dist/remote/app_user.remote.js +91 -0
  14. package/dist/remote/einladung.remote.d.ts +27 -0
  15. package/dist/remote/einladung.remote.js +56 -0
  16. package/dist/remote/index.d.ts +2 -0
  17. package/dist/remote/index.js +2 -0
  18. package/dist/schema/index.d.ts +3683 -0
  19. package/dist/schema/index.js +265 -0
  20. package/dist/server/create.d.ts +87 -0
  21. package/dist/server/create.js +158 -0
  22. package/dist/server/crypto.d.ts +5 -0
  23. package/dist/server/crypto.js +15 -0
  24. package/dist/server/helpers.d.ts +18 -0
  25. package/dist/server/helpers.js +62 -0
  26. package/dist/server/index.d.ts +9 -0
  27. package/dist/server/index.js +9 -0
  28. package/dist/server/loads.d.ts +57 -0
  29. package/dist/server/loads.js +83 -0
  30. package/dist/server/registry.d.ts +39 -0
  31. package/dist/server/registry.js +15 -0
  32. package/dist/server/repositories/EinladungRepo.d.ts +36 -0
  33. package/dist/server/repositories/EinladungRepo.js +74 -0
  34. package/dist/server/repositories/UserRepo.d.ts +19 -0
  35. package/dist/server/repositories/UserRepo.js +67 -0
  36. package/dist/server/service/einladung.service.d.ts +48 -0
  37. package/dist/server/service/einladung.service.js +76 -0
  38. package/dist/server/service/konto.service.d.ts +7 -0
  39. package/dist/server/service/konto.service.js +11 -0
  40. package/dist/server/service/mail.d.ts +12 -0
  41. package/dist/server/service/mail.js +40 -0
  42. package/dist/templates/InvitationEmail.svelte +18 -0
  43. package/dist/templates/InvitationEmail.svelte.d.ts +10 -0
  44. package/dist/templates/ResetPasswordEmail.svelte +16 -0
  45. package/dist/templates/ResetPasswordEmail.svelte.d.ts +9 -0
  46. package/dist/templates/VerifyEmailEmail.svelte +16 -0
  47. package/dist/templates/VerifyEmailEmail.svelte.d.ts +9 -0
  48. package/dist/testing/index.d.ts +6 -0
  49. package/dist/testing/index.js +26 -0
  50. package/dist/types.d.ts +38 -0
  51. package/dist/types.js +21 -0
  52. package/dist/util/fresh.d.ts +11 -0
  53. package/dist/util/fresh.js +20 -0
  54. package/dist/util/messageOf.d.ts +5 -0
  55. package/dist/util/messageOf.js +12 -0
  56. package/dist/util/names.d.ts +10 -0
  57. package/dist/util/names.js +19 -0
  58. package/dist/util/sameSite.d.ts +5 -0
  59. package/dist/util/sameSite.js +15 -0
  60. package/dist/util/signup.d.ts +15 -0
  61. package/dist/util/signup.js +23 -0
  62. package/package.json +96 -3
package/dist/schema/index.d.ts ADDED
@@ -0,0 +1,3683 @@
1
+ export type SchemaOptions = {
2
+ /** The Admin option: `role`, `banned`, `banReason`, `banExpires` on `user`, `impersonatedBy` on `session`. */
3
+ admin?: boolean;
4
+ /** The tables of the OAuth provider for the MCP endpoint (`@vonall/mcp`). */
5
+ mcp?: boolean;
6
+ };
7
+ declare const buildUser: () => import("drizzle-orm/pg-core").PgTableWithColumns<{
8
+ name: "user";
9
+ schema: undefined;
10
+ columns: {
11
+ id: import("drizzle-orm/pg-core").PgColumn<{
12
+ name: "id";
13
+ tableName: "user";
14
+ dataType: "string";
15
+ columnType: "PgText";
16
+ data: string;
17
+ driverParam: string;
18
+ notNull: true;
19
+ hasDefault: false;
20
+ isPrimaryKey: true;
21
+ isAutoincrement: false;
22
+ hasRuntimeDefault: false;
23
+ enumValues: [string, ...string[]];
24
+ baseColumn: never;
25
+ identity: undefined;
26
+ generated: undefined;
27
+ }, {}, {}>;
28
+ name: import("drizzle-orm/pg-core").PgColumn<{
29
+ name: "name";
30
+ tableName: "user";
31
+ dataType: "string";
32
+ columnType: "PgText";
33
+ data: string;
34
+ driverParam: string;
35
+ notNull: true;
36
+ hasDefault: false;
37
+ isPrimaryKey: false;
38
+ isAutoincrement: false;
39
+ hasRuntimeDefault: false;
40
+ enumValues: [string, ...string[]];
41
+ baseColumn: never;
42
+ identity: undefined;
43
+ generated: undefined;
44
+ }, {}, {}>;
45
+ email: import("drizzle-orm/pg-core").PgColumn<{
46
+ name: "email";
47
+ tableName: "user";
48
+ dataType: "string";
49
+ columnType: "PgText";
50
+ data: string;
51
+ driverParam: string;
52
+ notNull: true;
53
+ hasDefault: false;
54
+ isPrimaryKey: false;
55
+ isAutoincrement: false;
56
+ hasRuntimeDefault: false;
57
+ enumValues: [string, ...string[]];
58
+ baseColumn: never;
59
+ identity: undefined;
60
+ generated: undefined;
61
+ }, {}, {}>;
62
+ emailVerified: import("drizzle-orm/pg-core").PgColumn<{
63
+ name: "email_verified";
64
+ tableName: "user";
65
+ dataType: "boolean";
66
+ columnType: "PgBoolean";
67
+ data: boolean;
68
+ driverParam: boolean;
69
+ notNull: true;
70
+ hasDefault: false;
71
+ isPrimaryKey: false;
72
+ isAutoincrement: false;
73
+ hasRuntimeDefault: false;
74
+ enumValues: undefined;
75
+ baseColumn: never;
76
+ identity: undefined;
77
+ generated: undefined;
78
+ }, {}, {}>;
79
+ image: import("drizzle-orm/pg-core").PgColumn<{
80
+ name: "image";
81
+ tableName: "user";
82
+ dataType: "string";
83
+ columnType: "PgText";
84
+ data: string;
85
+ driverParam: string;
86
+ notNull: false;
87
+ hasDefault: false;
88
+ isPrimaryKey: false;
89
+ isAutoincrement: false;
90
+ hasRuntimeDefault: false;
91
+ enumValues: [string, ...string[]];
92
+ baseColumn: never;
93
+ identity: undefined;
94
+ generated: undefined;
95
+ }, {}, {}>;
96
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
97
+ name: "created_at";
98
+ tableName: "user";
99
+ dataType: "date";
100
+ columnType: "PgTimestamp";
101
+ data: Date;
102
+ driverParam: string;
103
+ notNull: true;
104
+ hasDefault: false;
105
+ isPrimaryKey: false;
106
+ isAutoincrement: false;
107
+ hasRuntimeDefault: false;
108
+ enumValues: undefined;
109
+ baseColumn: never;
110
+ identity: undefined;
111
+ generated: undefined;
112
+ }, {}, {}>;
113
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
114
+ name: "updated_at";
115
+ tableName: "user";
116
+ dataType: "date";
117
+ columnType: "PgTimestamp";
118
+ data: Date;
119
+ driverParam: string;
120
+ notNull: true;
121
+ hasDefault: false;
122
+ isPrimaryKey: false;
123
+ isAutoincrement: false;
124
+ hasRuntimeDefault: false;
125
+ enumValues: undefined;
126
+ baseColumn: never;
127
+ identity: undefined;
128
+ generated: undefined;
129
+ }, {}, {}>;
130
+ twoFactorEnabled: import("drizzle-orm/pg-core").PgColumn<{
131
+ name: "two_factor_enabled";
132
+ tableName: "user";
133
+ dataType: "boolean";
134
+ columnType: "PgBoolean";
135
+ data: boolean;
136
+ driverParam: boolean;
137
+ notNull: false;
138
+ hasDefault: false;
139
+ isPrimaryKey: false;
140
+ isAutoincrement: false;
141
+ hasRuntimeDefault: false;
142
+ enumValues: undefined;
143
+ baseColumn: never;
144
+ identity: undefined;
145
+ generated: undefined;
146
+ }, {}, {}>;
147
+ };
148
+ dialect: "pg";
149
+ }>;
150
+ declare const buildUserAdmin: () => import("drizzle-orm/pg-core").PgTableWithColumns<{
151
+ name: "user";
152
+ schema: undefined;
153
+ columns: {
154
+ role: import("drizzle-orm/pg-core").PgColumn<{
155
+ name: "role";
156
+ tableName: "user";
157
+ dataType: "string";
158
+ columnType: "PgText";
159
+ data: string;
160
+ driverParam: string;
161
+ notNull: true;
162
+ hasDefault: true;
163
+ isPrimaryKey: false;
164
+ isAutoincrement: false;
165
+ hasRuntimeDefault: false;
166
+ enumValues: [string, ...string[]];
167
+ baseColumn: never;
168
+ identity: undefined;
169
+ generated: undefined;
170
+ }, {}, {}>;
171
+ banned: import("drizzle-orm/pg-core").PgColumn<{
172
+ name: "banned";
173
+ tableName: "user";
174
+ dataType: "boolean";
175
+ columnType: "PgBoolean";
176
+ data: boolean;
177
+ driverParam: boolean;
178
+ notNull: true;
179
+ hasDefault: true;
180
+ isPrimaryKey: false;
181
+ isAutoincrement: false;
182
+ hasRuntimeDefault: false;
183
+ enumValues: undefined;
184
+ baseColumn: never;
185
+ identity: undefined;
186
+ generated: undefined;
187
+ }, {}, {}>;
188
+ banReason: import("drizzle-orm/pg-core").PgColumn<{
189
+ name: "ban_reason";
190
+ tableName: "user";
191
+ dataType: "string";
192
+ columnType: "PgText";
193
+ data: string;
194
+ driverParam: string;
195
+ notNull: false;
196
+ hasDefault: false;
197
+ isPrimaryKey: false;
198
+ isAutoincrement: false;
199
+ hasRuntimeDefault: false;
200
+ enumValues: [string, ...string[]];
201
+ baseColumn: never;
202
+ identity: undefined;
203
+ generated: undefined;
204
+ }, {}, {}>;
205
+ banExpires: import("drizzle-orm/pg-core").PgColumn<{
206
+ name: "ban_expires";
207
+ tableName: "user";
208
+ dataType: "date";
209
+ columnType: "PgTimestamp";
210
+ data: Date;
211
+ driverParam: string;
212
+ notNull: false;
213
+ hasDefault: false;
214
+ isPrimaryKey: false;
215
+ isAutoincrement: false;
216
+ hasRuntimeDefault: false;
217
+ enumValues: undefined;
218
+ baseColumn: never;
219
+ identity: undefined;
220
+ generated: undefined;
221
+ }, {}, {}>;
222
+ id: import("drizzle-orm/pg-core").PgColumn<{
223
+ name: "id";
224
+ tableName: "user";
225
+ dataType: "string";
226
+ columnType: "PgText";
227
+ data: string;
228
+ driverParam: string;
229
+ notNull: true;
230
+ hasDefault: false;
231
+ isPrimaryKey: true;
232
+ isAutoincrement: false;
233
+ hasRuntimeDefault: false;
234
+ enumValues: [string, ...string[]];
235
+ baseColumn: never;
236
+ identity: undefined;
237
+ generated: undefined;
238
+ }, {}, {}>;
239
+ name: import("drizzle-orm/pg-core").PgColumn<{
240
+ name: "name";
241
+ tableName: "user";
242
+ dataType: "string";
243
+ columnType: "PgText";
244
+ data: string;
245
+ driverParam: string;
246
+ notNull: true;
247
+ hasDefault: false;
248
+ isPrimaryKey: false;
249
+ isAutoincrement: false;
250
+ hasRuntimeDefault: false;
251
+ enumValues: [string, ...string[]];
252
+ baseColumn: never;
253
+ identity: undefined;
254
+ generated: undefined;
255
+ }, {}, {}>;
256
+ email: import("drizzle-orm/pg-core").PgColumn<{
257
+ name: "email";
258
+ tableName: "user";
259
+ dataType: "string";
260
+ columnType: "PgText";
261
+ data: string;
262
+ driverParam: string;
263
+ notNull: true;
264
+ hasDefault: false;
265
+ isPrimaryKey: false;
266
+ isAutoincrement: false;
267
+ hasRuntimeDefault: false;
268
+ enumValues: [string, ...string[]];
269
+ baseColumn: never;
270
+ identity: undefined;
271
+ generated: undefined;
272
+ }, {}, {}>;
273
+ emailVerified: import("drizzle-orm/pg-core").PgColumn<{
274
+ name: "email_verified";
275
+ tableName: "user";
276
+ dataType: "boolean";
277
+ columnType: "PgBoolean";
278
+ data: boolean;
279
+ driverParam: boolean;
280
+ notNull: true;
281
+ hasDefault: false;
282
+ isPrimaryKey: false;
283
+ isAutoincrement: false;
284
+ hasRuntimeDefault: false;
285
+ enumValues: undefined;
286
+ baseColumn: never;
287
+ identity: undefined;
288
+ generated: undefined;
289
+ }, {}, {}>;
290
+ image: import("drizzle-orm/pg-core").PgColumn<{
291
+ name: "image";
292
+ tableName: "user";
293
+ dataType: "string";
294
+ columnType: "PgText";
295
+ data: string;
296
+ driverParam: string;
297
+ notNull: false;
298
+ hasDefault: false;
299
+ isPrimaryKey: false;
300
+ isAutoincrement: false;
301
+ hasRuntimeDefault: false;
302
+ enumValues: [string, ...string[]];
303
+ baseColumn: never;
304
+ identity: undefined;
305
+ generated: undefined;
306
+ }, {}, {}>;
307
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
308
+ name: "created_at";
309
+ tableName: "user";
310
+ dataType: "date";
311
+ columnType: "PgTimestamp";
312
+ data: Date;
313
+ driverParam: string;
314
+ notNull: true;
315
+ hasDefault: false;
316
+ isPrimaryKey: false;
317
+ isAutoincrement: false;
318
+ hasRuntimeDefault: false;
319
+ enumValues: undefined;
320
+ baseColumn: never;
321
+ identity: undefined;
322
+ generated: undefined;
323
+ }, {}, {}>;
324
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
325
+ name: "updated_at";
326
+ tableName: "user";
327
+ dataType: "date";
328
+ columnType: "PgTimestamp";
329
+ data: Date;
330
+ driverParam: string;
331
+ notNull: true;
332
+ hasDefault: false;
333
+ isPrimaryKey: false;
334
+ isAutoincrement: false;
335
+ hasRuntimeDefault: false;
336
+ enumValues: undefined;
337
+ baseColumn: never;
338
+ identity: undefined;
339
+ generated: undefined;
340
+ }, {}, {}>;
341
+ twoFactorEnabled: import("drizzle-orm/pg-core").PgColumn<{
342
+ name: "two_factor_enabled";
343
+ tableName: "user";
344
+ dataType: "boolean";
345
+ columnType: "PgBoolean";
346
+ data: boolean;
347
+ driverParam: boolean;
348
+ notNull: false;
349
+ hasDefault: false;
350
+ isPrimaryKey: false;
351
+ isAutoincrement: false;
352
+ hasRuntimeDefault: false;
353
+ enumValues: undefined;
354
+ baseColumn: never;
355
+ identity: undefined;
356
+ generated: undefined;
357
+ }, {}, {}>;
358
+ };
359
+ dialect: "pg";
360
+ }>;
361
+ export type UserTable = ReturnType<typeof buildUser>;
362
+ export type UserAdminTable = ReturnType<typeof buildUserAdmin>;
363
+ declare const buildSession: (user: UserTable) => import("drizzle-orm/pg-core").PgTableWithColumns<{
364
+ name: "session";
365
+ schema: undefined;
366
+ columns: {
367
+ id: import("drizzle-orm/pg-core").PgColumn<{
368
+ name: "id";
369
+ tableName: "session";
370
+ dataType: "string";
371
+ columnType: "PgText";
372
+ data: string;
373
+ driverParam: string;
374
+ notNull: true;
375
+ hasDefault: false;
376
+ isPrimaryKey: true;
377
+ isAutoincrement: false;
378
+ hasRuntimeDefault: false;
379
+ enumValues: [string, ...string[]];
380
+ baseColumn: never;
381
+ identity: undefined;
382
+ generated: undefined;
383
+ }, {}, {}>;
384
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
385
+ name: "expires_at";
386
+ tableName: "session";
387
+ dataType: "date";
388
+ columnType: "PgTimestamp";
389
+ data: Date;
390
+ driverParam: string;
391
+ notNull: true;
392
+ hasDefault: false;
393
+ isPrimaryKey: false;
394
+ isAutoincrement: false;
395
+ hasRuntimeDefault: false;
396
+ enumValues: undefined;
397
+ baseColumn: never;
398
+ identity: undefined;
399
+ generated: undefined;
400
+ }, {}, {}>;
401
+ token: import("drizzle-orm/pg-core").PgColumn<{
402
+ name: "token";
403
+ tableName: "session";
404
+ dataType: "string";
405
+ columnType: "PgText";
406
+ data: string;
407
+ driverParam: string;
408
+ notNull: true;
409
+ hasDefault: false;
410
+ isPrimaryKey: false;
411
+ isAutoincrement: false;
412
+ hasRuntimeDefault: false;
413
+ enumValues: [string, ...string[]];
414
+ baseColumn: never;
415
+ identity: undefined;
416
+ generated: undefined;
417
+ }, {}, {}>;
418
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
419
+ name: "created_at";
420
+ tableName: "session";
421
+ dataType: "date";
422
+ columnType: "PgTimestamp";
423
+ data: Date;
424
+ driverParam: string;
425
+ notNull: true;
426
+ hasDefault: false;
427
+ isPrimaryKey: false;
428
+ isAutoincrement: false;
429
+ hasRuntimeDefault: false;
430
+ enumValues: undefined;
431
+ baseColumn: never;
432
+ identity: undefined;
433
+ generated: undefined;
434
+ }, {}, {}>;
435
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
436
+ name: "updated_at";
437
+ tableName: "session";
438
+ dataType: "date";
439
+ columnType: "PgTimestamp";
440
+ data: Date;
441
+ driverParam: string;
442
+ notNull: true;
443
+ hasDefault: false;
444
+ isPrimaryKey: false;
445
+ isAutoincrement: false;
446
+ hasRuntimeDefault: false;
447
+ enumValues: undefined;
448
+ baseColumn: never;
449
+ identity: undefined;
450
+ generated: undefined;
451
+ }, {}, {}>;
452
+ ipAddress: import("drizzle-orm/pg-core").PgColumn<{
453
+ name: "ip_address";
454
+ tableName: "session";
455
+ dataType: "string";
456
+ columnType: "PgText";
457
+ data: string;
458
+ driverParam: string;
459
+ notNull: false;
460
+ hasDefault: false;
461
+ isPrimaryKey: false;
462
+ isAutoincrement: false;
463
+ hasRuntimeDefault: false;
464
+ enumValues: [string, ...string[]];
465
+ baseColumn: never;
466
+ identity: undefined;
467
+ generated: undefined;
468
+ }, {}, {}>;
469
+ userAgent: import("drizzle-orm/pg-core").PgColumn<{
470
+ name: "user_agent";
471
+ tableName: "session";
472
+ dataType: "string";
473
+ columnType: "PgText";
474
+ data: string;
475
+ driverParam: string;
476
+ notNull: false;
477
+ hasDefault: false;
478
+ isPrimaryKey: false;
479
+ isAutoincrement: false;
480
+ hasRuntimeDefault: false;
481
+ enumValues: [string, ...string[]];
482
+ baseColumn: never;
483
+ identity: undefined;
484
+ generated: undefined;
485
+ }, {}, {}>;
486
+ userId: import("drizzle-orm/pg-core").PgColumn<{
487
+ name: "user_id";
488
+ tableName: "session";
489
+ dataType: "string";
490
+ columnType: "PgText";
491
+ data: string;
492
+ driverParam: string;
493
+ notNull: true;
494
+ hasDefault: false;
495
+ isPrimaryKey: false;
496
+ isAutoincrement: false;
497
+ hasRuntimeDefault: false;
498
+ enumValues: [string, ...string[]];
499
+ baseColumn: never;
500
+ identity: undefined;
501
+ generated: undefined;
502
+ }, {}, {}>;
503
+ };
504
+ dialect: "pg";
505
+ }>;
506
+ declare const buildSessionAdmin: (user: UserTable) => import("drizzle-orm/pg-core").PgTableWithColumns<{
507
+ name: "session";
508
+ schema: undefined;
509
+ columns: {
510
+ impersonatedBy: import("drizzle-orm/pg-core").PgColumn<{
511
+ name: "impersonated_by";
512
+ tableName: "session";
513
+ dataType: "string";
514
+ columnType: "PgText";
515
+ data: string;
516
+ driverParam: string;
517
+ notNull: false;
518
+ hasDefault: false;
519
+ isPrimaryKey: false;
520
+ isAutoincrement: false;
521
+ hasRuntimeDefault: false;
522
+ enumValues: [string, ...string[]];
523
+ baseColumn: never;
524
+ identity: undefined;
525
+ generated: undefined;
526
+ }, {}, {}>;
527
+ id: import("drizzle-orm/pg-core").PgColumn<{
528
+ name: "id";
529
+ tableName: "session";
530
+ dataType: "string";
531
+ columnType: "PgText";
532
+ data: string;
533
+ driverParam: string;
534
+ notNull: true;
535
+ hasDefault: false;
536
+ isPrimaryKey: true;
537
+ isAutoincrement: false;
538
+ hasRuntimeDefault: false;
539
+ enumValues: [string, ...string[]];
540
+ baseColumn: never;
541
+ identity: undefined;
542
+ generated: undefined;
543
+ }, {}, {}>;
544
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
545
+ name: "expires_at";
546
+ tableName: "session";
547
+ dataType: "date";
548
+ columnType: "PgTimestamp";
549
+ data: Date;
550
+ driverParam: string;
551
+ notNull: true;
552
+ hasDefault: false;
553
+ isPrimaryKey: false;
554
+ isAutoincrement: false;
555
+ hasRuntimeDefault: false;
556
+ enumValues: undefined;
557
+ baseColumn: never;
558
+ identity: undefined;
559
+ generated: undefined;
560
+ }, {}, {}>;
561
+ token: import("drizzle-orm/pg-core").PgColumn<{
562
+ name: "token";
563
+ tableName: "session";
564
+ dataType: "string";
565
+ columnType: "PgText";
566
+ data: string;
567
+ driverParam: string;
568
+ notNull: true;
569
+ hasDefault: false;
570
+ isPrimaryKey: false;
571
+ isAutoincrement: false;
572
+ hasRuntimeDefault: false;
573
+ enumValues: [string, ...string[]];
574
+ baseColumn: never;
575
+ identity: undefined;
576
+ generated: undefined;
577
+ }, {}, {}>;
578
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
579
+ name: "created_at";
580
+ tableName: "session";
581
+ dataType: "date";
582
+ columnType: "PgTimestamp";
583
+ data: Date;
584
+ driverParam: string;
585
+ notNull: true;
586
+ hasDefault: false;
587
+ isPrimaryKey: false;
588
+ isAutoincrement: false;
589
+ hasRuntimeDefault: false;
590
+ enumValues: undefined;
591
+ baseColumn: never;
592
+ identity: undefined;
593
+ generated: undefined;
594
+ }, {}, {}>;
595
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
596
+ name: "updated_at";
597
+ tableName: "session";
598
+ dataType: "date";
599
+ columnType: "PgTimestamp";
600
+ data: Date;
601
+ driverParam: string;
602
+ notNull: true;
603
+ hasDefault: false;
604
+ isPrimaryKey: false;
605
+ isAutoincrement: false;
606
+ hasRuntimeDefault: false;
607
+ enumValues: undefined;
608
+ baseColumn: never;
609
+ identity: undefined;
610
+ generated: undefined;
611
+ }, {}, {}>;
612
+ ipAddress: import("drizzle-orm/pg-core").PgColumn<{
613
+ name: "ip_address";
614
+ tableName: "session";
615
+ dataType: "string";
616
+ columnType: "PgText";
617
+ data: string;
618
+ driverParam: string;
619
+ notNull: false;
620
+ hasDefault: false;
621
+ isPrimaryKey: false;
622
+ isAutoincrement: false;
623
+ hasRuntimeDefault: false;
624
+ enumValues: [string, ...string[]];
625
+ baseColumn: never;
626
+ identity: undefined;
627
+ generated: undefined;
628
+ }, {}, {}>;
629
+ userAgent: import("drizzle-orm/pg-core").PgColumn<{
630
+ name: "user_agent";
631
+ tableName: "session";
632
+ dataType: "string";
633
+ columnType: "PgText";
634
+ data: string;
635
+ driverParam: string;
636
+ notNull: false;
637
+ hasDefault: false;
638
+ isPrimaryKey: false;
639
+ isAutoincrement: false;
640
+ hasRuntimeDefault: false;
641
+ enumValues: [string, ...string[]];
642
+ baseColumn: never;
643
+ identity: undefined;
644
+ generated: undefined;
645
+ }, {}, {}>;
646
+ userId: import("drizzle-orm/pg-core").PgColumn<{
647
+ name: "user_id";
648
+ tableName: "session";
649
+ dataType: "string";
650
+ columnType: "PgText";
651
+ data: string;
652
+ driverParam: string;
653
+ notNull: true;
654
+ hasDefault: false;
655
+ isPrimaryKey: false;
656
+ isAutoincrement: false;
657
+ hasRuntimeDefault: false;
658
+ enumValues: [string, ...string[]];
659
+ baseColumn: never;
660
+ identity: undefined;
661
+ generated: undefined;
662
+ }, {}, {}>;
663
+ };
664
+ dialect: "pg";
665
+ }>;
666
+ export type SessionTable = ReturnType<typeof buildSession>;
667
+ export type SessionAdminTable = ReturnType<typeof buildSessionAdmin>;
668
+ declare function buildShared(user: UserTable): {
669
+ account: import("drizzle-orm/pg-core").PgTableWithColumns<{
670
+ name: "account";
671
+ schema: undefined;
672
+ columns: {
673
+ id: import("drizzle-orm/pg-core").PgColumn<{
674
+ name: "id";
675
+ tableName: "account";
676
+ dataType: "string";
677
+ columnType: "PgText";
678
+ data: string;
679
+ driverParam: string;
680
+ notNull: true;
681
+ hasDefault: false;
682
+ isPrimaryKey: true;
683
+ isAutoincrement: false;
684
+ hasRuntimeDefault: false;
685
+ enumValues: [string, ...string[]];
686
+ baseColumn: never;
687
+ identity: undefined;
688
+ generated: undefined;
689
+ }, {}, {}>;
690
+ accountId: import("drizzle-orm/pg-core").PgColumn<{
691
+ name: "account_id";
692
+ tableName: "account";
693
+ dataType: "string";
694
+ columnType: "PgText";
695
+ data: string;
696
+ driverParam: string;
697
+ notNull: true;
698
+ hasDefault: false;
699
+ isPrimaryKey: false;
700
+ isAutoincrement: false;
701
+ hasRuntimeDefault: false;
702
+ enumValues: [string, ...string[]];
703
+ baseColumn: never;
704
+ identity: undefined;
705
+ generated: undefined;
706
+ }, {}, {}>;
707
+ providerId: import("drizzle-orm/pg-core").PgColumn<{
708
+ name: "provider_id";
709
+ tableName: "account";
710
+ dataType: "string";
711
+ columnType: "PgText";
712
+ data: string;
713
+ driverParam: string;
714
+ notNull: true;
715
+ hasDefault: false;
716
+ isPrimaryKey: false;
717
+ isAutoincrement: false;
718
+ hasRuntimeDefault: false;
719
+ enumValues: [string, ...string[]];
720
+ baseColumn: never;
721
+ identity: undefined;
722
+ generated: undefined;
723
+ }, {}, {}>;
724
+ userId: import("drizzle-orm/pg-core").PgColumn<{
725
+ name: "user_id";
726
+ tableName: "account";
727
+ dataType: "string";
728
+ columnType: "PgText";
729
+ data: string;
730
+ driverParam: string;
731
+ notNull: true;
732
+ hasDefault: false;
733
+ isPrimaryKey: false;
734
+ isAutoincrement: false;
735
+ hasRuntimeDefault: false;
736
+ enumValues: [string, ...string[]];
737
+ baseColumn: never;
738
+ identity: undefined;
739
+ generated: undefined;
740
+ }, {}, {}>;
741
+ accessToken: import("drizzle-orm/pg-core").PgColumn<{
742
+ name: "access_token";
743
+ tableName: "account";
744
+ dataType: "string";
745
+ columnType: "PgText";
746
+ data: string;
747
+ driverParam: string;
748
+ notNull: false;
749
+ hasDefault: false;
750
+ isPrimaryKey: false;
751
+ isAutoincrement: false;
752
+ hasRuntimeDefault: false;
753
+ enumValues: [string, ...string[]];
754
+ baseColumn: never;
755
+ identity: undefined;
756
+ generated: undefined;
757
+ }, {}, {}>;
758
+ refreshToken: import("drizzle-orm/pg-core").PgColumn<{
759
+ name: "refresh_token";
760
+ tableName: "account";
761
+ dataType: "string";
762
+ columnType: "PgText";
763
+ data: string;
764
+ driverParam: string;
765
+ notNull: false;
766
+ hasDefault: false;
767
+ isPrimaryKey: false;
768
+ isAutoincrement: false;
769
+ hasRuntimeDefault: false;
770
+ enumValues: [string, ...string[]];
771
+ baseColumn: never;
772
+ identity: undefined;
773
+ generated: undefined;
774
+ }, {}, {}>;
775
+ idToken: import("drizzle-orm/pg-core").PgColumn<{
776
+ name: "id_token";
777
+ tableName: "account";
778
+ dataType: "string";
779
+ columnType: "PgText";
780
+ data: string;
781
+ driverParam: string;
782
+ notNull: false;
783
+ hasDefault: false;
784
+ isPrimaryKey: false;
785
+ isAutoincrement: false;
786
+ hasRuntimeDefault: false;
787
+ enumValues: [string, ...string[]];
788
+ baseColumn: never;
789
+ identity: undefined;
790
+ generated: undefined;
791
+ }, {}, {}>;
792
+ accessTokenExpiresAt: import("drizzle-orm/pg-core").PgColumn<{
793
+ name: "access_token_expires_at";
794
+ tableName: "account";
795
+ dataType: "date";
796
+ columnType: "PgTimestamp";
797
+ data: Date;
798
+ driverParam: string;
799
+ notNull: false;
800
+ hasDefault: false;
801
+ isPrimaryKey: false;
802
+ isAutoincrement: false;
803
+ hasRuntimeDefault: false;
804
+ enumValues: undefined;
805
+ baseColumn: never;
806
+ identity: undefined;
807
+ generated: undefined;
808
+ }, {}, {}>;
809
+ refreshTokenExpiresAt: import("drizzle-orm/pg-core").PgColumn<{
810
+ name: "refresh_token_expires_at";
811
+ tableName: "account";
812
+ dataType: "date";
813
+ columnType: "PgTimestamp";
814
+ data: Date;
815
+ driverParam: string;
816
+ notNull: false;
817
+ hasDefault: false;
818
+ isPrimaryKey: false;
819
+ isAutoincrement: false;
820
+ hasRuntimeDefault: false;
821
+ enumValues: undefined;
822
+ baseColumn: never;
823
+ identity: undefined;
824
+ generated: undefined;
825
+ }, {}, {}>;
826
+ scope: import("drizzle-orm/pg-core").PgColumn<{
827
+ name: "scope";
828
+ tableName: "account";
829
+ dataType: "string";
830
+ columnType: "PgText";
831
+ data: string;
832
+ driverParam: string;
833
+ notNull: false;
834
+ hasDefault: false;
835
+ isPrimaryKey: false;
836
+ isAutoincrement: false;
837
+ hasRuntimeDefault: false;
838
+ enumValues: [string, ...string[]];
839
+ baseColumn: never;
840
+ identity: undefined;
841
+ generated: undefined;
842
+ }, {}, {}>;
843
+ password: import("drizzle-orm/pg-core").PgColumn<{
844
+ name: "password";
845
+ tableName: "account";
846
+ dataType: "string";
847
+ columnType: "PgText";
848
+ data: string;
849
+ driverParam: string;
850
+ notNull: false;
851
+ hasDefault: false;
852
+ isPrimaryKey: false;
853
+ isAutoincrement: false;
854
+ hasRuntimeDefault: false;
855
+ enumValues: [string, ...string[]];
856
+ baseColumn: never;
857
+ identity: undefined;
858
+ generated: undefined;
859
+ }, {}, {}>;
860
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
861
+ name: "created_at";
862
+ tableName: "account";
863
+ dataType: "date";
864
+ columnType: "PgTimestamp";
865
+ data: Date;
866
+ driverParam: string;
867
+ notNull: true;
868
+ hasDefault: false;
869
+ isPrimaryKey: false;
870
+ isAutoincrement: false;
871
+ hasRuntimeDefault: false;
872
+ enumValues: undefined;
873
+ baseColumn: never;
874
+ identity: undefined;
875
+ generated: undefined;
876
+ }, {}, {}>;
877
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
878
+ name: "updated_at";
879
+ tableName: "account";
880
+ dataType: "date";
881
+ columnType: "PgTimestamp";
882
+ data: Date;
883
+ driverParam: string;
884
+ notNull: true;
885
+ hasDefault: false;
886
+ isPrimaryKey: false;
887
+ isAutoincrement: false;
888
+ hasRuntimeDefault: false;
889
+ enumValues: undefined;
890
+ baseColumn: never;
891
+ identity: undefined;
892
+ generated: undefined;
893
+ }, {}, {}>;
894
+ };
895
+ dialect: "pg";
896
+ }>;
897
+ verification: import("drizzle-orm/pg-core").PgTableWithColumns<{
898
+ name: "verification";
899
+ schema: undefined;
900
+ columns: {
901
+ id: import("drizzle-orm/pg-core").PgColumn<{
902
+ name: "id";
903
+ tableName: "verification";
904
+ dataType: "string";
905
+ columnType: "PgText";
906
+ data: string;
907
+ driverParam: string;
908
+ notNull: true;
909
+ hasDefault: false;
910
+ isPrimaryKey: true;
911
+ isAutoincrement: false;
912
+ hasRuntimeDefault: false;
913
+ enumValues: [string, ...string[]];
914
+ baseColumn: never;
915
+ identity: undefined;
916
+ generated: undefined;
917
+ }, {}, {}>;
918
+ identifier: import("drizzle-orm/pg-core").PgColumn<{
919
+ name: "identifier";
920
+ tableName: "verification";
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
+ value: import("drizzle-orm/pg-core").PgColumn<{
936
+ name: "value";
937
+ tableName: "verification";
938
+ dataType: "string";
939
+ columnType: "PgText";
940
+ data: string;
941
+ driverParam: string;
942
+ notNull: true;
943
+ hasDefault: false;
944
+ isPrimaryKey: false;
945
+ isAutoincrement: false;
946
+ hasRuntimeDefault: false;
947
+ enumValues: [string, ...string[]];
948
+ baseColumn: never;
949
+ identity: undefined;
950
+ generated: undefined;
951
+ }, {}, {}>;
952
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
953
+ name: "expires_at";
954
+ tableName: "verification";
955
+ dataType: "date";
956
+ columnType: "PgTimestamp";
957
+ data: Date;
958
+ driverParam: string;
959
+ notNull: true;
960
+ hasDefault: false;
961
+ isPrimaryKey: false;
962
+ isAutoincrement: false;
963
+ hasRuntimeDefault: false;
964
+ enumValues: undefined;
965
+ baseColumn: never;
966
+ identity: undefined;
967
+ generated: undefined;
968
+ }, {}, {}>;
969
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
970
+ name: "created_at";
971
+ tableName: "verification";
972
+ dataType: "date";
973
+ columnType: "PgTimestamp";
974
+ data: Date;
975
+ driverParam: string;
976
+ notNull: false;
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: "verification";
989
+ dataType: "date";
990
+ columnType: "PgTimestamp";
991
+ data: Date;
992
+ driverParam: string;
993
+ notNull: false;
994
+ hasDefault: false;
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
+ twoFactor: import("drizzle-orm/pg-core").PgTableWithColumns<{
1007
+ name: "twoFactor";
1008
+ schema: undefined;
1009
+ columns: {
1010
+ id: import("drizzle-orm/pg-core").PgColumn<{
1011
+ name: "id";
1012
+ tableName: "twoFactor";
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
+ userId: import("drizzle-orm/pg-core").PgColumn<{
1028
+ name: "user_id";
1029
+ tableName: "twoFactor";
1030
+ dataType: "string";
1031
+ columnType: "PgText";
1032
+ data: string;
1033
+ driverParam: string;
1034
+ notNull: true;
1035
+ hasDefault: false;
1036
+ isPrimaryKey: false;
1037
+ isAutoincrement: false;
1038
+ hasRuntimeDefault: false;
1039
+ enumValues: [string, ...string[]];
1040
+ baseColumn: never;
1041
+ identity: undefined;
1042
+ generated: undefined;
1043
+ }, {}, {}>;
1044
+ secret: import("drizzle-orm/pg-core").PgColumn<{
1045
+ name: "secret";
1046
+ tableName: "twoFactor";
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
+ backupCodes: import("drizzle-orm/pg-core").PgColumn<{
1062
+ name: "backup_codes";
1063
+ tableName: "twoFactor";
1064
+ dataType: "string";
1065
+ columnType: "PgText";
1066
+ data: string;
1067
+ driverParam: string;
1068
+ notNull: true;
1069
+ hasDefault: false;
1070
+ isPrimaryKey: false;
1071
+ isAutoincrement: false;
1072
+ hasRuntimeDefault: false;
1073
+ enumValues: [string, ...string[]];
1074
+ baseColumn: never;
1075
+ identity: undefined;
1076
+ generated: undefined;
1077
+ }, {}, {}>;
1078
+ verified: import("drizzle-orm/pg-core").PgColumn<{
1079
+ name: "verified";
1080
+ tableName: "twoFactor";
1081
+ dataType: "boolean";
1082
+ columnType: "PgBoolean";
1083
+ data: boolean;
1084
+ driverParam: boolean;
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
+ failedVerificationCount: import("drizzle-orm/pg-core").PgColumn<{
1096
+ name: "failed_verification_count";
1097
+ tableName: "twoFactor";
1098
+ dataType: "number";
1099
+ columnType: "PgInteger";
1100
+ data: number;
1101
+ driverParam: string | number;
1102
+ notNull: true;
1103
+ hasDefault: true;
1104
+ isPrimaryKey: false;
1105
+ isAutoincrement: false;
1106
+ hasRuntimeDefault: false;
1107
+ enumValues: undefined;
1108
+ baseColumn: never;
1109
+ identity: undefined;
1110
+ generated: undefined;
1111
+ }, {}, {}>;
1112
+ lockedUntil: import("drizzle-orm/pg-core").PgColumn<{
1113
+ name: "locked_until";
1114
+ tableName: "twoFactor";
1115
+ dataType: "date";
1116
+ columnType: "PgTimestamp";
1117
+ data: Date;
1118
+ driverParam: string;
1119
+ notNull: false;
1120
+ hasDefault: false;
1121
+ isPrimaryKey: false;
1122
+ isAutoincrement: false;
1123
+ hasRuntimeDefault: false;
1124
+ enumValues: undefined;
1125
+ baseColumn: never;
1126
+ identity: undefined;
1127
+ generated: undefined;
1128
+ }, {}, {}>;
1129
+ };
1130
+ dialect: "pg";
1131
+ }>;
1132
+ rateLimit: import("drizzle-orm/pg-core").PgTableWithColumns<{
1133
+ name: "rate_limit";
1134
+ schema: undefined;
1135
+ columns: {
1136
+ id: import("drizzle-orm/pg-core").PgColumn<{
1137
+ name: "id";
1138
+ tableName: "rate_limit";
1139
+ dataType: "string";
1140
+ columnType: "PgText";
1141
+ data: string;
1142
+ driverParam: string;
1143
+ notNull: true;
1144
+ hasDefault: false;
1145
+ isPrimaryKey: true;
1146
+ isAutoincrement: false;
1147
+ hasRuntimeDefault: false;
1148
+ enumValues: [string, ...string[]];
1149
+ baseColumn: never;
1150
+ identity: undefined;
1151
+ generated: undefined;
1152
+ }, {}, {}>;
1153
+ key: import("drizzle-orm/pg-core").PgColumn<{
1154
+ name: "key";
1155
+ tableName: "rate_limit";
1156
+ dataType: "string";
1157
+ columnType: "PgText";
1158
+ data: string;
1159
+ driverParam: string;
1160
+ notNull: true;
1161
+ hasDefault: false;
1162
+ isPrimaryKey: false;
1163
+ isAutoincrement: false;
1164
+ hasRuntimeDefault: false;
1165
+ enumValues: [string, ...string[]];
1166
+ baseColumn: never;
1167
+ identity: undefined;
1168
+ generated: undefined;
1169
+ }, {}, {}>;
1170
+ count: import("drizzle-orm/pg-core").PgColumn<{
1171
+ name: "count";
1172
+ tableName: "rate_limit";
1173
+ dataType: "number";
1174
+ columnType: "PgInteger";
1175
+ data: number;
1176
+ driverParam: string | number;
1177
+ notNull: true;
1178
+ hasDefault: false;
1179
+ isPrimaryKey: false;
1180
+ isAutoincrement: false;
1181
+ hasRuntimeDefault: false;
1182
+ enumValues: undefined;
1183
+ baseColumn: never;
1184
+ identity: undefined;
1185
+ generated: undefined;
1186
+ }, {}, {}>;
1187
+ lastRequest: import("drizzle-orm/pg-core").PgColumn<{
1188
+ name: "last_request";
1189
+ tableName: "rate_limit";
1190
+ dataType: "number";
1191
+ columnType: "PgBigInt53";
1192
+ data: number;
1193
+ driverParam: string | number;
1194
+ notNull: true;
1195
+ hasDefault: false;
1196
+ isPrimaryKey: false;
1197
+ isAutoincrement: false;
1198
+ hasRuntimeDefault: false;
1199
+ enumValues: undefined;
1200
+ baseColumn: never;
1201
+ identity: undefined;
1202
+ generated: undefined;
1203
+ }, {}, {}>;
1204
+ };
1205
+ dialect: "pg";
1206
+ }>;
1207
+ einladung: import("drizzle-orm/pg-core").PgTableWithColumns<{
1208
+ name: "einladung";
1209
+ schema: undefined;
1210
+ columns: {
1211
+ id: import("drizzle-orm/pg-core").PgColumn<{
1212
+ name: "id";
1213
+ tableName: "einladung";
1214
+ dataType: "string";
1215
+ columnType: "PgText";
1216
+ data: string;
1217
+ driverParam: string;
1218
+ notNull: true;
1219
+ hasDefault: false;
1220
+ isPrimaryKey: true;
1221
+ isAutoincrement: false;
1222
+ hasRuntimeDefault: false;
1223
+ enumValues: [string, ...string[]];
1224
+ baseColumn: never;
1225
+ identity: undefined;
1226
+ generated: undefined;
1227
+ }, {}, {}>;
1228
+ tokenHash: import("drizzle-orm/pg-core").PgColumn<{
1229
+ name: "token_hash";
1230
+ tableName: "einladung";
1231
+ dataType: "string";
1232
+ columnType: "PgText";
1233
+ data: string;
1234
+ driverParam: string;
1235
+ notNull: true;
1236
+ hasDefault: false;
1237
+ isPrimaryKey: false;
1238
+ isAutoincrement: false;
1239
+ hasRuntimeDefault: false;
1240
+ enumValues: [string, ...string[]];
1241
+ baseColumn: never;
1242
+ identity: undefined;
1243
+ generated: undefined;
1244
+ }, {}, {}>;
1245
+ createdBy: import("drizzle-orm/pg-core").PgColumn<{
1246
+ name: "created_by";
1247
+ tableName: "einladung";
1248
+ dataType: "string";
1249
+ columnType: "PgText";
1250
+ data: string;
1251
+ driverParam: string;
1252
+ notNull: true;
1253
+ hasDefault: false;
1254
+ isPrimaryKey: false;
1255
+ isAutoincrement: false;
1256
+ hasRuntimeDefault: false;
1257
+ enumValues: [string, ...string[]];
1258
+ baseColumn: never;
1259
+ identity: undefined;
1260
+ generated: undefined;
1261
+ }, {}, {}>;
1262
+ email: import("drizzle-orm/pg-core").PgColumn<{
1263
+ name: "email";
1264
+ tableName: "einladung";
1265
+ dataType: "string";
1266
+ columnType: "PgText";
1267
+ data: string;
1268
+ driverParam: string;
1269
+ notNull: false;
1270
+ hasDefault: false;
1271
+ isPrimaryKey: false;
1272
+ isAutoincrement: false;
1273
+ hasRuntimeDefault: false;
1274
+ enumValues: [string, ...string[]];
1275
+ baseColumn: never;
1276
+ identity: undefined;
1277
+ generated: undefined;
1278
+ }, {}, {}>;
1279
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
1280
+ name: "expires_at";
1281
+ tableName: "einladung";
1282
+ dataType: "date";
1283
+ columnType: "PgTimestamp";
1284
+ data: Date;
1285
+ driverParam: string;
1286
+ notNull: true;
1287
+ hasDefault: false;
1288
+ isPrimaryKey: false;
1289
+ isAutoincrement: false;
1290
+ hasRuntimeDefault: false;
1291
+ enumValues: undefined;
1292
+ baseColumn: never;
1293
+ identity: undefined;
1294
+ generated: undefined;
1295
+ }, {}, {}>;
1296
+ acceptedAt: import("drizzle-orm/pg-core").PgColumn<{
1297
+ name: "accepted_at";
1298
+ tableName: "einladung";
1299
+ dataType: "date";
1300
+ columnType: "PgTimestamp";
1301
+ data: Date;
1302
+ driverParam: string;
1303
+ notNull: false;
1304
+ hasDefault: false;
1305
+ isPrimaryKey: false;
1306
+ isAutoincrement: false;
1307
+ hasRuntimeDefault: false;
1308
+ enumValues: undefined;
1309
+ baseColumn: never;
1310
+ identity: undefined;
1311
+ generated: undefined;
1312
+ }, {}, {}>;
1313
+ acceptedBy: import("drizzle-orm/pg-core").PgColumn<{
1314
+ name: "accepted_by";
1315
+ tableName: "einladung";
1316
+ dataType: "string";
1317
+ columnType: "PgText";
1318
+ data: string;
1319
+ driverParam: string;
1320
+ notNull: false;
1321
+ hasDefault: false;
1322
+ isPrimaryKey: false;
1323
+ isAutoincrement: false;
1324
+ hasRuntimeDefault: false;
1325
+ enumValues: [string, ...string[]];
1326
+ baseColumn: never;
1327
+ identity: undefined;
1328
+ generated: undefined;
1329
+ }, {}, {}>;
1330
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1331
+ name: "created_at";
1332
+ tableName: "einladung";
1333
+ dataType: "date";
1334
+ columnType: "PgTimestamp";
1335
+ data: Date;
1336
+ driverParam: string;
1337
+ notNull: true;
1338
+ hasDefault: true;
1339
+ isPrimaryKey: false;
1340
+ isAutoincrement: false;
1341
+ hasRuntimeDefault: false;
1342
+ enumValues: undefined;
1343
+ baseColumn: never;
1344
+ identity: undefined;
1345
+ generated: undefined;
1346
+ }, {}, {}>;
1347
+ };
1348
+ dialect: "pg";
1349
+ }>;
1350
+ };
1351
+ declare function buildMcp(user: UserTable, session: SessionTable): {
1352
+ jwks: import("drizzle-orm/pg-core").PgTableWithColumns<{
1353
+ name: "jwks";
1354
+ schema: undefined;
1355
+ columns: {
1356
+ id: import("drizzle-orm/pg-core").PgColumn<{
1357
+ name: "id";
1358
+ tableName: "jwks";
1359
+ dataType: "string";
1360
+ columnType: "PgText";
1361
+ data: string;
1362
+ driverParam: string;
1363
+ notNull: true;
1364
+ hasDefault: false;
1365
+ isPrimaryKey: true;
1366
+ isAutoincrement: false;
1367
+ hasRuntimeDefault: false;
1368
+ enumValues: [string, ...string[]];
1369
+ baseColumn: never;
1370
+ identity: undefined;
1371
+ generated: undefined;
1372
+ }, {}, {}>;
1373
+ publicKey: import("drizzle-orm/pg-core").PgColumn<{
1374
+ name: "public_key";
1375
+ tableName: "jwks";
1376
+ dataType: "string";
1377
+ columnType: "PgText";
1378
+ data: string;
1379
+ driverParam: string;
1380
+ notNull: true;
1381
+ hasDefault: false;
1382
+ isPrimaryKey: false;
1383
+ isAutoincrement: false;
1384
+ hasRuntimeDefault: false;
1385
+ enumValues: [string, ...string[]];
1386
+ baseColumn: never;
1387
+ identity: undefined;
1388
+ generated: undefined;
1389
+ }, {}, {}>;
1390
+ privateKey: import("drizzle-orm/pg-core").PgColumn<{
1391
+ name: "private_key";
1392
+ tableName: "jwks";
1393
+ dataType: "string";
1394
+ columnType: "PgText";
1395
+ data: string;
1396
+ driverParam: string;
1397
+ notNull: true;
1398
+ hasDefault: false;
1399
+ isPrimaryKey: false;
1400
+ isAutoincrement: false;
1401
+ hasRuntimeDefault: false;
1402
+ enumValues: [string, ...string[]];
1403
+ baseColumn: never;
1404
+ identity: undefined;
1405
+ generated: undefined;
1406
+ }, {}, {}>;
1407
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1408
+ name: "created_at";
1409
+ tableName: "jwks";
1410
+ dataType: "date";
1411
+ columnType: "PgTimestamp";
1412
+ data: Date;
1413
+ driverParam: string;
1414
+ notNull: true;
1415
+ hasDefault: false;
1416
+ isPrimaryKey: false;
1417
+ isAutoincrement: false;
1418
+ hasRuntimeDefault: false;
1419
+ enumValues: undefined;
1420
+ baseColumn: never;
1421
+ identity: undefined;
1422
+ generated: undefined;
1423
+ }, {}, {}>;
1424
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
1425
+ name: "expires_at";
1426
+ tableName: "jwks";
1427
+ dataType: "date";
1428
+ columnType: "PgTimestamp";
1429
+ data: Date;
1430
+ driverParam: string;
1431
+ notNull: false;
1432
+ hasDefault: false;
1433
+ isPrimaryKey: false;
1434
+ isAutoincrement: false;
1435
+ hasRuntimeDefault: false;
1436
+ enumValues: undefined;
1437
+ baseColumn: never;
1438
+ identity: undefined;
1439
+ generated: undefined;
1440
+ }, {}, {}>;
1441
+ alg: import("drizzle-orm/pg-core").PgColumn<{
1442
+ name: "alg";
1443
+ tableName: "jwks";
1444
+ dataType: "string";
1445
+ columnType: "PgText";
1446
+ data: string;
1447
+ driverParam: string;
1448
+ notNull: false;
1449
+ hasDefault: false;
1450
+ isPrimaryKey: false;
1451
+ isAutoincrement: false;
1452
+ hasRuntimeDefault: false;
1453
+ enumValues: [string, ...string[]];
1454
+ baseColumn: never;
1455
+ identity: undefined;
1456
+ generated: undefined;
1457
+ }, {}, {}>;
1458
+ crv: import("drizzle-orm/pg-core").PgColumn<{
1459
+ name: "crv";
1460
+ tableName: "jwks";
1461
+ dataType: "string";
1462
+ columnType: "PgText";
1463
+ data: string;
1464
+ driverParam: string;
1465
+ notNull: false;
1466
+ hasDefault: false;
1467
+ isPrimaryKey: false;
1468
+ isAutoincrement: false;
1469
+ hasRuntimeDefault: false;
1470
+ enumValues: [string, ...string[]];
1471
+ baseColumn: never;
1472
+ identity: undefined;
1473
+ generated: undefined;
1474
+ }, {}, {}>;
1475
+ };
1476
+ dialect: "pg";
1477
+ }>;
1478
+ oauthClient: import("drizzle-orm/pg-core").PgTableWithColumns<{
1479
+ name: "oauth_client";
1480
+ schema: undefined;
1481
+ columns: {
1482
+ id: import("drizzle-orm/pg-core").PgColumn<{
1483
+ name: "id";
1484
+ tableName: "oauth_client";
1485
+ dataType: "string";
1486
+ columnType: "PgText";
1487
+ data: string;
1488
+ driverParam: string;
1489
+ notNull: true;
1490
+ hasDefault: false;
1491
+ isPrimaryKey: true;
1492
+ isAutoincrement: false;
1493
+ hasRuntimeDefault: false;
1494
+ enumValues: [string, ...string[]];
1495
+ baseColumn: never;
1496
+ identity: undefined;
1497
+ generated: undefined;
1498
+ }, {}, {}>;
1499
+ clientId: import("drizzle-orm/pg-core").PgColumn<{
1500
+ name: "client_id";
1501
+ tableName: "oauth_client";
1502
+ dataType: "string";
1503
+ columnType: "PgText";
1504
+ data: string;
1505
+ driverParam: string;
1506
+ notNull: true;
1507
+ hasDefault: false;
1508
+ isPrimaryKey: false;
1509
+ isAutoincrement: false;
1510
+ hasRuntimeDefault: false;
1511
+ enumValues: [string, ...string[]];
1512
+ baseColumn: never;
1513
+ identity: undefined;
1514
+ generated: undefined;
1515
+ }, {}, {}>;
1516
+ clientSecret: import("drizzle-orm/pg-core").PgColumn<{
1517
+ name: "client_secret";
1518
+ tableName: "oauth_client";
1519
+ dataType: "string";
1520
+ columnType: "PgText";
1521
+ data: string;
1522
+ driverParam: string;
1523
+ notNull: false;
1524
+ hasDefault: false;
1525
+ isPrimaryKey: false;
1526
+ isAutoincrement: false;
1527
+ hasRuntimeDefault: false;
1528
+ enumValues: [string, ...string[]];
1529
+ baseColumn: never;
1530
+ identity: undefined;
1531
+ generated: undefined;
1532
+ }, {}, {}>;
1533
+ clientDiscoveryId: import("drizzle-orm/pg-core").PgColumn<{
1534
+ name: "client_discovery_id";
1535
+ tableName: "oauth_client";
1536
+ dataType: "string";
1537
+ columnType: "PgText";
1538
+ data: string;
1539
+ driverParam: string;
1540
+ notNull: false;
1541
+ hasDefault: false;
1542
+ isPrimaryKey: false;
1543
+ isAutoincrement: false;
1544
+ hasRuntimeDefault: false;
1545
+ enumValues: [string, ...string[]];
1546
+ baseColumn: never;
1547
+ identity: undefined;
1548
+ generated: undefined;
1549
+ }, {}, {}>;
1550
+ disabled: import("drizzle-orm/pg-core").PgColumn<{
1551
+ name: "disabled";
1552
+ tableName: "oauth_client";
1553
+ dataType: "boolean";
1554
+ columnType: "PgBoolean";
1555
+ data: boolean;
1556
+ driverParam: boolean;
1557
+ notNull: false;
1558
+ hasDefault: true;
1559
+ isPrimaryKey: false;
1560
+ isAutoincrement: false;
1561
+ hasRuntimeDefault: false;
1562
+ enumValues: undefined;
1563
+ baseColumn: never;
1564
+ identity: undefined;
1565
+ generated: undefined;
1566
+ }, {}, {}>;
1567
+ skipConsent: import("drizzle-orm/pg-core").PgColumn<{
1568
+ name: "skip_consent";
1569
+ tableName: "oauth_client";
1570
+ dataType: "boolean";
1571
+ columnType: "PgBoolean";
1572
+ data: boolean;
1573
+ driverParam: boolean;
1574
+ notNull: false;
1575
+ hasDefault: false;
1576
+ isPrimaryKey: false;
1577
+ isAutoincrement: false;
1578
+ hasRuntimeDefault: false;
1579
+ enumValues: undefined;
1580
+ baseColumn: never;
1581
+ identity: undefined;
1582
+ generated: undefined;
1583
+ }, {}, {}>;
1584
+ enableEndSession: import("drizzle-orm/pg-core").PgColumn<{
1585
+ name: "enable_end_session";
1586
+ tableName: "oauth_client";
1587
+ dataType: "boolean";
1588
+ columnType: "PgBoolean";
1589
+ data: boolean;
1590
+ driverParam: boolean;
1591
+ notNull: false;
1592
+ hasDefault: false;
1593
+ isPrimaryKey: false;
1594
+ isAutoincrement: false;
1595
+ hasRuntimeDefault: false;
1596
+ enumValues: undefined;
1597
+ baseColumn: never;
1598
+ identity: undefined;
1599
+ generated: undefined;
1600
+ }, {}, {}>;
1601
+ subjectType: import("drizzle-orm/pg-core").PgColumn<{
1602
+ name: "subject_type";
1603
+ tableName: "oauth_client";
1604
+ dataType: "string";
1605
+ columnType: "PgText";
1606
+ data: string;
1607
+ driverParam: string;
1608
+ notNull: false;
1609
+ hasDefault: false;
1610
+ isPrimaryKey: false;
1611
+ isAutoincrement: false;
1612
+ hasRuntimeDefault: false;
1613
+ enumValues: [string, ...string[]];
1614
+ baseColumn: never;
1615
+ identity: undefined;
1616
+ generated: undefined;
1617
+ }, {}, {}>;
1618
+ scopes: import("drizzle-orm/pg-core").PgColumn<{
1619
+ name: "scopes";
1620
+ tableName: "oauth_client";
1621
+ dataType: "array";
1622
+ columnType: "PgArray";
1623
+ data: string[];
1624
+ driverParam: string | string[];
1625
+ notNull: false;
1626
+ hasDefault: false;
1627
+ isPrimaryKey: false;
1628
+ isAutoincrement: false;
1629
+ hasRuntimeDefault: false;
1630
+ enumValues: [string, ...string[]];
1631
+ baseColumn: import("drizzle-orm").Column<{
1632
+ name: "scopes";
1633
+ tableName: "oauth_client";
1634
+ dataType: "string";
1635
+ columnType: "PgText";
1636
+ data: string;
1637
+ driverParam: string;
1638
+ notNull: false;
1639
+ hasDefault: false;
1640
+ isPrimaryKey: false;
1641
+ isAutoincrement: false;
1642
+ hasRuntimeDefault: false;
1643
+ enumValues: [string, ...string[]];
1644
+ baseColumn: never;
1645
+ identity: undefined;
1646
+ generated: undefined;
1647
+ }, {}, {}>;
1648
+ identity: undefined;
1649
+ generated: undefined;
1650
+ }, {}, {
1651
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
1652
+ name: "scopes";
1653
+ dataType: "string";
1654
+ columnType: "PgText";
1655
+ data: string;
1656
+ enumValues: [string, ...string[]];
1657
+ driverParam: string;
1658
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
1659
+ size: undefined;
1660
+ }>;
1661
+ clientCredentialsScopes: import("drizzle-orm/pg-core").PgColumn<{
1662
+ name: "client_credentials_scopes";
1663
+ tableName: "oauth_client";
1664
+ dataType: "array";
1665
+ columnType: "PgArray";
1666
+ data: string[];
1667
+ driverParam: string | string[];
1668
+ notNull: false;
1669
+ hasDefault: true;
1670
+ isPrimaryKey: false;
1671
+ isAutoincrement: false;
1672
+ hasRuntimeDefault: false;
1673
+ enumValues: [string, ...string[]];
1674
+ baseColumn: import("drizzle-orm").Column<{
1675
+ name: "client_credentials_scopes";
1676
+ tableName: "oauth_client";
1677
+ dataType: "string";
1678
+ columnType: "PgText";
1679
+ data: string;
1680
+ driverParam: string;
1681
+ notNull: false;
1682
+ hasDefault: false;
1683
+ isPrimaryKey: false;
1684
+ isAutoincrement: false;
1685
+ hasRuntimeDefault: false;
1686
+ enumValues: [string, ...string[]];
1687
+ baseColumn: never;
1688
+ identity: undefined;
1689
+ generated: undefined;
1690
+ }, {}, {}>;
1691
+ identity: undefined;
1692
+ generated: undefined;
1693
+ }, {}, {
1694
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
1695
+ name: "client_credentials_scopes";
1696
+ dataType: "string";
1697
+ columnType: "PgText";
1698
+ data: string;
1699
+ enumValues: [string, ...string[]];
1700
+ driverParam: string;
1701
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
1702
+ size: undefined;
1703
+ }>;
1704
+ userId: import("drizzle-orm/pg-core").PgColumn<{
1705
+ name: "user_id";
1706
+ tableName: "oauth_client";
1707
+ dataType: "string";
1708
+ columnType: "PgText";
1709
+ data: string;
1710
+ driverParam: string;
1711
+ notNull: false;
1712
+ hasDefault: false;
1713
+ isPrimaryKey: false;
1714
+ isAutoincrement: false;
1715
+ hasRuntimeDefault: false;
1716
+ enumValues: [string, ...string[]];
1717
+ baseColumn: never;
1718
+ identity: undefined;
1719
+ generated: undefined;
1720
+ }, {}, {}>;
1721
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1722
+ name: "created_at";
1723
+ tableName: "oauth_client";
1724
+ dataType: "date";
1725
+ columnType: "PgTimestamp";
1726
+ data: Date;
1727
+ driverParam: string;
1728
+ notNull: false;
1729
+ hasDefault: false;
1730
+ isPrimaryKey: false;
1731
+ isAutoincrement: false;
1732
+ hasRuntimeDefault: false;
1733
+ enumValues: undefined;
1734
+ baseColumn: never;
1735
+ identity: undefined;
1736
+ generated: undefined;
1737
+ }, {}, {}>;
1738
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1739
+ name: "updated_at";
1740
+ tableName: "oauth_client";
1741
+ dataType: "date";
1742
+ columnType: "PgTimestamp";
1743
+ data: Date;
1744
+ driverParam: string;
1745
+ notNull: false;
1746
+ hasDefault: false;
1747
+ isPrimaryKey: false;
1748
+ isAutoincrement: false;
1749
+ hasRuntimeDefault: false;
1750
+ enumValues: undefined;
1751
+ baseColumn: never;
1752
+ identity: undefined;
1753
+ generated: undefined;
1754
+ }, {}, {}>;
1755
+ name: import("drizzle-orm/pg-core").PgColumn<{
1756
+ name: "name";
1757
+ tableName: "oauth_client";
1758
+ dataType: "string";
1759
+ columnType: "PgText";
1760
+ data: string;
1761
+ driverParam: string;
1762
+ notNull: false;
1763
+ hasDefault: false;
1764
+ isPrimaryKey: false;
1765
+ isAutoincrement: false;
1766
+ hasRuntimeDefault: false;
1767
+ enumValues: [string, ...string[]];
1768
+ baseColumn: never;
1769
+ identity: undefined;
1770
+ generated: undefined;
1771
+ }, {}, {}>;
1772
+ uri: import("drizzle-orm/pg-core").PgColumn<{
1773
+ name: "uri";
1774
+ tableName: "oauth_client";
1775
+ dataType: "string";
1776
+ columnType: "PgText";
1777
+ data: string;
1778
+ driverParam: string;
1779
+ notNull: false;
1780
+ hasDefault: false;
1781
+ isPrimaryKey: false;
1782
+ isAutoincrement: false;
1783
+ hasRuntimeDefault: false;
1784
+ enumValues: [string, ...string[]];
1785
+ baseColumn: never;
1786
+ identity: undefined;
1787
+ generated: undefined;
1788
+ }, {}, {}>;
1789
+ icon: import("drizzle-orm/pg-core").PgColumn<{
1790
+ name: "icon";
1791
+ tableName: "oauth_client";
1792
+ dataType: "string";
1793
+ columnType: "PgText";
1794
+ data: string;
1795
+ driverParam: string;
1796
+ notNull: false;
1797
+ hasDefault: false;
1798
+ isPrimaryKey: false;
1799
+ isAutoincrement: false;
1800
+ hasRuntimeDefault: false;
1801
+ enumValues: [string, ...string[]];
1802
+ baseColumn: never;
1803
+ identity: undefined;
1804
+ generated: undefined;
1805
+ }, {}, {}>;
1806
+ contacts: import("drizzle-orm/pg-core").PgColumn<{
1807
+ name: "contacts";
1808
+ tableName: "oauth_client";
1809
+ dataType: "array";
1810
+ columnType: "PgArray";
1811
+ data: string[];
1812
+ driverParam: string | string[];
1813
+ notNull: false;
1814
+ hasDefault: false;
1815
+ isPrimaryKey: false;
1816
+ isAutoincrement: false;
1817
+ hasRuntimeDefault: false;
1818
+ enumValues: [string, ...string[]];
1819
+ baseColumn: import("drizzle-orm").Column<{
1820
+ name: "contacts";
1821
+ tableName: "oauth_client";
1822
+ dataType: "string";
1823
+ columnType: "PgText";
1824
+ data: string;
1825
+ driverParam: string;
1826
+ notNull: false;
1827
+ hasDefault: false;
1828
+ isPrimaryKey: false;
1829
+ isAutoincrement: false;
1830
+ hasRuntimeDefault: false;
1831
+ enumValues: [string, ...string[]];
1832
+ baseColumn: never;
1833
+ identity: undefined;
1834
+ generated: undefined;
1835
+ }, {}, {}>;
1836
+ identity: undefined;
1837
+ generated: undefined;
1838
+ }, {}, {
1839
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
1840
+ name: "contacts";
1841
+ dataType: "string";
1842
+ columnType: "PgText";
1843
+ data: string;
1844
+ enumValues: [string, ...string[]];
1845
+ driverParam: string;
1846
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
1847
+ size: undefined;
1848
+ }>;
1849
+ tos: import("drizzle-orm/pg-core").PgColumn<{
1850
+ name: "tos";
1851
+ tableName: "oauth_client";
1852
+ dataType: "string";
1853
+ columnType: "PgText";
1854
+ data: string;
1855
+ driverParam: string;
1856
+ notNull: false;
1857
+ hasDefault: false;
1858
+ isPrimaryKey: false;
1859
+ isAutoincrement: false;
1860
+ hasRuntimeDefault: false;
1861
+ enumValues: [string, ...string[]];
1862
+ baseColumn: never;
1863
+ identity: undefined;
1864
+ generated: undefined;
1865
+ }, {}, {}>;
1866
+ policy: import("drizzle-orm/pg-core").PgColumn<{
1867
+ name: "policy";
1868
+ tableName: "oauth_client";
1869
+ dataType: "string";
1870
+ columnType: "PgText";
1871
+ data: string;
1872
+ driverParam: string;
1873
+ notNull: false;
1874
+ hasDefault: false;
1875
+ isPrimaryKey: false;
1876
+ isAutoincrement: false;
1877
+ hasRuntimeDefault: false;
1878
+ enumValues: [string, ...string[]];
1879
+ baseColumn: never;
1880
+ identity: undefined;
1881
+ generated: undefined;
1882
+ }, {}, {}>;
1883
+ softwareId: import("drizzle-orm/pg-core").PgColumn<{
1884
+ name: "software_id";
1885
+ tableName: "oauth_client";
1886
+ dataType: "string";
1887
+ columnType: "PgText";
1888
+ data: string;
1889
+ driverParam: string;
1890
+ notNull: false;
1891
+ hasDefault: false;
1892
+ isPrimaryKey: false;
1893
+ isAutoincrement: false;
1894
+ hasRuntimeDefault: false;
1895
+ enumValues: [string, ...string[]];
1896
+ baseColumn: never;
1897
+ identity: undefined;
1898
+ generated: undefined;
1899
+ }, {}, {}>;
1900
+ softwareVersion: import("drizzle-orm/pg-core").PgColumn<{
1901
+ name: "software_version";
1902
+ tableName: "oauth_client";
1903
+ dataType: "string";
1904
+ columnType: "PgText";
1905
+ data: string;
1906
+ driverParam: string;
1907
+ notNull: false;
1908
+ hasDefault: false;
1909
+ isPrimaryKey: false;
1910
+ isAutoincrement: false;
1911
+ hasRuntimeDefault: false;
1912
+ enumValues: [string, ...string[]];
1913
+ baseColumn: never;
1914
+ identity: undefined;
1915
+ generated: undefined;
1916
+ }, {}, {}>;
1917
+ softwareStatement: import("drizzle-orm/pg-core").PgColumn<{
1918
+ name: "software_statement";
1919
+ tableName: "oauth_client";
1920
+ dataType: "string";
1921
+ columnType: "PgText";
1922
+ data: string;
1923
+ driverParam: string;
1924
+ notNull: false;
1925
+ hasDefault: false;
1926
+ isPrimaryKey: false;
1927
+ isAutoincrement: false;
1928
+ hasRuntimeDefault: false;
1929
+ enumValues: [string, ...string[]];
1930
+ baseColumn: never;
1931
+ identity: undefined;
1932
+ generated: undefined;
1933
+ }, {}, {}>;
1934
+ redirectUris: import("drizzle-orm/pg-core").PgColumn<{
1935
+ name: "redirect_uris";
1936
+ tableName: "oauth_client";
1937
+ dataType: "array";
1938
+ columnType: "PgArray";
1939
+ data: string[];
1940
+ driverParam: string | string[];
1941
+ notNull: true;
1942
+ hasDefault: false;
1943
+ isPrimaryKey: false;
1944
+ isAutoincrement: false;
1945
+ hasRuntimeDefault: false;
1946
+ enumValues: [string, ...string[]];
1947
+ baseColumn: import("drizzle-orm").Column<{
1948
+ name: "redirect_uris";
1949
+ tableName: "oauth_client";
1950
+ dataType: "string";
1951
+ columnType: "PgText";
1952
+ data: string;
1953
+ driverParam: string;
1954
+ notNull: false;
1955
+ hasDefault: false;
1956
+ isPrimaryKey: false;
1957
+ isAutoincrement: false;
1958
+ hasRuntimeDefault: false;
1959
+ enumValues: [string, ...string[]];
1960
+ baseColumn: never;
1961
+ identity: undefined;
1962
+ generated: undefined;
1963
+ }, {}, {}>;
1964
+ identity: undefined;
1965
+ generated: undefined;
1966
+ }, {}, {
1967
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
1968
+ name: "redirect_uris";
1969
+ dataType: "string";
1970
+ columnType: "PgText";
1971
+ data: string;
1972
+ enumValues: [string, ...string[]];
1973
+ driverParam: string;
1974
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
1975
+ size: undefined;
1976
+ }>;
1977
+ postLogoutRedirectUris: import("drizzle-orm/pg-core").PgColumn<{
1978
+ name: "post_logout_redirect_uris";
1979
+ tableName: "oauth_client";
1980
+ dataType: "array";
1981
+ columnType: "PgArray";
1982
+ data: string[];
1983
+ driverParam: string | string[];
1984
+ notNull: false;
1985
+ hasDefault: false;
1986
+ isPrimaryKey: false;
1987
+ isAutoincrement: false;
1988
+ hasRuntimeDefault: false;
1989
+ enumValues: [string, ...string[]];
1990
+ baseColumn: import("drizzle-orm").Column<{
1991
+ name: "post_logout_redirect_uris";
1992
+ tableName: "oauth_client";
1993
+ dataType: "string";
1994
+ columnType: "PgText";
1995
+ data: string;
1996
+ driverParam: string;
1997
+ notNull: false;
1998
+ hasDefault: false;
1999
+ isPrimaryKey: false;
2000
+ isAutoincrement: false;
2001
+ hasRuntimeDefault: false;
2002
+ enumValues: [string, ...string[]];
2003
+ baseColumn: never;
2004
+ identity: undefined;
2005
+ generated: undefined;
2006
+ }, {}, {}>;
2007
+ identity: undefined;
2008
+ generated: undefined;
2009
+ }, {}, {
2010
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
2011
+ name: "post_logout_redirect_uris";
2012
+ dataType: "string";
2013
+ columnType: "PgText";
2014
+ data: string;
2015
+ enumValues: [string, ...string[]];
2016
+ driverParam: string;
2017
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
2018
+ size: undefined;
2019
+ }>;
2020
+ backchannelLogoutUri: import("drizzle-orm/pg-core").PgColumn<{
2021
+ name: "backchannel_logout_uri";
2022
+ tableName: "oauth_client";
2023
+ dataType: "string";
2024
+ columnType: "PgText";
2025
+ data: string;
2026
+ driverParam: string;
2027
+ notNull: false;
2028
+ hasDefault: false;
2029
+ isPrimaryKey: false;
2030
+ isAutoincrement: false;
2031
+ hasRuntimeDefault: false;
2032
+ enumValues: [string, ...string[]];
2033
+ baseColumn: never;
2034
+ identity: undefined;
2035
+ generated: undefined;
2036
+ }, {}, {}>;
2037
+ backchannelLogoutSessionRequired: import("drizzle-orm/pg-core").PgColumn<{
2038
+ name: "backchannel_logout_session_required";
2039
+ tableName: "oauth_client";
2040
+ dataType: "boolean";
2041
+ columnType: "PgBoolean";
2042
+ data: boolean;
2043
+ driverParam: boolean;
2044
+ notNull: false;
2045
+ hasDefault: false;
2046
+ isPrimaryKey: false;
2047
+ isAutoincrement: false;
2048
+ hasRuntimeDefault: false;
2049
+ enumValues: undefined;
2050
+ baseColumn: never;
2051
+ identity: undefined;
2052
+ generated: undefined;
2053
+ }, {}, {}>;
2054
+ tokenEndpointAuthMethod: import("drizzle-orm/pg-core").PgColumn<{
2055
+ name: "token_endpoint_auth_method";
2056
+ tableName: "oauth_client";
2057
+ dataType: "string";
2058
+ columnType: "PgText";
2059
+ data: string;
2060
+ driverParam: string;
2061
+ notNull: false;
2062
+ hasDefault: false;
2063
+ isPrimaryKey: false;
2064
+ isAutoincrement: false;
2065
+ hasRuntimeDefault: false;
2066
+ enumValues: [string, ...string[]];
2067
+ baseColumn: never;
2068
+ identity: undefined;
2069
+ generated: undefined;
2070
+ }, {}, {}>;
2071
+ applicationType: import("drizzle-orm/pg-core").PgColumn<{
2072
+ name: "application_type";
2073
+ tableName: "oauth_client";
2074
+ dataType: "string";
2075
+ columnType: "PgText";
2076
+ data: string;
2077
+ driverParam: string;
2078
+ notNull: false;
2079
+ hasDefault: false;
2080
+ isPrimaryKey: false;
2081
+ isAutoincrement: false;
2082
+ hasRuntimeDefault: false;
2083
+ enumValues: [string, ...string[]];
2084
+ baseColumn: never;
2085
+ identity: undefined;
2086
+ generated: undefined;
2087
+ }, {}, {}>;
2088
+ jwks: import("drizzle-orm/pg-core").PgColumn<{
2089
+ name: "jwks";
2090
+ tableName: "oauth_client";
2091
+ dataType: "string";
2092
+ columnType: "PgText";
2093
+ data: string;
2094
+ driverParam: string;
2095
+ notNull: false;
2096
+ hasDefault: false;
2097
+ isPrimaryKey: false;
2098
+ isAutoincrement: false;
2099
+ hasRuntimeDefault: false;
2100
+ enumValues: [string, ...string[]];
2101
+ baseColumn: never;
2102
+ identity: undefined;
2103
+ generated: undefined;
2104
+ }, {}, {}>;
2105
+ jwksUri: import("drizzle-orm/pg-core").PgColumn<{
2106
+ name: "jwks_uri";
2107
+ tableName: "oauth_client";
2108
+ dataType: "string";
2109
+ columnType: "PgText";
2110
+ data: string;
2111
+ driverParam: string;
2112
+ notNull: false;
2113
+ hasDefault: false;
2114
+ isPrimaryKey: false;
2115
+ isAutoincrement: false;
2116
+ hasRuntimeDefault: false;
2117
+ enumValues: [string, ...string[]];
2118
+ baseColumn: never;
2119
+ identity: undefined;
2120
+ generated: undefined;
2121
+ }, {}, {}>;
2122
+ grantTypes: import("drizzle-orm/pg-core").PgColumn<{
2123
+ name: "grant_types";
2124
+ tableName: "oauth_client";
2125
+ dataType: "array";
2126
+ columnType: "PgArray";
2127
+ data: string[];
2128
+ driverParam: string | string[];
2129
+ notNull: false;
2130
+ hasDefault: false;
2131
+ isPrimaryKey: false;
2132
+ isAutoincrement: false;
2133
+ hasRuntimeDefault: false;
2134
+ enumValues: [string, ...string[]];
2135
+ baseColumn: import("drizzle-orm").Column<{
2136
+ name: "grant_types";
2137
+ tableName: "oauth_client";
2138
+ dataType: "string";
2139
+ columnType: "PgText";
2140
+ data: string;
2141
+ driverParam: string;
2142
+ notNull: false;
2143
+ hasDefault: false;
2144
+ isPrimaryKey: false;
2145
+ isAutoincrement: false;
2146
+ hasRuntimeDefault: false;
2147
+ enumValues: [string, ...string[]];
2148
+ baseColumn: never;
2149
+ identity: undefined;
2150
+ generated: undefined;
2151
+ }, {}, {}>;
2152
+ identity: undefined;
2153
+ generated: undefined;
2154
+ }, {}, {
2155
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
2156
+ name: "grant_types";
2157
+ dataType: "string";
2158
+ columnType: "PgText";
2159
+ data: string;
2160
+ enumValues: [string, ...string[]];
2161
+ driverParam: string;
2162
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
2163
+ size: undefined;
2164
+ }>;
2165
+ responseTypes: import("drizzle-orm/pg-core").PgColumn<{
2166
+ name: "response_types";
2167
+ tableName: "oauth_client";
2168
+ dataType: "array";
2169
+ columnType: "PgArray";
2170
+ data: string[];
2171
+ driverParam: string | string[];
2172
+ notNull: false;
2173
+ hasDefault: false;
2174
+ isPrimaryKey: false;
2175
+ isAutoincrement: false;
2176
+ hasRuntimeDefault: false;
2177
+ enumValues: [string, ...string[]];
2178
+ baseColumn: import("drizzle-orm").Column<{
2179
+ name: "response_types";
2180
+ tableName: "oauth_client";
2181
+ dataType: "string";
2182
+ columnType: "PgText";
2183
+ data: string;
2184
+ driverParam: string;
2185
+ notNull: false;
2186
+ hasDefault: false;
2187
+ isPrimaryKey: false;
2188
+ isAutoincrement: false;
2189
+ hasRuntimeDefault: false;
2190
+ enumValues: [string, ...string[]];
2191
+ baseColumn: never;
2192
+ identity: undefined;
2193
+ generated: undefined;
2194
+ }, {}, {}>;
2195
+ identity: undefined;
2196
+ generated: undefined;
2197
+ }, {}, {
2198
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
2199
+ name: "response_types";
2200
+ dataType: "string";
2201
+ columnType: "PgText";
2202
+ data: string;
2203
+ enumValues: [string, ...string[]];
2204
+ driverParam: string;
2205
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
2206
+ size: undefined;
2207
+ }>;
2208
+ requirePKCE: import("drizzle-orm/pg-core").PgColumn<{
2209
+ name: "require_pkce";
2210
+ tableName: "oauth_client";
2211
+ dataType: "boolean";
2212
+ columnType: "PgBoolean";
2213
+ data: boolean;
2214
+ driverParam: boolean;
2215
+ notNull: false;
2216
+ hasDefault: false;
2217
+ isPrimaryKey: false;
2218
+ isAutoincrement: false;
2219
+ hasRuntimeDefault: false;
2220
+ enumValues: undefined;
2221
+ baseColumn: never;
2222
+ identity: undefined;
2223
+ generated: undefined;
2224
+ }, {}, {}>;
2225
+ dpopBoundAccessTokens: import("drizzle-orm/pg-core").PgColumn<{
2226
+ name: "dpop_bound_access_tokens";
2227
+ tableName: "oauth_client";
2228
+ dataType: "boolean";
2229
+ columnType: "PgBoolean";
2230
+ data: boolean;
2231
+ driverParam: boolean;
2232
+ notNull: false;
2233
+ hasDefault: true;
2234
+ isPrimaryKey: false;
2235
+ isAutoincrement: false;
2236
+ hasRuntimeDefault: false;
2237
+ enumValues: undefined;
2238
+ baseColumn: never;
2239
+ identity: undefined;
2240
+ generated: undefined;
2241
+ }, {}, {}>;
2242
+ referenceId: import("drizzle-orm/pg-core").PgColumn<{
2243
+ name: "reference_id";
2244
+ tableName: "oauth_client";
2245
+ dataType: "string";
2246
+ columnType: "PgText";
2247
+ data: string;
2248
+ driverParam: string;
2249
+ notNull: false;
2250
+ hasDefault: false;
2251
+ isPrimaryKey: false;
2252
+ isAutoincrement: false;
2253
+ hasRuntimeDefault: false;
2254
+ enumValues: [string, ...string[]];
2255
+ baseColumn: never;
2256
+ identity: undefined;
2257
+ generated: undefined;
2258
+ }, {}, {}>;
2259
+ metadata: import("drizzle-orm/pg-core").PgColumn<{
2260
+ name: "metadata";
2261
+ tableName: "oauth_client";
2262
+ dataType: "json";
2263
+ columnType: "PgJsonb";
2264
+ data: unknown;
2265
+ driverParam: unknown;
2266
+ notNull: false;
2267
+ hasDefault: false;
2268
+ isPrimaryKey: false;
2269
+ isAutoincrement: false;
2270
+ hasRuntimeDefault: false;
2271
+ enumValues: undefined;
2272
+ baseColumn: never;
2273
+ identity: undefined;
2274
+ generated: undefined;
2275
+ }, {}, {}>;
2276
+ };
2277
+ dialect: "pg";
2278
+ }>;
2279
+ oauthResource: import("drizzle-orm/pg-core").PgTableWithColumns<{
2280
+ name: "oauth_resource";
2281
+ schema: undefined;
2282
+ columns: {
2283
+ id: import("drizzle-orm/pg-core").PgColumn<{
2284
+ name: "id";
2285
+ tableName: "oauth_resource";
2286
+ dataType: "string";
2287
+ columnType: "PgText";
2288
+ data: string;
2289
+ driverParam: string;
2290
+ notNull: true;
2291
+ hasDefault: false;
2292
+ isPrimaryKey: true;
2293
+ isAutoincrement: false;
2294
+ hasRuntimeDefault: false;
2295
+ enumValues: [string, ...string[]];
2296
+ baseColumn: never;
2297
+ identity: undefined;
2298
+ generated: undefined;
2299
+ }, {}, {}>;
2300
+ identifier: import("drizzle-orm/pg-core").PgColumn<{
2301
+ name: "identifier";
2302
+ tableName: "oauth_resource";
2303
+ dataType: "string";
2304
+ columnType: "PgText";
2305
+ data: string;
2306
+ driverParam: string;
2307
+ notNull: true;
2308
+ hasDefault: false;
2309
+ isPrimaryKey: false;
2310
+ isAutoincrement: false;
2311
+ hasRuntimeDefault: false;
2312
+ enumValues: [string, ...string[]];
2313
+ baseColumn: never;
2314
+ identity: undefined;
2315
+ generated: undefined;
2316
+ }, {}, {}>;
2317
+ name: import("drizzle-orm/pg-core").PgColumn<{
2318
+ name: "name";
2319
+ tableName: "oauth_resource";
2320
+ dataType: "string";
2321
+ columnType: "PgText";
2322
+ data: string;
2323
+ driverParam: string;
2324
+ notNull: true;
2325
+ hasDefault: false;
2326
+ isPrimaryKey: false;
2327
+ isAutoincrement: false;
2328
+ hasRuntimeDefault: false;
2329
+ enumValues: [string, ...string[]];
2330
+ baseColumn: never;
2331
+ identity: undefined;
2332
+ generated: undefined;
2333
+ }, {}, {}>;
2334
+ accessTokenTtl: import("drizzle-orm/pg-core").PgColumn<{
2335
+ name: "access_token_ttl";
2336
+ tableName: "oauth_resource";
2337
+ dataType: "number";
2338
+ columnType: "PgInteger";
2339
+ data: number;
2340
+ driverParam: string | number;
2341
+ notNull: false;
2342
+ hasDefault: false;
2343
+ isPrimaryKey: false;
2344
+ isAutoincrement: false;
2345
+ hasRuntimeDefault: false;
2346
+ enumValues: undefined;
2347
+ baseColumn: never;
2348
+ identity: undefined;
2349
+ generated: undefined;
2350
+ }, {}, {}>;
2351
+ refreshTokenTtl: import("drizzle-orm/pg-core").PgColumn<{
2352
+ name: "refresh_token_ttl";
2353
+ tableName: "oauth_resource";
2354
+ dataType: "number";
2355
+ columnType: "PgInteger";
2356
+ data: number;
2357
+ driverParam: string | number;
2358
+ notNull: false;
2359
+ hasDefault: false;
2360
+ isPrimaryKey: false;
2361
+ isAutoincrement: false;
2362
+ hasRuntimeDefault: false;
2363
+ enumValues: undefined;
2364
+ baseColumn: never;
2365
+ identity: undefined;
2366
+ generated: undefined;
2367
+ }, {}, {}>;
2368
+ signingAlgorithm: import("drizzle-orm/pg-core").PgColumn<{
2369
+ name: "signing_algorithm";
2370
+ tableName: "oauth_resource";
2371
+ dataType: "string";
2372
+ columnType: "PgText";
2373
+ data: string;
2374
+ driverParam: string;
2375
+ notNull: false;
2376
+ hasDefault: false;
2377
+ isPrimaryKey: false;
2378
+ isAutoincrement: false;
2379
+ hasRuntimeDefault: false;
2380
+ enumValues: [string, ...string[]];
2381
+ baseColumn: never;
2382
+ identity: undefined;
2383
+ generated: undefined;
2384
+ }, {}, {}>;
2385
+ signingKeyId: import("drizzle-orm/pg-core").PgColumn<{
2386
+ name: "signing_key_id";
2387
+ tableName: "oauth_resource";
2388
+ dataType: "string";
2389
+ columnType: "PgText";
2390
+ data: string;
2391
+ driverParam: string;
2392
+ notNull: false;
2393
+ hasDefault: false;
2394
+ isPrimaryKey: false;
2395
+ isAutoincrement: false;
2396
+ hasRuntimeDefault: false;
2397
+ enumValues: [string, ...string[]];
2398
+ baseColumn: never;
2399
+ identity: undefined;
2400
+ generated: undefined;
2401
+ }, {}, {}>;
2402
+ allowedScopes: import("drizzle-orm/pg-core").PgColumn<{
2403
+ name: "allowed_scopes";
2404
+ tableName: "oauth_resource";
2405
+ dataType: "array";
2406
+ columnType: "PgArray";
2407
+ data: string[];
2408
+ driverParam: string | string[];
2409
+ notNull: false;
2410
+ hasDefault: false;
2411
+ isPrimaryKey: false;
2412
+ isAutoincrement: false;
2413
+ hasRuntimeDefault: false;
2414
+ enumValues: [string, ...string[]];
2415
+ baseColumn: import("drizzle-orm").Column<{
2416
+ name: "allowed_scopes";
2417
+ tableName: "oauth_resource";
2418
+ dataType: "string";
2419
+ columnType: "PgText";
2420
+ data: string;
2421
+ driverParam: string;
2422
+ notNull: false;
2423
+ hasDefault: false;
2424
+ isPrimaryKey: false;
2425
+ isAutoincrement: false;
2426
+ hasRuntimeDefault: false;
2427
+ enumValues: [string, ...string[]];
2428
+ baseColumn: never;
2429
+ identity: undefined;
2430
+ generated: undefined;
2431
+ }, {}, {}>;
2432
+ identity: undefined;
2433
+ generated: undefined;
2434
+ }, {}, {
2435
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
2436
+ name: "allowed_scopes";
2437
+ dataType: "string";
2438
+ columnType: "PgText";
2439
+ data: string;
2440
+ enumValues: [string, ...string[]];
2441
+ driverParam: string;
2442
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
2443
+ size: undefined;
2444
+ }>;
2445
+ customClaims: import("drizzle-orm/pg-core").PgColumn<{
2446
+ name: "custom_claims";
2447
+ tableName: "oauth_resource";
2448
+ dataType: "json";
2449
+ columnType: "PgJsonb";
2450
+ data: unknown;
2451
+ driverParam: unknown;
2452
+ notNull: false;
2453
+ hasDefault: false;
2454
+ isPrimaryKey: false;
2455
+ isAutoincrement: false;
2456
+ hasRuntimeDefault: false;
2457
+ enumValues: undefined;
2458
+ baseColumn: never;
2459
+ identity: undefined;
2460
+ generated: undefined;
2461
+ }, {}, {}>;
2462
+ dpopBoundAccessTokensRequired: import("drizzle-orm/pg-core").PgColumn<{
2463
+ name: "dpop_bound_access_tokens_required";
2464
+ tableName: "oauth_resource";
2465
+ dataType: "boolean";
2466
+ columnType: "PgBoolean";
2467
+ data: boolean;
2468
+ driverParam: boolean;
2469
+ notNull: false;
2470
+ hasDefault: true;
2471
+ isPrimaryKey: false;
2472
+ isAutoincrement: false;
2473
+ hasRuntimeDefault: false;
2474
+ enumValues: undefined;
2475
+ baseColumn: never;
2476
+ identity: undefined;
2477
+ generated: undefined;
2478
+ }, {}, {}>;
2479
+ disabled: import("drizzle-orm/pg-core").PgColumn<{
2480
+ name: "disabled";
2481
+ tableName: "oauth_resource";
2482
+ dataType: "boolean";
2483
+ columnType: "PgBoolean";
2484
+ data: boolean;
2485
+ driverParam: boolean;
2486
+ notNull: false;
2487
+ hasDefault: true;
2488
+ isPrimaryKey: false;
2489
+ isAutoincrement: false;
2490
+ hasRuntimeDefault: false;
2491
+ enumValues: undefined;
2492
+ baseColumn: never;
2493
+ identity: undefined;
2494
+ generated: undefined;
2495
+ }, {}, {}>;
2496
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2497
+ name: "created_at";
2498
+ tableName: "oauth_resource";
2499
+ dataType: "date";
2500
+ columnType: "PgTimestamp";
2501
+ data: Date;
2502
+ driverParam: string;
2503
+ notNull: false;
2504
+ hasDefault: false;
2505
+ isPrimaryKey: false;
2506
+ isAutoincrement: false;
2507
+ hasRuntimeDefault: false;
2508
+ enumValues: undefined;
2509
+ baseColumn: never;
2510
+ identity: undefined;
2511
+ generated: undefined;
2512
+ }, {}, {}>;
2513
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2514
+ name: "updated_at";
2515
+ tableName: "oauth_resource";
2516
+ dataType: "date";
2517
+ columnType: "PgTimestamp";
2518
+ data: Date;
2519
+ driverParam: string;
2520
+ notNull: false;
2521
+ hasDefault: false;
2522
+ isPrimaryKey: false;
2523
+ isAutoincrement: false;
2524
+ hasRuntimeDefault: false;
2525
+ enumValues: undefined;
2526
+ baseColumn: never;
2527
+ identity: undefined;
2528
+ generated: undefined;
2529
+ }, {}, {}>;
2530
+ policyVersion: import("drizzle-orm/pg-core").PgColumn<{
2531
+ name: "policy_version";
2532
+ tableName: "oauth_resource";
2533
+ dataType: "number";
2534
+ columnType: "PgInteger";
2535
+ data: number;
2536
+ driverParam: string | number;
2537
+ notNull: false;
2538
+ hasDefault: true;
2539
+ isPrimaryKey: false;
2540
+ isAutoincrement: false;
2541
+ hasRuntimeDefault: false;
2542
+ enumValues: undefined;
2543
+ baseColumn: never;
2544
+ identity: undefined;
2545
+ generated: undefined;
2546
+ }, {}, {}>;
2547
+ metadata: import("drizzle-orm/pg-core").PgColumn<{
2548
+ name: "metadata";
2549
+ tableName: "oauth_resource";
2550
+ dataType: "json";
2551
+ columnType: "PgJsonb";
2552
+ data: unknown;
2553
+ driverParam: unknown;
2554
+ notNull: false;
2555
+ hasDefault: false;
2556
+ isPrimaryKey: false;
2557
+ isAutoincrement: false;
2558
+ hasRuntimeDefault: false;
2559
+ enumValues: undefined;
2560
+ baseColumn: never;
2561
+ identity: undefined;
2562
+ generated: undefined;
2563
+ }, {}, {}>;
2564
+ };
2565
+ dialect: "pg";
2566
+ }>;
2567
+ oauthClientResource: import("drizzle-orm/pg-core").PgTableWithColumns<{
2568
+ name: "oauth_client_resource";
2569
+ schema: undefined;
2570
+ columns: {
2571
+ id: import("drizzle-orm/pg-core").PgColumn<{
2572
+ name: "id";
2573
+ tableName: "oauth_client_resource";
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
+ clientId: import("drizzle-orm/pg-core").PgColumn<{
2589
+ name: "client_id";
2590
+ tableName: "oauth_client_resource";
2591
+ dataType: "string";
2592
+ columnType: "PgText";
2593
+ data: string;
2594
+ driverParam: string;
2595
+ notNull: true;
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
+ resourceId: import("drizzle-orm/pg-core").PgColumn<{
2606
+ name: "resource_id";
2607
+ tableName: "oauth_client_resource";
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
+ metadata: import("drizzle-orm/pg-core").PgColumn<{
2623
+ name: "metadata";
2624
+ tableName: "oauth_client_resource";
2625
+ dataType: "json";
2626
+ columnType: "PgJsonb";
2627
+ data: unknown;
2628
+ driverParam: unknown;
2629
+ notNull: false;
2630
+ hasDefault: false;
2631
+ isPrimaryKey: false;
2632
+ isAutoincrement: false;
2633
+ hasRuntimeDefault: false;
2634
+ enumValues: undefined;
2635
+ baseColumn: never;
2636
+ identity: undefined;
2637
+ generated: undefined;
2638
+ }, {}, {}>;
2639
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2640
+ name: "created_at";
2641
+ tableName: "oauth_client_resource";
2642
+ dataType: "date";
2643
+ columnType: "PgTimestamp";
2644
+ data: Date;
2645
+ driverParam: string;
2646
+ notNull: false;
2647
+ hasDefault: false;
2648
+ isPrimaryKey: false;
2649
+ isAutoincrement: false;
2650
+ hasRuntimeDefault: false;
2651
+ enumValues: undefined;
2652
+ baseColumn: never;
2653
+ identity: undefined;
2654
+ generated: undefined;
2655
+ }, {}, {}>;
2656
+ };
2657
+ dialect: "pg";
2658
+ }>;
2659
+ oauthRefreshToken: import("drizzle-orm/pg-core").PgTableWithColumns<{
2660
+ name: "oauth_refresh_token";
2661
+ schema: undefined;
2662
+ columns: {
2663
+ id: import("drizzle-orm/pg-core").PgColumn<{
2664
+ name: "id";
2665
+ tableName: "oauth_refresh_token";
2666
+ dataType: "string";
2667
+ columnType: "PgText";
2668
+ data: string;
2669
+ driverParam: string;
2670
+ notNull: true;
2671
+ hasDefault: false;
2672
+ isPrimaryKey: true;
2673
+ isAutoincrement: false;
2674
+ hasRuntimeDefault: false;
2675
+ enumValues: [string, ...string[]];
2676
+ baseColumn: never;
2677
+ identity: undefined;
2678
+ generated: undefined;
2679
+ }, {}, {}>;
2680
+ token: import("drizzle-orm/pg-core").PgColumn<{
2681
+ name: "token";
2682
+ tableName: "oauth_refresh_token";
2683
+ dataType: "string";
2684
+ columnType: "PgText";
2685
+ data: string;
2686
+ driverParam: string;
2687
+ notNull: true;
2688
+ hasDefault: false;
2689
+ isPrimaryKey: false;
2690
+ isAutoincrement: false;
2691
+ hasRuntimeDefault: false;
2692
+ enumValues: [string, ...string[]];
2693
+ baseColumn: never;
2694
+ identity: undefined;
2695
+ generated: undefined;
2696
+ }, {}, {}>;
2697
+ clientId: import("drizzle-orm/pg-core").PgColumn<{
2698
+ name: "client_id";
2699
+ tableName: "oauth_refresh_token";
2700
+ dataType: "string";
2701
+ columnType: "PgText";
2702
+ data: string;
2703
+ driverParam: string;
2704
+ notNull: true;
2705
+ hasDefault: false;
2706
+ isPrimaryKey: false;
2707
+ isAutoincrement: false;
2708
+ hasRuntimeDefault: false;
2709
+ enumValues: [string, ...string[]];
2710
+ baseColumn: never;
2711
+ identity: undefined;
2712
+ generated: undefined;
2713
+ }, {}, {}>;
2714
+ sessionId: import("drizzle-orm/pg-core").PgColumn<{
2715
+ name: "session_id";
2716
+ tableName: "oauth_refresh_token";
2717
+ dataType: "string";
2718
+ columnType: "PgText";
2719
+ data: string;
2720
+ driverParam: string;
2721
+ notNull: false;
2722
+ hasDefault: false;
2723
+ isPrimaryKey: false;
2724
+ isAutoincrement: false;
2725
+ hasRuntimeDefault: false;
2726
+ enumValues: [string, ...string[]];
2727
+ baseColumn: never;
2728
+ identity: undefined;
2729
+ generated: undefined;
2730
+ }, {}, {}>;
2731
+ userId: import("drizzle-orm/pg-core").PgColumn<{
2732
+ name: "user_id";
2733
+ tableName: "oauth_refresh_token";
2734
+ dataType: "string";
2735
+ columnType: "PgText";
2736
+ data: string;
2737
+ driverParam: string;
2738
+ notNull: true;
2739
+ hasDefault: false;
2740
+ isPrimaryKey: false;
2741
+ isAutoincrement: false;
2742
+ hasRuntimeDefault: false;
2743
+ enumValues: [string, ...string[]];
2744
+ baseColumn: never;
2745
+ identity: undefined;
2746
+ generated: undefined;
2747
+ }, {}, {}>;
2748
+ referenceId: import("drizzle-orm/pg-core").PgColumn<{
2749
+ name: "reference_id";
2750
+ tableName: "oauth_refresh_token";
2751
+ dataType: "string";
2752
+ columnType: "PgText";
2753
+ data: string;
2754
+ driverParam: string;
2755
+ notNull: false;
2756
+ hasDefault: false;
2757
+ isPrimaryKey: false;
2758
+ isAutoincrement: false;
2759
+ hasRuntimeDefault: false;
2760
+ enumValues: [string, ...string[]];
2761
+ baseColumn: never;
2762
+ identity: undefined;
2763
+ generated: undefined;
2764
+ }, {}, {}>;
2765
+ authorizationCodeId: import("drizzle-orm/pg-core").PgColumn<{
2766
+ name: "authorization_code_id";
2767
+ tableName: "oauth_refresh_token";
2768
+ dataType: "string";
2769
+ columnType: "PgText";
2770
+ data: string;
2771
+ driverParam: string;
2772
+ notNull: false;
2773
+ hasDefault: false;
2774
+ isPrimaryKey: false;
2775
+ isAutoincrement: false;
2776
+ hasRuntimeDefault: false;
2777
+ enumValues: [string, ...string[]];
2778
+ baseColumn: never;
2779
+ identity: undefined;
2780
+ generated: undefined;
2781
+ }, {}, {}>;
2782
+ resources: import("drizzle-orm/pg-core").PgColumn<{
2783
+ name: "resources";
2784
+ tableName: "oauth_refresh_token";
2785
+ dataType: "array";
2786
+ columnType: "PgArray";
2787
+ data: string[];
2788
+ driverParam: string | string[];
2789
+ notNull: false;
2790
+ hasDefault: false;
2791
+ isPrimaryKey: false;
2792
+ isAutoincrement: false;
2793
+ hasRuntimeDefault: false;
2794
+ enumValues: [string, ...string[]];
2795
+ baseColumn: import("drizzle-orm").Column<{
2796
+ name: "resources";
2797
+ tableName: "oauth_refresh_token";
2798
+ dataType: "string";
2799
+ columnType: "PgText";
2800
+ data: string;
2801
+ driverParam: string;
2802
+ notNull: false;
2803
+ hasDefault: false;
2804
+ isPrimaryKey: false;
2805
+ isAutoincrement: false;
2806
+ hasRuntimeDefault: false;
2807
+ enumValues: [string, ...string[]];
2808
+ baseColumn: never;
2809
+ identity: undefined;
2810
+ generated: undefined;
2811
+ }, {}, {}>;
2812
+ identity: undefined;
2813
+ generated: undefined;
2814
+ }, {}, {
2815
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
2816
+ name: "resources";
2817
+ dataType: "string";
2818
+ columnType: "PgText";
2819
+ data: string;
2820
+ enumValues: [string, ...string[]];
2821
+ driverParam: string;
2822
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
2823
+ size: undefined;
2824
+ }>;
2825
+ requestedUserInfoClaims: import("drizzle-orm/pg-core").PgColumn<{
2826
+ name: "requested_user_info_claims";
2827
+ tableName: "oauth_refresh_token";
2828
+ dataType: "array";
2829
+ columnType: "PgArray";
2830
+ data: string[];
2831
+ driverParam: string | string[];
2832
+ notNull: false;
2833
+ hasDefault: false;
2834
+ isPrimaryKey: false;
2835
+ isAutoincrement: false;
2836
+ hasRuntimeDefault: false;
2837
+ enumValues: [string, ...string[]];
2838
+ baseColumn: import("drizzle-orm").Column<{
2839
+ name: "requested_user_info_claims";
2840
+ tableName: "oauth_refresh_token";
2841
+ dataType: "string";
2842
+ columnType: "PgText";
2843
+ data: string;
2844
+ driverParam: string;
2845
+ notNull: false;
2846
+ hasDefault: false;
2847
+ isPrimaryKey: false;
2848
+ isAutoincrement: false;
2849
+ hasRuntimeDefault: false;
2850
+ enumValues: [string, ...string[]];
2851
+ baseColumn: never;
2852
+ identity: undefined;
2853
+ generated: undefined;
2854
+ }, {}, {}>;
2855
+ identity: undefined;
2856
+ generated: undefined;
2857
+ }, {}, {
2858
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
2859
+ name: "requested_user_info_claims";
2860
+ dataType: "string";
2861
+ columnType: "PgText";
2862
+ data: string;
2863
+ enumValues: [string, ...string[]];
2864
+ driverParam: string;
2865
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
2866
+ size: undefined;
2867
+ }>;
2868
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
2869
+ name: "expires_at";
2870
+ tableName: "oauth_refresh_token";
2871
+ dataType: "date";
2872
+ columnType: "PgTimestamp";
2873
+ data: Date;
2874
+ driverParam: string;
2875
+ notNull: true;
2876
+ hasDefault: false;
2877
+ isPrimaryKey: false;
2878
+ isAutoincrement: false;
2879
+ hasRuntimeDefault: false;
2880
+ enumValues: undefined;
2881
+ baseColumn: never;
2882
+ identity: undefined;
2883
+ generated: undefined;
2884
+ }, {}, {}>;
2885
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2886
+ name: "created_at";
2887
+ tableName: "oauth_refresh_token";
2888
+ dataType: "date";
2889
+ columnType: "PgTimestamp";
2890
+ data: Date;
2891
+ driverParam: string;
2892
+ notNull: true;
2893
+ hasDefault: false;
2894
+ isPrimaryKey: false;
2895
+ isAutoincrement: false;
2896
+ hasRuntimeDefault: false;
2897
+ enumValues: undefined;
2898
+ baseColumn: never;
2899
+ identity: undefined;
2900
+ generated: undefined;
2901
+ }, {}, {}>;
2902
+ revoked: import("drizzle-orm/pg-core").PgColumn<{
2903
+ name: "revoked";
2904
+ tableName: "oauth_refresh_token";
2905
+ dataType: "date";
2906
+ columnType: "PgTimestamp";
2907
+ data: Date;
2908
+ driverParam: string;
2909
+ notNull: false;
2910
+ hasDefault: false;
2911
+ isPrimaryKey: false;
2912
+ isAutoincrement: false;
2913
+ hasRuntimeDefault: false;
2914
+ enumValues: undefined;
2915
+ baseColumn: never;
2916
+ identity: undefined;
2917
+ generated: undefined;
2918
+ }, {}, {}>;
2919
+ rotatedAt: import("drizzle-orm/pg-core").PgColumn<{
2920
+ name: "rotated_at";
2921
+ tableName: "oauth_refresh_token";
2922
+ dataType: "date";
2923
+ columnType: "PgTimestamp";
2924
+ data: Date;
2925
+ driverParam: string;
2926
+ notNull: false;
2927
+ hasDefault: false;
2928
+ isPrimaryKey: false;
2929
+ isAutoincrement: false;
2930
+ hasRuntimeDefault: false;
2931
+ enumValues: undefined;
2932
+ baseColumn: never;
2933
+ identity: undefined;
2934
+ generated: undefined;
2935
+ }, {}, {}>;
2936
+ rotationReplayResponse: import("drizzle-orm/pg-core").PgColumn<{
2937
+ name: "rotation_replay_response";
2938
+ tableName: "oauth_refresh_token";
2939
+ dataType: "string";
2940
+ columnType: "PgText";
2941
+ data: string;
2942
+ driverParam: string;
2943
+ notNull: false;
2944
+ hasDefault: false;
2945
+ isPrimaryKey: false;
2946
+ isAutoincrement: false;
2947
+ hasRuntimeDefault: false;
2948
+ enumValues: [string, ...string[]];
2949
+ baseColumn: never;
2950
+ identity: undefined;
2951
+ generated: undefined;
2952
+ }, {}, {}>;
2953
+ rotationReplayExpiresAt: import("drizzle-orm/pg-core").PgColumn<{
2954
+ name: "rotation_replay_expires_at";
2955
+ tableName: "oauth_refresh_token";
2956
+ dataType: "date";
2957
+ columnType: "PgTimestamp";
2958
+ data: Date;
2959
+ driverParam: string;
2960
+ notNull: false;
2961
+ hasDefault: false;
2962
+ isPrimaryKey: false;
2963
+ isAutoincrement: false;
2964
+ hasRuntimeDefault: false;
2965
+ enumValues: undefined;
2966
+ baseColumn: never;
2967
+ identity: undefined;
2968
+ generated: undefined;
2969
+ }, {}, {}>;
2970
+ authTime: import("drizzle-orm/pg-core").PgColumn<{
2971
+ name: "auth_time";
2972
+ tableName: "oauth_refresh_token";
2973
+ dataType: "date";
2974
+ columnType: "PgTimestamp";
2975
+ data: Date;
2976
+ driverParam: string;
2977
+ notNull: false;
2978
+ hasDefault: false;
2979
+ isPrimaryKey: false;
2980
+ isAutoincrement: false;
2981
+ hasRuntimeDefault: false;
2982
+ enumValues: undefined;
2983
+ baseColumn: never;
2984
+ identity: undefined;
2985
+ generated: undefined;
2986
+ }, {}, {}>;
2987
+ confirmation: import("drizzle-orm/pg-core").PgColumn<{
2988
+ name: "confirmation";
2989
+ tableName: "oauth_refresh_token";
2990
+ dataType: "json";
2991
+ columnType: "PgJsonb";
2992
+ data: unknown;
2993
+ driverParam: unknown;
2994
+ notNull: false;
2995
+ hasDefault: false;
2996
+ isPrimaryKey: false;
2997
+ isAutoincrement: false;
2998
+ hasRuntimeDefault: false;
2999
+ enumValues: undefined;
3000
+ baseColumn: never;
3001
+ identity: undefined;
3002
+ generated: undefined;
3003
+ }, {}, {}>;
3004
+ scopes: import("drizzle-orm/pg-core").PgColumn<{
3005
+ name: "scopes";
3006
+ tableName: "oauth_refresh_token";
3007
+ dataType: "array";
3008
+ columnType: "PgArray";
3009
+ data: string[];
3010
+ driverParam: string | string[];
3011
+ notNull: true;
3012
+ hasDefault: false;
3013
+ isPrimaryKey: false;
3014
+ isAutoincrement: false;
3015
+ hasRuntimeDefault: false;
3016
+ enumValues: [string, ...string[]];
3017
+ baseColumn: import("drizzle-orm").Column<{
3018
+ name: "scopes";
3019
+ tableName: "oauth_refresh_token";
3020
+ dataType: "string";
3021
+ columnType: "PgText";
3022
+ data: string;
3023
+ driverParam: string;
3024
+ notNull: false;
3025
+ hasDefault: false;
3026
+ isPrimaryKey: false;
3027
+ isAutoincrement: false;
3028
+ hasRuntimeDefault: false;
3029
+ enumValues: [string, ...string[]];
3030
+ baseColumn: never;
3031
+ identity: undefined;
3032
+ generated: undefined;
3033
+ }, {}, {}>;
3034
+ identity: undefined;
3035
+ generated: undefined;
3036
+ }, {}, {
3037
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
3038
+ name: "scopes";
3039
+ dataType: "string";
3040
+ columnType: "PgText";
3041
+ data: string;
3042
+ enumValues: [string, ...string[]];
3043
+ driverParam: string;
3044
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
3045
+ size: undefined;
3046
+ }>;
3047
+ };
3048
+ dialect: "pg";
3049
+ }>;
3050
+ oauthAccessToken: import("drizzle-orm/pg-core").PgTableWithColumns<{
3051
+ name: "oauth_access_token";
3052
+ schema: undefined;
3053
+ columns: {
3054
+ id: import("drizzle-orm/pg-core").PgColumn<{
3055
+ name: "id";
3056
+ tableName: "oauth_access_token";
3057
+ dataType: "string";
3058
+ columnType: "PgText";
3059
+ data: string;
3060
+ driverParam: string;
3061
+ notNull: true;
3062
+ hasDefault: false;
3063
+ isPrimaryKey: true;
3064
+ isAutoincrement: false;
3065
+ hasRuntimeDefault: false;
3066
+ enumValues: [string, ...string[]];
3067
+ baseColumn: never;
3068
+ identity: undefined;
3069
+ generated: undefined;
3070
+ }, {}, {}>;
3071
+ token: import("drizzle-orm/pg-core").PgColumn<{
3072
+ name: "token";
3073
+ tableName: "oauth_access_token";
3074
+ dataType: "string";
3075
+ columnType: "PgText";
3076
+ data: string;
3077
+ driverParam: string;
3078
+ notNull: true;
3079
+ hasDefault: false;
3080
+ isPrimaryKey: false;
3081
+ isAutoincrement: false;
3082
+ hasRuntimeDefault: false;
3083
+ enumValues: [string, ...string[]];
3084
+ baseColumn: never;
3085
+ identity: undefined;
3086
+ generated: undefined;
3087
+ }, {}, {}>;
3088
+ clientId: import("drizzle-orm/pg-core").PgColumn<{
3089
+ name: "client_id";
3090
+ tableName: "oauth_access_token";
3091
+ dataType: "string";
3092
+ columnType: "PgText";
3093
+ data: string;
3094
+ driverParam: string;
3095
+ notNull: true;
3096
+ hasDefault: false;
3097
+ isPrimaryKey: false;
3098
+ isAutoincrement: false;
3099
+ hasRuntimeDefault: false;
3100
+ enumValues: [string, ...string[]];
3101
+ baseColumn: never;
3102
+ identity: undefined;
3103
+ generated: undefined;
3104
+ }, {}, {}>;
3105
+ sessionId: import("drizzle-orm/pg-core").PgColumn<{
3106
+ name: "session_id";
3107
+ tableName: "oauth_access_token";
3108
+ dataType: "string";
3109
+ columnType: "PgText";
3110
+ data: string;
3111
+ driverParam: string;
3112
+ notNull: false;
3113
+ hasDefault: false;
3114
+ isPrimaryKey: false;
3115
+ isAutoincrement: false;
3116
+ hasRuntimeDefault: false;
3117
+ enumValues: [string, ...string[]];
3118
+ baseColumn: never;
3119
+ identity: undefined;
3120
+ generated: undefined;
3121
+ }, {}, {}>;
3122
+ userId: import("drizzle-orm/pg-core").PgColumn<{
3123
+ name: "user_id";
3124
+ tableName: "oauth_access_token";
3125
+ dataType: "string";
3126
+ columnType: "PgText";
3127
+ data: string;
3128
+ driverParam: string;
3129
+ notNull: false;
3130
+ hasDefault: false;
3131
+ isPrimaryKey: false;
3132
+ isAutoincrement: false;
3133
+ hasRuntimeDefault: false;
3134
+ enumValues: [string, ...string[]];
3135
+ baseColumn: never;
3136
+ identity: undefined;
3137
+ generated: undefined;
3138
+ }, {}, {}>;
3139
+ referenceId: import("drizzle-orm/pg-core").PgColumn<{
3140
+ name: "reference_id";
3141
+ tableName: "oauth_access_token";
3142
+ dataType: "string";
3143
+ columnType: "PgText";
3144
+ data: string;
3145
+ driverParam: string;
3146
+ notNull: false;
3147
+ hasDefault: false;
3148
+ isPrimaryKey: false;
3149
+ isAutoincrement: false;
3150
+ hasRuntimeDefault: false;
3151
+ enumValues: [string, ...string[]];
3152
+ baseColumn: never;
3153
+ identity: undefined;
3154
+ generated: undefined;
3155
+ }, {}, {}>;
3156
+ authorizationCodeId: import("drizzle-orm/pg-core").PgColumn<{
3157
+ name: "authorization_code_id";
3158
+ tableName: "oauth_access_token";
3159
+ dataType: "string";
3160
+ columnType: "PgText";
3161
+ data: string;
3162
+ driverParam: string;
3163
+ notNull: false;
3164
+ hasDefault: false;
3165
+ isPrimaryKey: false;
3166
+ isAutoincrement: false;
3167
+ hasRuntimeDefault: false;
3168
+ enumValues: [string, ...string[]];
3169
+ baseColumn: never;
3170
+ identity: undefined;
3171
+ generated: undefined;
3172
+ }, {}, {}>;
3173
+ resources: import("drizzle-orm/pg-core").PgColumn<{
3174
+ name: "resources";
3175
+ tableName: "oauth_access_token";
3176
+ dataType: "array";
3177
+ columnType: "PgArray";
3178
+ data: string[];
3179
+ driverParam: string | string[];
3180
+ notNull: false;
3181
+ hasDefault: false;
3182
+ isPrimaryKey: false;
3183
+ isAutoincrement: false;
3184
+ hasRuntimeDefault: false;
3185
+ enumValues: [string, ...string[]];
3186
+ baseColumn: import("drizzle-orm").Column<{
3187
+ name: "resources";
3188
+ tableName: "oauth_access_token";
3189
+ dataType: "string";
3190
+ columnType: "PgText";
3191
+ data: string;
3192
+ driverParam: string;
3193
+ notNull: false;
3194
+ hasDefault: false;
3195
+ isPrimaryKey: false;
3196
+ isAutoincrement: false;
3197
+ hasRuntimeDefault: false;
3198
+ enumValues: [string, ...string[]];
3199
+ baseColumn: never;
3200
+ identity: undefined;
3201
+ generated: undefined;
3202
+ }, {}, {}>;
3203
+ identity: undefined;
3204
+ generated: undefined;
3205
+ }, {}, {
3206
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
3207
+ name: "resources";
3208
+ dataType: "string";
3209
+ columnType: "PgText";
3210
+ data: string;
3211
+ enumValues: [string, ...string[]];
3212
+ driverParam: string;
3213
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
3214
+ size: undefined;
3215
+ }>;
3216
+ requestedUserInfoClaims: import("drizzle-orm/pg-core").PgColumn<{
3217
+ name: "requested_user_info_claims";
3218
+ tableName: "oauth_access_token";
3219
+ dataType: "array";
3220
+ columnType: "PgArray";
3221
+ data: string[];
3222
+ driverParam: string | string[];
3223
+ notNull: false;
3224
+ hasDefault: false;
3225
+ isPrimaryKey: false;
3226
+ isAutoincrement: false;
3227
+ hasRuntimeDefault: false;
3228
+ enumValues: [string, ...string[]];
3229
+ baseColumn: import("drizzle-orm").Column<{
3230
+ name: "requested_user_info_claims";
3231
+ tableName: "oauth_access_token";
3232
+ dataType: "string";
3233
+ columnType: "PgText";
3234
+ data: string;
3235
+ driverParam: string;
3236
+ notNull: false;
3237
+ hasDefault: false;
3238
+ isPrimaryKey: false;
3239
+ isAutoincrement: false;
3240
+ hasRuntimeDefault: false;
3241
+ enumValues: [string, ...string[]];
3242
+ baseColumn: never;
3243
+ identity: undefined;
3244
+ generated: undefined;
3245
+ }, {}, {}>;
3246
+ identity: undefined;
3247
+ generated: undefined;
3248
+ }, {}, {
3249
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
3250
+ name: "requested_user_info_claims";
3251
+ dataType: "string";
3252
+ columnType: "PgText";
3253
+ data: string;
3254
+ enumValues: [string, ...string[]];
3255
+ driverParam: string;
3256
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
3257
+ size: undefined;
3258
+ }>;
3259
+ refreshId: import("drizzle-orm/pg-core").PgColumn<{
3260
+ name: "refresh_id";
3261
+ tableName: "oauth_access_token";
3262
+ dataType: "string";
3263
+ columnType: "PgText";
3264
+ data: string;
3265
+ driverParam: string;
3266
+ notNull: false;
3267
+ hasDefault: false;
3268
+ isPrimaryKey: false;
3269
+ isAutoincrement: false;
3270
+ hasRuntimeDefault: false;
3271
+ enumValues: [string, ...string[]];
3272
+ baseColumn: never;
3273
+ identity: undefined;
3274
+ generated: undefined;
3275
+ }, {}, {}>;
3276
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
3277
+ name: "expires_at";
3278
+ tableName: "oauth_access_token";
3279
+ dataType: "date";
3280
+ columnType: "PgTimestamp";
3281
+ data: Date;
3282
+ driverParam: string;
3283
+ notNull: true;
3284
+ hasDefault: false;
3285
+ isPrimaryKey: false;
3286
+ isAutoincrement: false;
3287
+ hasRuntimeDefault: false;
3288
+ enumValues: undefined;
3289
+ baseColumn: never;
3290
+ identity: undefined;
3291
+ generated: undefined;
3292
+ }, {}, {}>;
3293
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
3294
+ name: "created_at";
3295
+ tableName: "oauth_access_token";
3296
+ dataType: "date";
3297
+ columnType: "PgTimestamp";
3298
+ data: Date;
3299
+ driverParam: string;
3300
+ notNull: true;
3301
+ hasDefault: false;
3302
+ isPrimaryKey: false;
3303
+ isAutoincrement: false;
3304
+ hasRuntimeDefault: false;
3305
+ enumValues: undefined;
3306
+ baseColumn: never;
3307
+ identity: undefined;
3308
+ generated: undefined;
3309
+ }, {}, {}>;
3310
+ revoked: import("drizzle-orm/pg-core").PgColumn<{
3311
+ name: "revoked";
3312
+ tableName: "oauth_access_token";
3313
+ dataType: "date";
3314
+ columnType: "PgTimestamp";
3315
+ data: Date;
3316
+ driverParam: string;
3317
+ notNull: false;
3318
+ hasDefault: false;
3319
+ isPrimaryKey: false;
3320
+ isAutoincrement: false;
3321
+ hasRuntimeDefault: false;
3322
+ enumValues: undefined;
3323
+ baseColumn: never;
3324
+ identity: undefined;
3325
+ generated: undefined;
3326
+ }, {}, {}>;
3327
+ confirmation: import("drizzle-orm/pg-core").PgColumn<{
3328
+ name: "confirmation";
3329
+ tableName: "oauth_access_token";
3330
+ dataType: "json";
3331
+ columnType: "PgJsonb";
3332
+ data: unknown;
3333
+ driverParam: unknown;
3334
+ notNull: false;
3335
+ hasDefault: false;
3336
+ isPrimaryKey: false;
3337
+ isAutoincrement: false;
3338
+ hasRuntimeDefault: false;
3339
+ enumValues: undefined;
3340
+ baseColumn: never;
3341
+ identity: undefined;
3342
+ generated: undefined;
3343
+ }, {}, {}>;
3344
+ scopes: import("drizzle-orm/pg-core").PgColumn<{
3345
+ name: "scopes";
3346
+ tableName: "oauth_access_token";
3347
+ dataType: "array";
3348
+ columnType: "PgArray";
3349
+ data: string[];
3350
+ driverParam: string | string[];
3351
+ notNull: true;
3352
+ hasDefault: false;
3353
+ isPrimaryKey: false;
3354
+ isAutoincrement: false;
3355
+ hasRuntimeDefault: false;
3356
+ enumValues: [string, ...string[]];
3357
+ baseColumn: import("drizzle-orm").Column<{
3358
+ name: "scopes";
3359
+ tableName: "oauth_access_token";
3360
+ dataType: "string";
3361
+ columnType: "PgText";
3362
+ data: string;
3363
+ driverParam: string;
3364
+ notNull: false;
3365
+ hasDefault: false;
3366
+ isPrimaryKey: false;
3367
+ isAutoincrement: false;
3368
+ hasRuntimeDefault: false;
3369
+ enumValues: [string, ...string[]];
3370
+ baseColumn: never;
3371
+ identity: undefined;
3372
+ generated: undefined;
3373
+ }, {}, {}>;
3374
+ identity: undefined;
3375
+ generated: undefined;
3376
+ }, {}, {
3377
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
3378
+ name: "scopes";
3379
+ dataType: "string";
3380
+ columnType: "PgText";
3381
+ data: string;
3382
+ enumValues: [string, ...string[]];
3383
+ driverParam: string;
3384
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
3385
+ size: undefined;
3386
+ }>;
3387
+ };
3388
+ dialect: "pg";
3389
+ }>;
3390
+ oauthConsent: import("drizzle-orm/pg-core").PgTableWithColumns<{
3391
+ name: "oauth_consent";
3392
+ schema: undefined;
3393
+ columns: {
3394
+ id: import("drizzle-orm/pg-core").PgColumn<{
3395
+ name: "id";
3396
+ tableName: "oauth_consent";
3397
+ dataType: "string";
3398
+ columnType: "PgText";
3399
+ data: string;
3400
+ driverParam: string;
3401
+ notNull: true;
3402
+ hasDefault: false;
3403
+ isPrimaryKey: true;
3404
+ isAutoincrement: false;
3405
+ hasRuntimeDefault: false;
3406
+ enumValues: [string, ...string[]];
3407
+ baseColumn: never;
3408
+ identity: undefined;
3409
+ generated: undefined;
3410
+ }, {}, {}>;
3411
+ clientId: import("drizzle-orm/pg-core").PgColumn<{
3412
+ name: "client_id";
3413
+ tableName: "oauth_consent";
3414
+ dataType: "string";
3415
+ columnType: "PgText";
3416
+ data: string;
3417
+ driverParam: string;
3418
+ notNull: true;
3419
+ hasDefault: false;
3420
+ isPrimaryKey: false;
3421
+ isAutoincrement: false;
3422
+ hasRuntimeDefault: false;
3423
+ enumValues: [string, ...string[]];
3424
+ baseColumn: never;
3425
+ identity: undefined;
3426
+ generated: undefined;
3427
+ }, {}, {}>;
3428
+ userId: import("drizzle-orm/pg-core").PgColumn<{
3429
+ name: "user_id";
3430
+ tableName: "oauth_consent";
3431
+ dataType: "string";
3432
+ columnType: "PgText";
3433
+ data: string;
3434
+ driverParam: string;
3435
+ notNull: false;
3436
+ hasDefault: false;
3437
+ isPrimaryKey: false;
3438
+ isAutoincrement: false;
3439
+ hasRuntimeDefault: false;
3440
+ enumValues: [string, ...string[]];
3441
+ baseColumn: never;
3442
+ identity: undefined;
3443
+ generated: undefined;
3444
+ }, {}, {}>;
3445
+ referenceId: import("drizzle-orm/pg-core").PgColumn<{
3446
+ name: "reference_id";
3447
+ tableName: "oauth_consent";
3448
+ dataType: "string";
3449
+ columnType: "PgText";
3450
+ data: string;
3451
+ driverParam: string;
3452
+ notNull: false;
3453
+ hasDefault: false;
3454
+ isPrimaryKey: false;
3455
+ isAutoincrement: false;
3456
+ hasRuntimeDefault: false;
3457
+ enumValues: [string, ...string[]];
3458
+ baseColumn: never;
3459
+ identity: undefined;
3460
+ generated: undefined;
3461
+ }, {}, {}>;
3462
+ resources: import("drizzle-orm/pg-core").PgColumn<{
3463
+ name: "resources";
3464
+ tableName: "oauth_consent";
3465
+ dataType: "array";
3466
+ columnType: "PgArray";
3467
+ data: string[];
3468
+ driverParam: string | string[];
3469
+ notNull: false;
3470
+ hasDefault: false;
3471
+ isPrimaryKey: false;
3472
+ isAutoincrement: false;
3473
+ hasRuntimeDefault: false;
3474
+ enumValues: [string, ...string[]];
3475
+ baseColumn: import("drizzle-orm").Column<{
3476
+ name: "resources";
3477
+ tableName: "oauth_consent";
3478
+ dataType: "string";
3479
+ columnType: "PgText";
3480
+ data: string;
3481
+ driverParam: string;
3482
+ notNull: false;
3483
+ hasDefault: false;
3484
+ isPrimaryKey: false;
3485
+ isAutoincrement: false;
3486
+ hasRuntimeDefault: false;
3487
+ enumValues: [string, ...string[]];
3488
+ baseColumn: never;
3489
+ identity: undefined;
3490
+ generated: undefined;
3491
+ }, {}, {}>;
3492
+ identity: undefined;
3493
+ generated: undefined;
3494
+ }, {}, {
3495
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
3496
+ name: "resources";
3497
+ dataType: "string";
3498
+ columnType: "PgText";
3499
+ data: string;
3500
+ enumValues: [string, ...string[]];
3501
+ driverParam: string;
3502
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
3503
+ size: undefined;
3504
+ }>;
3505
+ requestedUserInfoClaims: import("drizzle-orm/pg-core").PgColumn<{
3506
+ name: "requested_user_info_claims";
3507
+ tableName: "oauth_consent";
3508
+ dataType: "array";
3509
+ columnType: "PgArray";
3510
+ data: string[];
3511
+ driverParam: string | string[];
3512
+ notNull: false;
3513
+ hasDefault: false;
3514
+ isPrimaryKey: false;
3515
+ isAutoincrement: false;
3516
+ hasRuntimeDefault: false;
3517
+ enumValues: [string, ...string[]];
3518
+ baseColumn: import("drizzle-orm").Column<{
3519
+ name: "requested_user_info_claims";
3520
+ tableName: "oauth_consent";
3521
+ dataType: "string";
3522
+ columnType: "PgText";
3523
+ data: string;
3524
+ driverParam: string;
3525
+ notNull: false;
3526
+ hasDefault: false;
3527
+ isPrimaryKey: false;
3528
+ isAutoincrement: false;
3529
+ hasRuntimeDefault: false;
3530
+ enumValues: [string, ...string[]];
3531
+ baseColumn: never;
3532
+ identity: undefined;
3533
+ generated: undefined;
3534
+ }, {}, {}>;
3535
+ identity: undefined;
3536
+ generated: undefined;
3537
+ }, {}, {
3538
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
3539
+ name: "requested_user_info_claims";
3540
+ dataType: "string";
3541
+ columnType: "PgText";
3542
+ data: string;
3543
+ enumValues: [string, ...string[]];
3544
+ driverParam: string;
3545
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
3546
+ size: undefined;
3547
+ }>;
3548
+ scopes: import("drizzle-orm/pg-core").PgColumn<{
3549
+ name: "scopes";
3550
+ tableName: "oauth_consent";
3551
+ dataType: "array";
3552
+ columnType: "PgArray";
3553
+ data: string[];
3554
+ driverParam: string | string[];
3555
+ notNull: true;
3556
+ hasDefault: false;
3557
+ isPrimaryKey: false;
3558
+ isAutoincrement: false;
3559
+ hasRuntimeDefault: false;
3560
+ enumValues: [string, ...string[]];
3561
+ baseColumn: import("drizzle-orm").Column<{
3562
+ name: "scopes";
3563
+ tableName: "oauth_consent";
3564
+ dataType: "string";
3565
+ columnType: "PgText";
3566
+ data: string;
3567
+ driverParam: string;
3568
+ notNull: false;
3569
+ hasDefault: false;
3570
+ isPrimaryKey: false;
3571
+ isAutoincrement: false;
3572
+ hasRuntimeDefault: false;
3573
+ enumValues: [string, ...string[]];
3574
+ baseColumn: never;
3575
+ identity: undefined;
3576
+ generated: undefined;
3577
+ }, {}, {}>;
3578
+ identity: undefined;
3579
+ generated: undefined;
3580
+ }, {}, {
3581
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
3582
+ name: "scopes";
3583
+ dataType: "string";
3584
+ columnType: "PgText";
3585
+ data: string;
3586
+ enumValues: [string, ...string[]];
3587
+ driverParam: string;
3588
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
3589
+ size: undefined;
3590
+ }>;
3591
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
3592
+ name: "created_at";
3593
+ tableName: "oauth_consent";
3594
+ dataType: "date";
3595
+ columnType: "PgTimestamp";
3596
+ data: Date;
3597
+ driverParam: string;
3598
+ notNull: true;
3599
+ hasDefault: false;
3600
+ isPrimaryKey: false;
3601
+ isAutoincrement: false;
3602
+ hasRuntimeDefault: false;
3603
+ enumValues: undefined;
3604
+ baseColumn: never;
3605
+ identity: undefined;
3606
+ generated: undefined;
3607
+ }, {}, {}>;
3608
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
3609
+ name: "updated_at";
3610
+ tableName: "oauth_consent";
3611
+ dataType: "date";
3612
+ columnType: "PgTimestamp";
3613
+ data: Date;
3614
+ driverParam: string;
3615
+ notNull: true;
3616
+ hasDefault: false;
3617
+ isPrimaryKey: false;
3618
+ isAutoincrement: false;
3619
+ hasRuntimeDefault: false;
3620
+ enumValues: undefined;
3621
+ baseColumn: never;
3622
+ identity: undefined;
3623
+ generated: undefined;
3624
+ }, {}, {}>;
3625
+ };
3626
+ dialect: "pg";
3627
+ }>;
3628
+ oauthClientAssertion: import("drizzle-orm/pg-core").PgTableWithColumns<{
3629
+ name: "oauth_client_assertion";
3630
+ schema: undefined;
3631
+ columns: {
3632
+ id: import("drizzle-orm/pg-core").PgColumn<{
3633
+ name: "id";
3634
+ tableName: "oauth_client_assertion";
3635
+ dataType: "string";
3636
+ columnType: "PgText";
3637
+ data: string;
3638
+ driverParam: string;
3639
+ notNull: true;
3640
+ hasDefault: false;
3641
+ isPrimaryKey: true;
3642
+ isAutoincrement: false;
3643
+ hasRuntimeDefault: false;
3644
+ enumValues: [string, ...string[]];
3645
+ baseColumn: never;
3646
+ identity: undefined;
3647
+ generated: undefined;
3648
+ }, {}, {}>;
3649
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
3650
+ name: "expires_at";
3651
+ tableName: "oauth_client_assertion";
3652
+ dataType: "date";
3653
+ columnType: "PgTimestamp";
3654
+ data: Date;
3655
+ driverParam: string;
3656
+ notNull: true;
3657
+ hasDefault: false;
3658
+ isPrimaryKey: false;
3659
+ isAutoincrement: false;
3660
+ hasRuntimeDefault: false;
3661
+ enumValues: undefined;
3662
+ baseColumn: never;
3663
+ identity: undefined;
3664
+ generated: undefined;
3665
+ }, {}, {}>;
3666
+ };
3667
+ dialect: "pg";
3668
+ }>;
3669
+ };
3670
+ export type SharedTables = ReturnType<typeof buildShared>;
3671
+ export type McpTables = ReturnType<typeof buildMcp>;
3672
+ /** The tables for the options given: `user` and `session` with or without the admin columns, the `mcp` tables or not. */
3673
+ export type AuthSchema<A extends boolean = boolean, M extends boolean = boolean> = SharedTables & {
3674
+ user: A extends true ? UserAdminTable : UserTable;
3675
+ session: A extends true ? SessionAdminTable : SessionTable;
3676
+ } & (M extends true ? McpTables : Record<never, never>);
3677
+ /** Every table with every option: what the package's own code is typed against (an option that is off leaves its columns unused). */
3678
+ export type FullSchema = AuthSchema<true, true>;
3679
+ export declare function authSchema<A extends boolean = false, M extends boolean = false>(options?: {
3680
+ admin?: A;
3681
+ mcp?: M;
3682
+ }): AuthSchema<A, M>;
3683
+ export {};