@rebasepro/server-postgresql 0.2.3 → 0.2.5

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 (63) hide show
  1. package/dist/common/src/collections/default-collections.d.ts +9 -0
  2. package/dist/common/src/collections/index.d.ts +1 -0
  3. package/dist/common/src/util/permissions.d.ts +1 -0
  4. package/dist/index.es.js +1075 -470
  5. package/dist/index.es.js.map +1 -1
  6. package/dist/index.umd.js +1071 -466
  7. package/dist/index.umd.js.map +1 -1
  8. package/dist/server-postgresql/src/PostgresBackendDriver.d.ts +3 -1
  9. package/dist/server-postgresql/src/PostgresBootstrapper.d.ts +1 -0
  10. package/dist/server-postgresql/src/auth/services.d.ts +48 -31
  11. package/dist/server-postgresql/src/connection.d.ts +25 -0
  12. package/dist/server-postgresql/src/schema/auth-schema.d.ts +2135 -41
  13. package/dist/server-postgresql/src/services/EntityFetchService.d.ts +4 -0
  14. package/dist/server-postgresql/src/services/EntityPersistService.d.ts +4 -0
  15. package/dist/server-postgresql/src/services/entityService.d.ts +6 -0
  16. package/dist/server-postgresql/src/services/realtimeService.d.ts +20 -0
  17. package/dist/server-postgresql/src/utils/drizzle-conditions.d.ts +18 -0
  18. package/dist/types/src/controllers/auth.d.ts +4 -26
  19. package/dist/types/src/controllers/client.d.ts +25 -43
  20. package/dist/types/src/controllers/collection_registry.d.ts +1 -1
  21. package/dist/types/src/controllers/data.d.ts +4 -0
  22. package/dist/types/src/controllers/data_driver.d.ts +23 -0
  23. package/dist/types/src/controllers/registry.d.ts +5 -4
  24. package/dist/types/src/rebase_context.d.ts +1 -1
  25. package/dist/types/src/types/auth_adapter.d.ts +5 -60
  26. package/dist/types/src/types/backend.d.ts +2 -2
  27. package/dist/types/src/types/backend_hooks.d.ts +2 -17
  28. package/dist/types/src/types/collections.d.ts +0 -4
  29. package/dist/types/src/types/component_ref.d.ts +1 -1
  30. package/dist/types/src/types/cron.d.ts +1 -1
  31. package/dist/types/src/types/entity_views.d.ts +1 -0
  32. package/dist/types/src/types/export_import.d.ts +1 -1
  33. package/dist/types/src/types/formex.d.ts +2 -2
  34. package/dist/types/src/types/properties.d.ts +9 -7
  35. package/dist/types/src/types/translations.d.ts +28 -12
  36. package/dist/types/src/types/user_management_delegate.d.ts +22 -57
  37. package/dist/types/src/users/index.d.ts +0 -1
  38. package/dist/types/src/users/user.d.ts +0 -1
  39. package/package.json +6 -6
  40. package/src/PostgresBackendDriver.ts +14 -2
  41. package/src/PostgresBootstrapper.ts +30 -20
  42. package/src/auth/ensure-tables.ts +116 -103
  43. package/src/auth/services.ts +347 -177
  44. package/src/connection.ts +77 -0
  45. package/src/data-transformer.ts +2 -2
  46. package/src/schema/auth-schema.ts +85 -75
  47. package/src/schema/doctor.ts +44 -3
  48. package/src/schema/generate-drizzle-schema-logic.ts +33 -3
  49. package/src/schema/generate-drizzle-schema.ts +6 -6
  50. package/src/schema/introspect-db-logic.ts +7 -0
  51. package/src/services/EntityFetchService.ts +69 -10
  52. package/src/services/EntityPersistService.ts +9 -0
  53. package/src/services/entityService.ts +9 -0
  54. package/src/services/realtimeService.ts +214 -2
  55. package/src/utils/drizzle-conditions.ts +74 -2
  56. package/src/websocket.ts +10 -2
  57. package/test/auth-services.test.ts +10 -166
  58. package/test/doctor.test.ts +6 -2
  59. package/test/drizzle-conditions.test.ts +168 -0
  60. package/vite.config.ts +1 -1
  61. package/dist/server-postgresql/src/schema/default-collections.d.ts +0 -2
  62. package/dist/types/src/users/roles.d.ts +0 -22
  63. package/src/schema/default-collections.ts +0 -69
package/dist/server-postgresql/src/schema/auth-schema.d.ts CHANGED
@@ -1,55 +1,2149 @@
1
1
  /**
2
2
  * Factory function to dynamically create the auth tables bound to the specified schema names.
3
3
  */
4
- export declare function createAuthSchema(rolesSchemaName?: string, usersSchemaName?: string): {
5
- rolesSchema: import("drizzle-orm/pg-core").PgSchema<string> | null;
4
+ export declare function createAuthSchema(usersSchemaName?: string): {
6
5
  usersSchema: import("drizzle-orm/pg-core").PgSchema<string> | null;
7
- users: any;
8
- roles: any;
9
- userRoles: any;
10
- refreshTokens: any;
11
- passwordResetTokens: any;
12
- appConfig: any;
13
- userIdentities: any;
6
+ users: import("drizzle-orm/pg-core").PgTableWithColumns<{
7
+ name: "users";
8
+ schema: undefined;
9
+ columns: {
10
+ id: import("drizzle-orm/pg-core").PgColumn<{
11
+ name: "id";
12
+ tableName: "users";
13
+ dataType: "string";
14
+ columnType: "PgUUID";
15
+ data: string;
16
+ driverParam: string;
17
+ notNull: true;
18
+ hasDefault: true;
19
+ isPrimaryKey: true;
20
+ isAutoincrement: false;
21
+ hasRuntimeDefault: false;
22
+ enumValues: undefined;
23
+ baseColumn: never;
24
+ identity: undefined;
25
+ generated: undefined;
26
+ }, {}, {}>;
27
+ email: import("drizzle-orm/pg-core").PgColumn<{
28
+ name: "email";
29
+ tableName: "users";
30
+ dataType: "string";
31
+ columnType: "PgVarchar";
32
+ data: string;
33
+ driverParam: string;
34
+ notNull: true;
35
+ hasDefault: false;
36
+ isPrimaryKey: false;
37
+ isAutoincrement: false;
38
+ hasRuntimeDefault: false;
39
+ enumValues: [string, ...string[]];
40
+ baseColumn: never;
41
+ identity: undefined;
42
+ generated: undefined;
43
+ }, {}, {
44
+ length: 255;
45
+ }>;
46
+ passwordHash: import("drizzle-orm/pg-core").PgColumn<{
47
+ name: "password_hash";
48
+ tableName: "users";
49
+ dataType: "string";
50
+ columnType: "PgVarchar";
51
+ data: string;
52
+ driverParam: string;
53
+ notNull: false;
54
+ hasDefault: false;
55
+ isPrimaryKey: false;
56
+ isAutoincrement: false;
57
+ hasRuntimeDefault: false;
58
+ enumValues: [string, ...string[]];
59
+ baseColumn: never;
60
+ identity: undefined;
61
+ generated: undefined;
62
+ }, {}, {
63
+ length: 255;
64
+ }>;
65
+ displayName: import("drizzle-orm/pg-core").PgColumn<{
66
+ name: "display_name";
67
+ tableName: "users";
68
+ dataType: "string";
69
+ columnType: "PgVarchar";
70
+ data: string;
71
+ driverParam: string;
72
+ notNull: false;
73
+ hasDefault: false;
74
+ isPrimaryKey: false;
75
+ isAutoincrement: false;
76
+ hasRuntimeDefault: false;
77
+ enumValues: [string, ...string[]];
78
+ baseColumn: never;
79
+ identity: undefined;
80
+ generated: undefined;
81
+ }, {}, {
82
+ length: 255;
83
+ }>;
84
+ photoUrl: import("drizzle-orm/pg-core").PgColumn<{
85
+ name: "photo_url";
86
+ tableName: "users";
87
+ dataType: "string";
88
+ columnType: "PgVarchar";
89
+ data: string;
90
+ driverParam: string;
91
+ notNull: false;
92
+ hasDefault: false;
93
+ isPrimaryKey: false;
94
+ isAutoincrement: false;
95
+ hasRuntimeDefault: false;
96
+ enumValues: [string, ...string[]];
97
+ baseColumn: never;
98
+ identity: undefined;
99
+ generated: undefined;
100
+ }, {}, {
101
+ length: 500;
102
+ }>;
103
+ emailVerified: import("drizzle-orm/pg-core").PgColumn<{
104
+ name: "email_verified";
105
+ tableName: "users";
106
+ dataType: "boolean";
107
+ columnType: "PgBoolean";
108
+ data: boolean;
109
+ driverParam: boolean;
110
+ notNull: true;
111
+ hasDefault: true;
112
+ isPrimaryKey: false;
113
+ isAutoincrement: false;
114
+ hasRuntimeDefault: false;
115
+ enumValues: undefined;
116
+ baseColumn: never;
117
+ identity: undefined;
118
+ generated: undefined;
119
+ }, {}, {}>;
120
+ emailVerificationToken: import("drizzle-orm/pg-core").PgColumn<{
121
+ name: "email_verification_token";
122
+ tableName: "users";
123
+ dataType: "string";
124
+ columnType: "PgVarchar";
125
+ data: string;
126
+ driverParam: string;
127
+ notNull: false;
128
+ hasDefault: false;
129
+ isPrimaryKey: false;
130
+ isAutoincrement: false;
131
+ hasRuntimeDefault: false;
132
+ enumValues: [string, ...string[]];
133
+ baseColumn: never;
134
+ identity: undefined;
135
+ generated: undefined;
136
+ }, {}, {
137
+ length: 255;
138
+ }>;
139
+ emailVerificationSentAt: import("drizzle-orm/pg-core").PgColumn<{
140
+ name: "email_verification_sent_at";
141
+ tableName: "users";
142
+ dataType: "date";
143
+ columnType: "PgTimestamp";
144
+ data: Date;
145
+ driverParam: string;
146
+ notNull: false;
147
+ hasDefault: false;
148
+ isPrimaryKey: false;
149
+ isAutoincrement: false;
150
+ hasRuntimeDefault: false;
151
+ enumValues: undefined;
152
+ baseColumn: never;
153
+ identity: undefined;
154
+ generated: undefined;
155
+ }, {}, {}>;
156
+ isAnonymous: import("drizzle-orm/pg-core").PgColumn<{
157
+ name: "is_anonymous";
158
+ tableName: "users";
159
+ dataType: "boolean";
160
+ columnType: "PgBoolean";
161
+ data: boolean;
162
+ driverParam: boolean;
163
+ notNull: true;
164
+ hasDefault: true;
165
+ isPrimaryKey: false;
166
+ isAutoincrement: false;
167
+ hasRuntimeDefault: false;
168
+ enumValues: undefined;
169
+ baseColumn: never;
170
+ identity: undefined;
171
+ generated: undefined;
172
+ }, {}, {}>;
173
+ roles: import("drizzle-orm/pg-core").PgColumn<{
174
+ name: "roles";
175
+ tableName: "users";
176
+ dataType: "array";
177
+ columnType: "PgArray";
178
+ data: string[];
179
+ driverParam: string | string[];
180
+ notNull: true;
181
+ hasDefault: true;
182
+ isPrimaryKey: false;
183
+ isAutoincrement: false;
184
+ hasRuntimeDefault: false;
185
+ enumValues: [string, ...string[]];
186
+ baseColumn: import("drizzle-orm").Column<{
187
+ name: "roles";
188
+ tableName: "users";
189
+ dataType: "string";
190
+ columnType: "PgText";
191
+ data: string;
192
+ driverParam: string;
193
+ notNull: false;
194
+ hasDefault: false;
195
+ isPrimaryKey: false;
196
+ isAutoincrement: false;
197
+ hasRuntimeDefault: false;
198
+ enumValues: [string, ...string[]];
199
+ baseColumn: never;
200
+ identity: undefined;
201
+ generated: undefined;
202
+ }, {}, {}>;
203
+ identity: undefined;
204
+ generated: undefined;
205
+ }, {}, {
206
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
207
+ name: "roles";
208
+ dataType: "string";
209
+ columnType: "PgText";
210
+ data: string;
211
+ enumValues: [string, ...string[]];
212
+ driverParam: string;
213
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
214
+ size: undefined;
215
+ }>;
216
+ metadata: import("drizzle-orm/pg-core").PgColumn<{
217
+ name: "metadata";
218
+ tableName: "users";
219
+ dataType: "json";
220
+ columnType: "PgJsonb";
221
+ data: Record<string, unknown>;
222
+ driverParam: unknown;
223
+ notNull: true;
224
+ hasDefault: true;
225
+ isPrimaryKey: false;
226
+ isAutoincrement: false;
227
+ hasRuntimeDefault: false;
228
+ enumValues: undefined;
229
+ baseColumn: never;
230
+ identity: undefined;
231
+ generated: undefined;
232
+ }, {}, {
233
+ $type: Record<string, unknown>;
234
+ }>;
235
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
236
+ name: "created_at";
237
+ tableName: "users";
238
+ dataType: "date";
239
+ columnType: "PgTimestamp";
240
+ data: Date;
241
+ driverParam: string;
242
+ notNull: true;
243
+ hasDefault: true;
244
+ isPrimaryKey: false;
245
+ isAutoincrement: false;
246
+ hasRuntimeDefault: false;
247
+ enumValues: undefined;
248
+ baseColumn: never;
249
+ identity: undefined;
250
+ generated: undefined;
251
+ }, {}, {}>;
252
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
253
+ name: "updated_at";
254
+ tableName: "users";
255
+ dataType: "date";
256
+ columnType: "PgTimestamp";
257
+ data: Date;
258
+ driverParam: string;
259
+ notNull: true;
260
+ hasDefault: true;
261
+ isPrimaryKey: false;
262
+ isAutoincrement: false;
263
+ hasRuntimeDefault: false;
264
+ enumValues: undefined;
265
+ baseColumn: never;
266
+ identity: undefined;
267
+ generated: undefined;
268
+ }, {}, {}>;
269
+ };
270
+ dialect: "pg";
271
+ }>;
272
+ refreshTokens: import("drizzle-orm/pg-core").PgTableWithColumns<{
273
+ name: "refresh_tokens";
274
+ schema: undefined;
275
+ columns: {
276
+ id: import("drizzle-orm/pg-core").PgColumn<{
277
+ name: "id";
278
+ tableName: "refresh_tokens";
279
+ dataType: "string";
280
+ columnType: "PgUUID";
281
+ data: string;
282
+ driverParam: string;
283
+ notNull: true;
284
+ hasDefault: true;
285
+ isPrimaryKey: true;
286
+ isAutoincrement: false;
287
+ hasRuntimeDefault: false;
288
+ enumValues: undefined;
289
+ baseColumn: never;
290
+ identity: undefined;
291
+ generated: undefined;
292
+ }, {}, {}>;
293
+ userId: import("drizzle-orm/pg-core").PgColumn<{
294
+ name: "user_id";
295
+ tableName: "refresh_tokens";
296
+ dataType: "string";
297
+ columnType: "PgUUID";
298
+ data: string;
299
+ driverParam: string;
300
+ notNull: true;
301
+ hasDefault: false;
302
+ isPrimaryKey: false;
303
+ isAutoincrement: false;
304
+ hasRuntimeDefault: false;
305
+ enumValues: undefined;
306
+ baseColumn: never;
307
+ identity: undefined;
308
+ generated: undefined;
309
+ }, {}, {}>;
310
+ tokenHash: import("drizzle-orm/pg-core").PgColumn<{
311
+ name: "token_hash";
312
+ tableName: "refresh_tokens";
313
+ dataType: "string";
314
+ columnType: "PgVarchar";
315
+ data: string;
316
+ driverParam: string;
317
+ notNull: true;
318
+ hasDefault: false;
319
+ isPrimaryKey: false;
320
+ isAutoincrement: false;
321
+ hasRuntimeDefault: false;
322
+ enumValues: [string, ...string[]];
323
+ baseColumn: never;
324
+ identity: undefined;
325
+ generated: undefined;
326
+ }, {}, {
327
+ length: 255;
328
+ }>;
329
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
330
+ name: "expires_at";
331
+ tableName: "refresh_tokens";
332
+ dataType: "date";
333
+ columnType: "PgTimestamp";
334
+ data: Date;
335
+ driverParam: string;
336
+ notNull: true;
337
+ hasDefault: false;
338
+ isPrimaryKey: false;
339
+ isAutoincrement: false;
340
+ hasRuntimeDefault: false;
341
+ enumValues: undefined;
342
+ baseColumn: never;
343
+ identity: undefined;
344
+ generated: undefined;
345
+ }, {}, {}>;
346
+ userAgent: import("drizzle-orm/pg-core").PgColumn<{
347
+ name: "user_agent";
348
+ tableName: "refresh_tokens";
349
+ dataType: "string";
350
+ columnType: "PgVarchar";
351
+ data: string;
352
+ driverParam: string;
353
+ notNull: false;
354
+ hasDefault: false;
355
+ isPrimaryKey: false;
356
+ isAutoincrement: false;
357
+ hasRuntimeDefault: false;
358
+ enumValues: [string, ...string[]];
359
+ baseColumn: never;
360
+ identity: undefined;
361
+ generated: undefined;
362
+ }, {}, {
363
+ length: 500;
364
+ }>;
365
+ ipAddress: import("drizzle-orm/pg-core").PgColumn<{
366
+ name: "ip_address";
367
+ tableName: "refresh_tokens";
368
+ dataType: "string";
369
+ columnType: "PgVarchar";
370
+ data: string;
371
+ driverParam: string;
372
+ notNull: false;
373
+ hasDefault: false;
374
+ isPrimaryKey: false;
375
+ isAutoincrement: false;
376
+ hasRuntimeDefault: false;
377
+ enumValues: [string, ...string[]];
378
+ baseColumn: never;
379
+ identity: undefined;
380
+ generated: undefined;
381
+ }, {}, {
382
+ length: 45;
383
+ }>;
384
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
385
+ name: "created_at";
386
+ tableName: "refresh_tokens";
387
+ dataType: "date";
388
+ columnType: "PgTimestamp";
389
+ data: Date;
390
+ driverParam: string;
391
+ notNull: true;
392
+ hasDefault: true;
393
+ isPrimaryKey: false;
394
+ isAutoincrement: false;
395
+ hasRuntimeDefault: false;
396
+ enumValues: undefined;
397
+ baseColumn: never;
398
+ identity: undefined;
399
+ generated: undefined;
400
+ }, {}, {}>;
401
+ };
402
+ dialect: "pg";
403
+ }>;
404
+ passwordResetTokens: import("drizzle-orm/pg-core").PgTableWithColumns<{
405
+ name: "password_reset_tokens";
406
+ schema: undefined;
407
+ columns: {
408
+ id: import("drizzle-orm/pg-core").PgColumn<{
409
+ name: "id";
410
+ tableName: "password_reset_tokens";
411
+ dataType: "string";
412
+ columnType: "PgUUID";
413
+ data: string;
414
+ driverParam: string;
415
+ notNull: true;
416
+ hasDefault: true;
417
+ isPrimaryKey: true;
418
+ isAutoincrement: false;
419
+ hasRuntimeDefault: false;
420
+ enumValues: undefined;
421
+ baseColumn: never;
422
+ identity: undefined;
423
+ generated: undefined;
424
+ }, {}, {}>;
425
+ userId: import("drizzle-orm/pg-core").PgColumn<{
426
+ name: "user_id";
427
+ tableName: "password_reset_tokens";
428
+ dataType: "string";
429
+ columnType: "PgUUID";
430
+ data: string;
431
+ driverParam: string;
432
+ notNull: true;
433
+ hasDefault: false;
434
+ isPrimaryKey: false;
435
+ isAutoincrement: false;
436
+ hasRuntimeDefault: false;
437
+ enumValues: undefined;
438
+ baseColumn: never;
439
+ identity: undefined;
440
+ generated: undefined;
441
+ }, {}, {}>;
442
+ tokenHash: import("drizzle-orm/pg-core").PgColumn<{
443
+ name: "token_hash";
444
+ tableName: "password_reset_tokens";
445
+ dataType: "string";
446
+ columnType: "PgVarchar";
447
+ data: string;
448
+ driverParam: string;
449
+ notNull: true;
450
+ hasDefault: false;
451
+ isPrimaryKey: false;
452
+ isAutoincrement: false;
453
+ hasRuntimeDefault: false;
454
+ enumValues: [string, ...string[]];
455
+ baseColumn: never;
456
+ identity: undefined;
457
+ generated: undefined;
458
+ }, {}, {
459
+ length: 255;
460
+ }>;
461
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
462
+ name: "expires_at";
463
+ tableName: "password_reset_tokens";
464
+ dataType: "date";
465
+ columnType: "PgTimestamp";
466
+ data: Date;
467
+ driverParam: string;
468
+ notNull: true;
469
+ hasDefault: false;
470
+ isPrimaryKey: false;
471
+ isAutoincrement: false;
472
+ hasRuntimeDefault: false;
473
+ enumValues: undefined;
474
+ baseColumn: never;
475
+ identity: undefined;
476
+ generated: undefined;
477
+ }, {}, {}>;
478
+ usedAt: import("drizzle-orm/pg-core").PgColumn<{
479
+ name: "used_at";
480
+ tableName: "password_reset_tokens";
481
+ dataType: "date";
482
+ columnType: "PgTimestamp";
483
+ data: Date;
484
+ driverParam: string;
485
+ notNull: false;
486
+ hasDefault: false;
487
+ isPrimaryKey: false;
488
+ isAutoincrement: false;
489
+ hasRuntimeDefault: false;
490
+ enumValues: undefined;
491
+ baseColumn: never;
492
+ identity: undefined;
493
+ generated: undefined;
494
+ }, {}, {}>;
495
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
496
+ name: "created_at";
497
+ tableName: "password_reset_tokens";
498
+ dataType: "date";
499
+ columnType: "PgTimestamp";
500
+ data: Date;
501
+ driverParam: string;
502
+ notNull: true;
503
+ hasDefault: true;
504
+ isPrimaryKey: false;
505
+ isAutoincrement: false;
506
+ hasRuntimeDefault: false;
507
+ enumValues: undefined;
508
+ baseColumn: never;
509
+ identity: undefined;
510
+ generated: undefined;
511
+ }, {}, {}>;
512
+ };
513
+ dialect: "pg";
514
+ }>;
515
+ appConfig: import("drizzle-orm/pg-core").PgTableWithColumns<{
516
+ name: "app_config";
517
+ schema: undefined;
518
+ columns: {
519
+ key: import("drizzle-orm/pg-core").PgColumn<{
520
+ name: "key";
521
+ tableName: "app_config";
522
+ dataType: "string";
523
+ columnType: "PgVarchar";
524
+ data: string;
525
+ driverParam: string;
526
+ notNull: true;
527
+ hasDefault: false;
528
+ isPrimaryKey: true;
529
+ isAutoincrement: false;
530
+ hasRuntimeDefault: false;
531
+ enumValues: [string, ...string[]];
532
+ baseColumn: never;
533
+ identity: undefined;
534
+ generated: undefined;
535
+ }, {}, {
536
+ length: 100;
537
+ }>;
538
+ value: import("drizzle-orm/pg-core").PgColumn<{
539
+ name: "value";
540
+ tableName: "app_config";
541
+ dataType: "json";
542
+ columnType: "PgJsonb";
543
+ data: unknown;
544
+ driverParam: unknown;
545
+ notNull: true;
546
+ hasDefault: false;
547
+ isPrimaryKey: false;
548
+ isAutoincrement: false;
549
+ hasRuntimeDefault: false;
550
+ enumValues: undefined;
551
+ baseColumn: never;
552
+ identity: undefined;
553
+ generated: undefined;
554
+ }, {}, {}>;
555
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
556
+ name: "updated_at";
557
+ tableName: "app_config";
558
+ dataType: "date";
559
+ columnType: "PgTimestamp";
560
+ data: Date;
561
+ driverParam: string;
562
+ notNull: true;
563
+ hasDefault: true;
564
+ isPrimaryKey: false;
565
+ isAutoincrement: false;
566
+ hasRuntimeDefault: false;
567
+ enumValues: undefined;
568
+ baseColumn: never;
569
+ identity: undefined;
570
+ generated: undefined;
571
+ }, {}, {}>;
572
+ };
573
+ dialect: "pg";
574
+ }>;
575
+ userIdentities: import("drizzle-orm/pg-core").PgTableWithColumns<{
576
+ name: "user_identities";
577
+ schema: undefined;
578
+ columns: {
579
+ id: import("drizzle-orm/pg-core").PgColumn<{
580
+ name: "id";
581
+ tableName: "user_identities";
582
+ dataType: "string";
583
+ columnType: "PgUUID";
584
+ data: string;
585
+ driverParam: string;
586
+ notNull: true;
587
+ hasDefault: true;
588
+ isPrimaryKey: true;
589
+ isAutoincrement: false;
590
+ hasRuntimeDefault: false;
591
+ enumValues: undefined;
592
+ baseColumn: never;
593
+ identity: undefined;
594
+ generated: undefined;
595
+ }, {}, {}>;
596
+ userId: import("drizzle-orm/pg-core").PgColumn<{
597
+ name: "user_id";
598
+ tableName: "user_identities";
599
+ dataType: "string";
600
+ columnType: "PgUUID";
601
+ data: string;
602
+ driverParam: string;
603
+ notNull: true;
604
+ hasDefault: false;
605
+ isPrimaryKey: false;
606
+ isAutoincrement: false;
607
+ hasRuntimeDefault: false;
608
+ enumValues: undefined;
609
+ baseColumn: never;
610
+ identity: undefined;
611
+ generated: undefined;
612
+ }, {}, {}>;
613
+ provider: import("drizzle-orm/pg-core").PgColumn<{
614
+ name: "provider";
615
+ tableName: "user_identities";
616
+ dataType: "string";
617
+ columnType: "PgVarchar";
618
+ data: string;
619
+ driverParam: string;
620
+ notNull: true;
621
+ hasDefault: false;
622
+ isPrimaryKey: false;
623
+ isAutoincrement: false;
624
+ hasRuntimeDefault: false;
625
+ enumValues: [string, ...string[]];
626
+ baseColumn: never;
627
+ identity: undefined;
628
+ generated: undefined;
629
+ }, {}, {
630
+ length: 50;
631
+ }>;
632
+ providerId: import("drizzle-orm/pg-core").PgColumn<{
633
+ name: "provider_id";
634
+ tableName: "user_identities";
635
+ dataType: "string";
636
+ columnType: "PgVarchar";
637
+ data: string;
638
+ driverParam: string;
639
+ notNull: true;
640
+ hasDefault: false;
641
+ isPrimaryKey: false;
642
+ isAutoincrement: false;
643
+ hasRuntimeDefault: false;
644
+ enumValues: [string, ...string[]];
645
+ baseColumn: never;
646
+ identity: undefined;
647
+ generated: undefined;
648
+ }, {}, {
649
+ length: 255;
650
+ }>;
651
+ profileData: import("drizzle-orm/pg-core").PgColumn<{
652
+ name: "profile_data";
653
+ tableName: "user_identities";
654
+ dataType: "json";
655
+ columnType: "PgJsonb";
656
+ data: unknown;
657
+ driverParam: unknown;
658
+ notNull: false;
659
+ hasDefault: false;
660
+ isPrimaryKey: false;
661
+ isAutoincrement: false;
662
+ hasRuntimeDefault: false;
663
+ enumValues: undefined;
664
+ baseColumn: never;
665
+ identity: undefined;
666
+ generated: undefined;
667
+ }, {}, {}>;
668
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
669
+ name: "created_at";
670
+ tableName: "user_identities";
671
+ dataType: "date";
672
+ columnType: "PgTimestamp";
673
+ data: Date;
674
+ driverParam: string;
675
+ notNull: true;
676
+ hasDefault: true;
677
+ isPrimaryKey: false;
678
+ isAutoincrement: false;
679
+ hasRuntimeDefault: false;
680
+ enumValues: undefined;
681
+ baseColumn: never;
682
+ identity: undefined;
683
+ generated: undefined;
684
+ }, {}, {}>;
685
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
686
+ name: "updated_at";
687
+ tableName: "user_identities";
688
+ dataType: "date";
689
+ columnType: "PgTimestamp";
690
+ data: Date;
691
+ driverParam: string;
692
+ notNull: true;
693
+ hasDefault: true;
694
+ isPrimaryKey: false;
695
+ isAutoincrement: false;
696
+ hasRuntimeDefault: false;
697
+ enumValues: undefined;
698
+ baseColumn: never;
699
+ identity: undefined;
700
+ generated: undefined;
701
+ }, {}, {}>;
702
+ };
703
+ dialect: "pg";
704
+ }>;
705
+ mfaFactors: import("drizzle-orm/pg-core").PgTableWithColumns<{
706
+ name: "mfa_factors";
707
+ schema: undefined;
708
+ columns: {
709
+ id: import("drizzle-orm/pg-core").PgColumn<{
710
+ name: "id";
711
+ tableName: "mfa_factors";
712
+ dataType: "string";
713
+ columnType: "PgUUID";
714
+ data: string;
715
+ driverParam: string;
716
+ notNull: true;
717
+ hasDefault: true;
718
+ isPrimaryKey: true;
719
+ isAutoincrement: false;
720
+ hasRuntimeDefault: false;
721
+ enumValues: undefined;
722
+ baseColumn: never;
723
+ identity: undefined;
724
+ generated: undefined;
725
+ }, {}, {}>;
726
+ userId: import("drizzle-orm/pg-core").PgColumn<{
727
+ name: "user_id";
728
+ tableName: "mfa_factors";
729
+ dataType: "string";
730
+ columnType: "PgUUID";
731
+ data: string;
732
+ driverParam: string;
733
+ notNull: true;
734
+ hasDefault: false;
735
+ isPrimaryKey: false;
736
+ isAutoincrement: false;
737
+ hasRuntimeDefault: false;
738
+ enumValues: undefined;
739
+ baseColumn: never;
740
+ identity: undefined;
741
+ generated: undefined;
742
+ }, {}, {}>;
743
+ factorType: import("drizzle-orm/pg-core").PgColumn<{
744
+ name: "factor_type";
745
+ tableName: "mfa_factors";
746
+ dataType: "string";
747
+ columnType: "PgVarchar";
748
+ data: string;
749
+ driverParam: string;
750
+ notNull: true;
751
+ hasDefault: false;
752
+ isPrimaryKey: false;
753
+ isAutoincrement: false;
754
+ hasRuntimeDefault: false;
755
+ enumValues: [string, ...string[]];
756
+ baseColumn: never;
757
+ identity: undefined;
758
+ generated: undefined;
759
+ }, {}, {
760
+ length: 20;
761
+ }>;
762
+ secretEncrypted: import("drizzle-orm/pg-core").PgColumn<{
763
+ name: "secret_encrypted";
764
+ tableName: "mfa_factors";
765
+ dataType: "string";
766
+ columnType: "PgVarchar";
767
+ data: string;
768
+ driverParam: string;
769
+ notNull: true;
770
+ hasDefault: false;
771
+ isPrimaryKey: false;
772
+ isAutoincrement: false;
773
+ hasRuntimeDefault: false;
774
+ enumValues: [string, ...string[]];
775
+ baseColumn: never;
776
+ identity: undefined;
777
+ generated: undefined;
778
+ }, {}, {
779
+ length: 500;
780
+ }>;
781
+ friendlyName: import("drizzle-orm/pg-core").PgColumn<{
782
+ name: "friendly_name";
783
+ tableName: "mfa_factors";
784
+ dataType: "string";
785
+ columnType: "PgVarchar";
786
+ data: string;
787
+ driverParam: string;
788
+ notNull: false;
789
+ hasDefault: false;
790
+ isPrimaryKey: false;
791
+ isAutoincrement: false;
792
+ hasRuntimeDefault: false;
793
+ enumValues: [string, ...string[]];
794
+ baseColumn: never;
795
+ identity: undefined;
796
+ generated: undefined;
797
+ }, {}, {
798
+ length: 255;
799
+ }>;
800
+ verified: import("drizzle-orm/pg-core").PgColumn<{
801
+ name: "verified";
802
+ tableName: "mfa_factors";
803
+ dataType: "boolean";
804
+ columnType: "PgBoolean";
805
+ data: boolean;
806
+ driverParam: boolean;
807
+ notNull: true;
808
+ hasDefault: true;
809
+ isPrimaryKey: false;
810
+ isAutoincrement: false;
811
+ hasRuntimeDefault: false;
812
+ enumValues: undefined;
813
+ baseColumn: never;
814
+ identity: undefined;
815
+ generated: undefined;
816
+ }, {}, {}>;
817
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
818
+ name: "created_at";
819
+ tableName: "mfa_factors";
820
+ dataType: "date";
821
+ columnType: "PgTimestamp";
822
+ data: Date;
823
+ driverParam: string;
824
+ notNull: true;
825
+ hasDefault: true;
826
+ isPrimaryKey: false;
827
+ isAutoincrement: false;
828
+ hasRuntimeDefault: false;
829
+ enumValues: undefined;
830
+ baseColumn: never;
831
+ identity: undefined;
832
+ generated: undefined;
833
+ }, {}, {}>;
834
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
835
+ name: "updated_at";
836
+ tableName: "mfa_factors";
837
+ dataType: "date";
838
+ columnType: "PgTimestamp";
839
+ data: Date;
840
+ driverParam: string;
841
+ notNull: true;
842
+ hasDefault: true;
843
+ isPrimaryKey: false;
844
+ isAutoincrement: false;
845
+ hasRuntimeDefault: false;
846
+ enumValues: undefined;
847
+ baseColumn: never;
848
+ identity: undefined;
849
+ generated: undefined;
850
+ }, {}, {}>;
851
+ };
852
+ dialect: "pg";
853
+ }>;
854
+ mfaChallenges: import("drizzle-orm/pg-core").PgTableWithColumns<{
855
+ name: "mfa_challenges";
856
+ schema: undefined;
857
+ columns: {
858
+ id: import("drizzle-orm/pg-core").PgColumn<{
859
+ name: "id";
860
+ tableName: "mfa_challenges";
861
+ dataType: "string";
862
+ columnType: "PgUUID";
863
+ data: string;
864
+ driverParam: string;
865
+ notNull: true;
866
+ hasDefault: true;
867
+ isPrimaryKey: true;
868
+ isAutoincrement: false;
869
+ hasRuntimeDefault: false;
870
+ enumValues: undefined;
871
+ baseColumn: never;
872
+ identity: undefined;
873
+ generated: undefined;
874
+ }, {}, {}>;
875
+ factorId: import("drizzle-orm/pg-core").PgColumn<{
876
+ name: "factor_id";
877
+ tableName: "mfa_challenges";
878
+ dataType: "string";
879
+ columnType: "PgUUID";
880
+ data: string;
881
+ driverParam: string;
882
+ notNull: true;
883
+ hasDefault: false;
884
+ isPrimaryKey: false;
885
+ isAutoincrement: false;
886
+ hasRuntimeDefault: false;
887
+ enumValues: undefined;
888
+ baseColumn: never;
889
+ identity: undefined;
890
+ generated: undefined;
891
+ }, {}, {}>;
892
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
893
+ name: "created_at";
894
+ tableName: "mfa_challenges";
895
+ dataType: "date";
896
+ columnType: "PgTimestamp";
897
+ data: Date;
898
+ driverParam: string;
899
+ notNull: true;
900
+ hasDefault: true;
901
+ isPrimaryKey: false;
902
+ isAutoincrement: false;
903
+ hasRuntimeDefault: false;
904
+ enumValues: undefined;
905
+ baseColumn: never;
906
+ identity: undefined;
907
+ generated: undefined;
908
+ }, {}, {}>;
909
+ verifiedAt: import("drizzle-orm/pg-core").PgColumn<{
910
+ name: "verified_at";
911
+ tableName: "mfa_challenges";
912
+ dataType: "date";
913
+ columnType: "PgTimestamp";
914
+ data: Date;
915
+ driverParam: string;
916
+ notNull: false;
917
+ hasDefault: false;
918
+ isPrimaryKey: false;
919
+ isAutoincrement: false;
920
+ hasRuntimeDefault: false;
921
+ enumValues: undefined;
922
+ baseColumn: never;
923
+ identity: undefined;
924
+ generated: undefined;
925
+ }, {}, {}>;
926
+ ipAddress: import("drizzle-orm/pg-core").PgColumn<{
927
+ name: "ip_address";
928
+ tableName: "mfa_challenges";
929
+ dataType: "string";
930
+ columnType: "PgVarchar";
931
+ data: string;
932
+ driverParam: string;
933
+ notNull: false;
934
+ hasDefault: false;
935
+ isPrimaryKey: false;
936
+ isAutoincrement: false;
937
+ hasRuntimeDefault: false;
938
+ enumValues: [string, ...string[]];
939
+ baseColumn: never;
940
+ identity: undefined;
941
+ generated: undefined;
942
+ }, {}, {
943
+ length: 45;
944
+ }>;
945
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
946
+ name: "expires_at";
947
+ tableName: "mfa_challenges";
948
+ dataType: "date";
949
+ columnType: "PgTimestamp";
950
+ data: Date;
951
+ driverParam: string;
952
+ notNull: true;
953
+ hasDefault: false;
954
+ isPrimaryKey: false;
955
+ isAutoincrement: false;
956
+ hasRuntimeDefault: false;
957
+ enumValues: undefined;
958
+ baseColumn: never;
959
+ identity: undefined;
960
+ generated: undefined;
961
+ }, {}, {}>;
962
+ };
963
+ dialect: "pg";
964
+ }>;
965
+ recoveryCodes: import("drizzle-orm/pg-core").PgTableWithColumns<{
966
+ name: "recovery_codes";
967
+ schema: undefined;
968
+ columns: {
969
+ id: import("drizzle-orm/pg-core").PgColumn<{
970
+ name: "id";
971
+ tableName: "recovery_codes";
972
+ dataType: "string";
973
+ columnType: "PgUUID";
974
+ data: string;
975
+ driverParam: string;
976
+ notNull: true;
977
+ hasDefault: true;
978
+ isPrimaryKey: true;
979
+ isAutoincrement: false;
980
+ hasRuntimeDefault: false;
981
+ enumValues: undefined;
982
+ baseColumn: never;
983
+ identity: undefined;
984
+ generated: undefined;
985
+ }, {}, {}>;
986
+ userId: import("drizzle-orm/pg-core").PgColumn<{
987
+ name: "user_id";
988
+ tableName: "recovery_codes";
989
+ dataType: "string";
990
+ columnType: "PgUUID";
991
+ data: string;
992
+ driverParam: string;
993
+ notNull: true;
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
+ codeHash: import("drizzle-orm/pg-core").PgColumn<{
1004
+ name: "code_hash";
1005
+ tableName: "recovery_codes";
1006
+ dataType: "string";
1007
+ columnType: "PgVarchar";
1008
+ data: string;
1009
+ driverParam: string;
1010
+ notNull: true;
1011
+ hasDefault: false;
1012
+ isPrimaryKey: false;
1013
+ isAutoincrement: false;
1014
+ hasRuntimeDefault: false;
1015
+ enumValues: [string, ...string[]];
1016
+ baseColumn: never;
1017
+ identity: undefined;
1018
+ generated: undefined;
1019
+ }, {}, {
1020
+ length: 255;
1021
+ }>;
1022
+ usedAt: import("drizzle-orm/pg-core").PgColumn<{
1023
+ name: "used_at";
1024
+ tableName: "recovery_codes";
1025
+ dataType: "date";
1026
+ columnType: "PgTimestamp";
1027
+ data: Date;
1028
+ driverParam: string;
1029
+ notNull: false;
1030
+ hasDefault: false;
1031
+ isPrimaryKey: false;
1032
+ isAutoincrement: false;
1033
+ hasRuntimeDefault: false;
1034
+ enumValues: undefined;
1035
+ baseColumn: never;
1036
+ identity: undefined;
1037
+ generated: undefined;
1038
+ }, {}, {}>;
1039
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1040
+ name: "created_at";
1041
+ tableName: "recovery_codes";
1042
+ dataType: "date";
1043
+ columnType: "PgTimestamp";
1044
+ data: Date;
1045
+ driverParam: string;
1046
+ notNull: true;
1047
+ hasDefault: true;
1048
+ isPrimaryKey: false;
1049
+ isAutoincrement: false;
1050
+ hasRuntimeDefault: false;
1051
+ enumValues: undefined;
1052
+ baseColumn: never;
1053
+ identity: undefined;
1054
+ generated: undefined;
1055
+ }, {}, {}>;
1056
+ };
1057
+ dialect: "pg";
1058
+ }>;
14
1059
  };
15
- export declare const rebaseSchema: import("drizzle-orm/pg-core").PgSchema<string> | null;
16
1060
  export declare const usersSchema: import("drizzle-orm/pg-core").PgSchema<string> | null;
17
- export declare const users: any;
18
- export declare const roles: any;
19
- export declare const userRoles: any;
20
- export declare const refreshTokens: any;
21
- export declare const passwordResetTokens: any;
22
- export declare const appConfig: any;
23
- export declare const userIdentities: any;
24
- export declare const usersRelations: import("drizzle-orm").Relations<string, {
25
- userRoles: import("drizzle-orm").Many<any>;
26
- refreshTokens: import("drizzle-orm").Many<any>;
27
- passwordResetTokens: import("drizzle-orm").Many<any>;
28
- userIdentities: import("drizzle-orm").Many<any>;
29
- }>;
30
- export declare const rolesRelations: import("drizzle-orm").Relations<string, {
31
- userRoles: import("drizzle-orm").Many<any>;
32
- }>;
33
- export declare const userRolesRelations: import("drizzle-orm").Relations<string, {
34
- user: import("drizzle-orm").One<any, false>;
35
- role: import("drizzle-orm").One<any, false>;
36
- }>;
37
- export declare const refreshTokensRelations: import("drizzle-orm").Relations<string, {
38
- user: import("drizzle-orm").One<any, false>;
39
- }>;
40
- export declare const passwordResetTokensRelations: import("drizzle-orm").Relations<string, {
41
- user: import("drizzle-orm").One<any, false>;
42
- }>;
43
- export declare const userIdentitiesRelations: import("drizzle-orm").Relations<string, {
44
- user: import("drizzle-orm").One<any, false>;
1061
+ export declare const users: import("drizzle-orm/pg-core").PgTableWithColumns<{
1062
+ name: "users";
1063
+ schema: undefined;
1064
+ columns: {
1065
+ id: import("drizzle-orm/pg-core").PgColumn<{
1066
+ name: "id";
1067
+ tableName: "users";
1068
+ dataType: "string";
1069
+ columnType: "PgUUID";
1070
+ data: string;
1071
+ driverParam: string;
1072
+ notNull: true;
1073
+ hasDefault: true;
1074
+ isPrimaryKey: true;
1075
+ isAutoincrement: false;
1076
+ hasRuntimeDefault: false;
1077
+ enumValues: undefined;
1078
+ baseColumn: never;
1079
+ identity: undefined;
1080
+ generated: undefined;
1081
+ }, {}, {}>;
1082
+ email: import("drizzle-orm/pg-core").PgColumn<{
1083
+ name: "email";
1084
+ tableName: "users";
1085
+ dataType: "string";
1086
+ columnType: "PgVarchar";
1087
+ data: string;
1088
+ driverParam: string;
1089
+ notNull: true;
1090
+ hasDefault: false;
1091
+ isPrimaryKey: false;
1092
+ isAutoincrement: false;
1093
+ hasRuntimeDefault: false;
1094
+ enumValues: [string, ...string[]];
1095
+ baseColumn: never;
1096
+ identity: undefined;
1097
+ generated: undefined;
1098
+ }, {}, {
1099
+ length: 255;
1100
+ }>;
1101
+ passwordHash: import("drizzle-orm/pg-core").PgColumn<{
1102
+ name: "password_hash";
1103
+ tableName: "users";
1104
+ dataType: "string";
1105
+ columnType: "PgVarchar";
1106
+ data: string;
1107
+ driverParam: string;
1108
+ notNull: false;
1109
+ hasDefault: false;
1110
+ isPrimaryKey: false;
1111
+ isAutoincrement: false;
1112
+ hasRuntimeDefault: false;
1113
+ enumValues: [string, ...string[]];
1114
+ baseColumn: never;
1115
+ identity: undefined;
1116
+ generated: undefined;
1117
+ }, {}, {
1118
+ length: 255;
1119
+ }>;
1120
+ displayName: import("drizzle-orm/pg-core").PgColumn<{
1121
+ name: "display_name";
1122
+ tableName: "users";
1123
+ dataType: "string";
1124
+ columnType: "PgVarchar";
1125
+ data: string;
1126
+ driverParam: string;
1127
+ notNull: false;
1128
+ hasDefault: false;
1129
+ isPrimaryKey: false;
1130
+ isAutoincrement: false;
1131
+ hasRuntimeDefault: false;
1132
+ enumValues: [string, ...string[]];
1133
+ baseColumn: never;
1134
+ identity: undefined;
1135
+ generated: undefined;
1136
+ }, {}, {
1137
+ length: 255;
1138
+ }>;
1139
+ photoUrl: import("drizzle-orm/pg-core").PgColumn<{
1140
+ name: "photo_url";
1141
+ tableName: "users";
1142
+ dataType: "string";
1143
+ columnType: "PgVarchar";
1144
+ data: string;
1145
+ driverParam: string;
1146
+ notNull: false;
1147
+ hasDefault: false;
1148
+ isPrimaryKey: false;
1149
+ isAutoincrement: false;
1150
+ hasRuntimeDefault: false;
1151
+ enumValues: [string, ...string[]];
1152
+ baseColumn: never;
1153
+ identity: undefined;
1154
+ generated: undefined;
1155
+ }, {}, {
1156
+ length: 500;
1157
+ }>;
1158
+ emailVerified: import("drizzle-orm/pg-core").PgColumn<{
1159
+ name: "email_verified";
1160
+ tableName: "users";
1161
+ dataType: "boolean";
1162
+ columnType: "PgBoolean";
1163
+ data: boolean;
1164
+ driverParam: boolean;
1165
+ notNull: true;
1166
+ hasDefault: true;
1167
+ isPrimaryKey: false;
1168
+ isAutoincrement: false;
1169
+ hasRuntimeDefault: false;
1170
+ enumValues: undefined;
1171
+ baseColumn: never;
1172
+ identity: undefined;
1173
+ generated: undefined;
1174
+ }, {}, {}>;
1175
+ emailVerificationToken: import("drizzle-orm/pg-core").PgColumn<{
1176
+ name: "email_verification_token";
1177
+ tableName: "users";
1178
+ dataType: "string";
1179
+ columnType: "PgVarchar";
1180
+ data: string;
1181
+ driverParam: string;
1182
+ notNull: false;
1183
+ hasDefault: false;
1184
+ isPrimaryKey: false;
1185
+ isAutoincrement: false;
1186
+ hasRuntimeDefault: false;
1187
+ enumValues: [string, ...string[]];
1188
+ baseColumn: never;
1189
+ identity: undefined;
1190
+ generated: undefined;
1191
+ }, {}, {
1192
+ length: 255;
1193
+ }>;
1194
+ emailVerificationSentAt: import("drizzle-orm/pg-core").PgColumn<{
1195
+ name: "email_verification_sent_at";
1196
+ tableName: "users";
1197
+ dataType: "date";
1198
+ columnType: "PgTimestamp";
1199
+ data: Date;
1200
+ driverParam: string;
1201
+ notNull: false;
1202
+ hasDefault: false;
1203
+ isPrimaryKey: false;
1204
+ isAutoincrement: false;
1205
+ hasRuntimeDefault: false;
1206
+ enumValues: undefined;
1207
+ baseColumn: never;
1208
+ identity: undefined;
1209
+ generated: undefined;
1210
+ }, {}, {}>;
1211
+ isAnonymous: import("drizzle-orm/pg-core").PgColumn<{
1212
+ name: "is_anonymous";
1213
+ tableName: "users";
1214
+ dataType: "boolean";
1215
+ columnType: "PgBoolean";
1216
+ data: boolean;
1217
+ driverParam: boolean;
1218
+ notNull: true;
1219
+ hasDefault: true;
1220
+ isPrimaryKey: false;
1221
+ isAutoincrement: false;
1222
+ hasRuntimeDefault: false;
1223
+ enumValues: undefined;
1224
+ baseColumn: never;
1225
+ identity: undefined;
1226
+ generated: undefined;
1227
+ }, {}, {}>;
1228
+ roles: import("drizzle-orm/pg-core").PgColumn<{
1229
+ name: "roles";
1230
+ tableName: "users";
1231
+ dataType: "array";
1232
+ columnType: "PgArray";
1233
+ data: string[];
1234
+ driverParam: string | string[];
1235
+ notNull: true;
1236
+ hasDefault: true;
1237
+ isPrimaryKey: false;
1238
+ isAutoincrement: false;
1239
+ hasRuntimeDefault: false;
1240
+ enumValues: [string, ...string[]];
1241
+ baseColumn: import("drizzle-orm").Column<{
1242
+ name: "roles";
1243
+ tableName: "users";
1244
+ dataType: "string";
1245
+ columnType: "PgText";
1246
+ data: string;
1247
+ driverParam: string;
1248
+ notNull: false;
1249
+ hasDefault: false;
1250
+ isPrimaryKey: false;
1251
+ isAutoincrement: false;
1252
+ hasRuntimeDefault: false;
1253
+ enumValues: [string, ...string[]];
1254
+ baseColumn: never;
1255
+ identity: undefined;
1256
+ generated: undefined;
1257
+ }, {}, {}>;
1258
+ identity: undefined;
1259
+ generated: undefined;
1260
+ }, {}, {
1261
+ baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
1262
+ name: "roles";
1263
+ dataType: "string";
1264
+ columnType: "PgText";
1265
+ data: string;
1266
+ enumValues: [string, ...string[]];
1267
+ driverParam: string;
1268
+ }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
1269
+ size: undefined;
1270
+ }>;
1271
+ metadata: import("drizzle-orm/pg-core").PgColumn<{
1272
+ name: "metadata";
1273
+ tableName: "users";
1274
+ dataType: "json";
1275
+ columnType: "PgJsonb";
1276
+ data: Record<string, unknown>;
1277
+ driverParam: unknown;
1278
+ notNull: true;
1279
+ hasDefault: true;
1280
+ isPrimaryKey: false;
1281
+ isAutoincrement: false;
1282
+ hasRuntimeDefault: false;
1283
+ enumValues: undefined;
1284
+ baseColumn: never;
1285
+ identity: undefined;
1286
+ generated: undefined;
1287
+ }, {}, {
1288
+ $type: Record<string, unknown>;
1289
+ }>;
1290
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1291
+ name: "created_at";
1292
+ tableName: "users";
1293
+ dataType: "date";
1294
+ columnType: "PgTimestamp";
1295
+ data: Date;
1296
+ driverParam: string;
1297
+ notNull: true;
1298
+ hasDefault: true;
1299
+ isPrimaryKey: false;
1300
+ isAutoincrement: false;
1301
+ hasRuntimeDefault: false;
1302
+ enumValues: undefined;
1303
+ baseColumn: never;
1304
+ identity: undefined;
1305
+ generated: undefined;
1306
+ }, {}, {}>;
1307
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1308
+ name: "updated_at";
1309
+ tableName: "users";
1310
+ dataType: "date";
1311
+ columnType: "PgTimestamp";
1312
+ data: Date;
1313
+ driverParam: string;
1314
+ notNull: true;
1315
+ hasDefault: true;
1316
+ isPrimaryKey: false;
1317
+ isAutoincrement: false;
1318
+ hasRuntimeDefault: false;
1319
+ enumValues: undefined;
1320
+ baseColumn: never;
1321
+ identity: undefined;
1322
+ generated: undefined;
1323
+ }, {}, {}>;
1324
+ };
1325
+ dialect: "pg";
1326
+ }>;
1327
+ export declare const refreshTokens: import("drizzle-orm/pg-core").PgTableWithColumns<{
1328
+ name: "refresh_tokens";
1329
+ schema: undefined;
1330
+ columns: {
1331
+ id: import("drizzle-orm/pg-core").PgColumn<{
1332
+ name: "id";
1333
+ tableName: "refresh_tokens";
1334
+ dataType: "string";
1335
+ columnType: "PgUUID";
1336
+ data: string;
1337
+ driverParam: string;
1338
+ notNull: true;
1339
+ hasDefault: true;
1340
+ isPrimaryKey: true;
1341
+ isAutoincrement: false;
1342
+ hasRuntimeDefault: false;
1343
+ enumValues: undefined;
1344
+ baseColumn: never;
1345
+ identity: undefined;
1346
+ generated: undefined;
1347
+ }, {}, {}>;
1348
+ userId: import("drizzle-orm/pg-core").PgColumn<{
1349
+ name: "user_id";
1350
+ tableName: "refresh_tokens";
1351
+ dataType: "string";
1352
+ columnType: "PgUUID";
1353
+ data: string;
1354
+ driverParam: string;
1355
+ notNull: true;
1356
+ hasDefault: false;
1357
+ isPrimaryKey: false;
1358
+ isAutoincrement: false;
1359
+ hasRuntimeDefault: false;
1360
+ enumValues: undefined;
1361
+ baseColumn: never;
1362
+ identity: undefined;
1363
+ generated: undefined;
1364
+ }, {}, {}>;
1365
+ tokenHash: import("drizzle-orm/pg-core").PgColumn<{
1366
+ name: "token_hash";
1367
+ tableName: "refresh_tokens";
1368
+ dataType: "string";
1369
+ columnType: "PgVarchar";
1370
+ data: string;
1371
+ driverParam: string;
1372
+ notNull: true;
1373
+ hasDefault: false;
1374
+ isPrimaryKey: false;
1375
+ isAutoincrement: false;
1376
+ hasRuntimeDefault: false;
1377
+ enumValues: [string, ...string[]];
1378
+ baseColumn: never;
1379
+ identity: undefined;
1380
+ generated: undefined;
1381
+ }, {}, {
1382
+ length: 255;
1383
+ }>;
1384
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
1385
+ name: "expires_at";
1386
+ tableName: "refresh_tokens";
1387
+ dataType: "date";
1388
+ columnType: "PgTimestamp";
1389
+ data: Date;
1390
+ driverParam: string;
1391
+ notNull: true;
1392
+ hasDefault: false;
1393
+ isPrimaryKey: false;
1394
+ isAutoincrement: false;
1395
+ hasRuntimeDefault: false;
1396
+ enumValues: undefined;
1397
+ baseColumn: never;
1398
+ identity: undefined;
1399
+ generated: undefined;
1400
+ }, {}, {}>;
1401
+ userAgent: import("drizzle-orm/pg-core").PgColumn<{
1402
+ name: "user_agent";
1403
+ tableName: "refresh_tokens";
1404
+ dataType: "string";
1405
+ columnType: "PgVarchar";
1406
+ data: string;
1407
+ driverParam: string;
1408
+ notNull: false;
1409
+ hasDefault: false;
1410
+ isPrimaryKey: false;
1411
+ isAutoincrement: false;
1412
+ hasRuntimeDefault: false;
1413
+ enumValues: [string, ...string[]];
1414
+ baseColumn: never;
1415
+ identity: undefined;
1416
+ generated: undefined;
1417
+ }, {}, {
1418
+ length: 500;
1419
+ }>;
1420
+ ipAddress: import("drizzle-orm/pg-core").PgColumn<{
1421
+ name: "ip_address";
1422
+ tableName: "refresh_tokens";
1423
+ dataType: "string";
1424
+ columnType: "PgVarchar";
1425
+ data: string;
1426
+ driverParam: string;
1427
+ notNull: false;
1428
+ hasDefault: false;
1429
+ isPrimaryKey: false;
1430
+ isAutoincrement: false;
1431
+ hasRuntimeDefault: false;
1432
+ enumValues: [string, ...string[]];
1433
+ baseColumn: never;
1434
+ identity: undefined;
1435
+ generated: undefined;
1436
+ }, {}, {
1437
+ length: 45;
1438
+ }>;
1439
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1440
+ name: "created_at";
1441
+ tableName: "refresh_tokens";
1442
+ dataType: "date";
1443
+ columnType: "PgTimestamp";
1444
+ data: Date;
1445
+ driverParam: string;
1446
+ notNull: true;
1447
+ hasDefault: true;
1448
+ isPrimaryKey: false;
1449
+ isAutoincrement: false;
1450
+ hasRuntimeDefault: false;
1451
+ enumValues: undefined;
1452
+ baseColumn: never;
1453
+ identity: undefined;
1454
+ generated: undefined;
1455
+ }, {}, {}>;
1456
+ };
1457
+ dialect: "pg";
1458
+ }>;
1459
+ export declare const passwordResetTokens: import("drizzle-orm/pg-core").PgTableWithColumns<{
1460
+ name: "password_reset_tokens";
1461
+ schema: undefined;
1462
+ columns: {
1463
+ id: import("drizzle-orm/pg-core").PgColumn<{
1464
+ name: "id";
1465
+ tableName: "password_reset_tokens";
1466
+ dataType: "string";
1467
+ columnType: "PgUUID";
1468
+ data: string;
1469
+ driverParam: string;
1470
+ notNull: true;
1471
+ hasDefault: true;
1472
+ isPrimaryKey: true;
1473
+ isAutoincrement: false;
1474
+ hasRuntimeDefault: false;
1475
+ enumValues: undefined;
1476
+ baseColumn: never;
1477
+ identity: undefined;
1478
+ generated: undefined;
1479
+ }, {}, {}>;
1480
+ userId: import("drizzle-orm/pg-core").PgColumn<{
1481
+ name: "user_id";
1482
+ tableName: "password_reset_tokens";
1483
+ dataType: "string";
1484
+ columnType: "PgUUID";
1485
+ data: string;
1486
+ driverParam: string;
1487
+ notNull: true;
1488
+ hasDefault: false;
1489
+ isPrimaryKey: false;
1490
+ isAutoincrement: false;
1491
+ hasRuntimeDefault: false;
1492
+ enumValues: undefined;
1493
+ baseColumn: never;
1494
+ identity: undefined;
1495
+ generated: undefined;
1496
+ }, {}, {}>;
1497
+ tokenHash: import("drizzle-orm/pg-core").PgColumn<{
1498
+ name: "token_hash";
1499
+ tableName: "password_reset_tokens";
1500
+ dataType: "string";
1501
+ columnType: "PgVarchar";
1502
+ data: string;
1503
+ driverParam: string;
1504
+ notNull: true;
1505
+ hasDefault: false;
1506
+ isPrimaryKey: false;
1507
+ isAutoincrement: false;
1508
+ hasRuntimeDefault: false;
1509
+ enumValues: [string, ...string[]];
1510
+ baseColumn: never;
1511
+ identity: undefined;
1512
+ generated: undefined;
1513
+ }, {}, {
1514
+ length: 255;
1515
+ }>;
1516
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
1517
+ name: "expires_at";
1518
+ tableName: "password_reset_tokens";
1519
+ dataType: "date";
1520
+ columnType: "PgTimestamp";
1521
+ data: Date;
1522
+ driverParam: string;
1523
+ notNull: true;
1524
+ hasDefault: false;
1525
+ isPrimaryKey: false;
1526
+ isAutoincrement: false;
1527
+ hasRuntimeDefault: false;
1528
+ enumValues: undefined;
1529
+ baseColumn: never;
1530
+ identity: undefined;
1531
+ generated: undefined;
1532
+ }, {}, {}>;
1533
+ usedAt: import("drizzle-orm/pg-core").PgColumn<{
1534
+ name: "used_at";
1535
+ tableName: "password_reset_tokens";
1536
+ dataType: "date";
1537
+ columnType: "PgTimestamp";
1538
+ data: Date;
1539
+ driverParam: string;
1540
+ notNull: false;
1541
+ hasDefault: false;
1542
+ isPrimaryKey: false;
1543
+ isAutoincrement: false;
1544
+ hasRuntimeDefault: false;
1545
+ enumValues: undefined;
1546
+ baseColumn: never;
1547
+ identity: undefined;
1548
+ generated: undefined;
1549
+ }, {}, {}>;
1550
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1551
+ name: "created_at";
1552
+ tableName: "password_reset_tokens";
1553
+ dataType: "date";
1554
+ columnType: "PgTimestamp";
1555
+ data: Date;
1556
+ driverParam: string;
1557
+ notNull: true;
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
+ };
1568
+ dialect: "pg";
1569
+ }>;
1570
+ export declare const appConfig: import("drizzle-orm/pg-core").PgTableWithColumns<{
1571
+ name: "app_config";
1572
+ schema: undefined;
1573
+ columns: {
1574
+ key: import("drizzle-orm/pg-core").PgColumn<{
1575
+ name: "key";
1576
+ tableName: "app_config";
1577
+ dataType: "string";
1578
+ columnType: "PgVarchar";
1579
+ data: string;
1580
+ driverParam: string;
1581
+ notNull: true;
1582
+ hasDefault: false;
1583
+ isPrimaryKey: true;
1584
+ isAutoincrement: false;
1585
+ hasRuntimeDefault: false;
1586
+ enumValues: [string, ...string[]];
1587
+ baseColumn: never;
1588
+ identity: undefined;
1589
+ generated: undefined;
1590
+ }, {}, {
1591
+ length: 100;
1592
+ }>;
1593
+ value: import("drizzle-orm/pg-core").PgColumn<{
1594
+ name: "value";
1595
+ tableName: "app_config";
1596
+ dataType: "json";
1597
+ columnType: "PgJsonb";
1598
+ data: unknown;
1599
+ driverParam: unknown;
1600
+ notNull: true;
1601
+ hasDefault: false;
1602
+ isPrimaryKey: false;
1603
+ isAutoincrement: false;
1604
+ hasRuntimeDefault: false;
1605
+ enumValues: undefined;
1606
+ baseColumn: never;
1607
+ identity: undefined;
1608
+ generated: undefined;
1609
+ }, {}, {}>;
1610
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1611
+ name: "updated_at";
1612
+ tableName: "app_config";
1613
+ dataType: "date";
1614
+ columnType: "PgTimestamp";
1615
+ data: Date;
1616
+ driverParam: string;
1617
+ notNull: true;
1618
+ hasDefault: true;
1619
+ isPrimaryKey: false;
1620
+ isAutoincrement: false;
1621
+ hasRuntimeDefault: false;
1622
+ enumValues: undefined;
1623
+ baseColumn: never;
1624
+ identity: undefined;
1625
+ generated: undefined;
1626
+ }, {}, {}>;
1627
+ };
1628
+ dialect: "pg";
1629
+ }>;
1630
+ export declare const userIdentities: import("drizzle-orm/pg-core").PgTableWithColumns<{
1631
+ name: "user_identities";
1632
+ schema: undefined;
1633
+ columns: {
1634
+ id: import("drizzle-orm/pg-core").PgColumn<{
1635
+ name: "id";
1636
+ tableName: "user_identities";
1637
+ dataType: "string";
1638
+ columnType: "PgUUID";
1639
+ data: string;
1640
+ driverParam: string;
1641
+ notNull: true;
1642
+ hasDefault: true;
1643
+ isPrimaryKey: true;
1644
+ isAutoincrement: false;
1645
+ hasRuntimeDefault: false;
1646
+ enumValues: undefined;
1647
+ baseColumn: never;
1648
+ identity: undefined;
1649
+ generated: undefined;
1650
+ }, {}, {}>;
1651
+ userId: import("drizzle-orm/pg-core").PgColumn<{
1652
+ name: "user_id";
1653
+ tableName: "user_identities";
1654
+ dataType: "string";
1655
+ columnType: "PgUUID";
1656
+ data: string;
1657
+ driverParam: string;
1658
+ notNull: true;
1659
+ hasDefault: false;
1660
+ isPrimaryKey: false;
1661
+ isAutoincrement: false;
1662
+ hasRuntimeDefault: false;
1663
+ enumValues: undefined;
1664
+ baseColumn: never;
1665
+ identity: undefined;
1666
+ generated: undefined;
1667
+ }, {}, {}>;
1668
+ provider: import("drizzle-orm/pg-core").PgColumn<{
1669
+ name: "provider";
1670
+ tableName: "user_identities";
1671
+ dataType: "string";
1672
+ columnType: "PgVarchar";
1673
+ data: string;
1674
+ driverParam: string;
1675
+ notNull: true;
1676
+ hasDefault: false;
1677
+ isPrimaryKey: false;
1678
+ isAutoincrement: false;
1679
+ hasRuntimeDefault: false;
1680
+ enumValues: [string, ...string[]];
1681
+ baseColumn: never;
1682
+ identity: undefined;
1683
+ generated: undefined;
1684
+ }, {}, {
1685
+ length: 50;
1686
+ }>;
1687
+ providerId: import("drizzle-orm/pg-core").PgColumn<{
1688
+ name: "provider_id";
1689
+ tableName: "user_identities";
1690
+ dataType: "string";
1691
+ columnType: "PgVarchar";
1692
+ data: string;
1693
+ driverParam: string;
1694
+ notNull: true;
1695
+ hasDefault: false;
1696
+ isPrimaryKey: false;
1697
+ isAutoincrement: false;
1698
+ hasRuntimeDefault: false;
1699
+ enumValues: [string, ...string[]];
1700
+ baseColumn: never;
1701
+ identity: undefined;
1702
+ generated: undefined;
1703
+ }, {}, {
1704
+ length: 255;
1705
+ }>;
1706
+ profileData: import("drizzle-orm/pg-core").PgColumn<{
1707
+ name: "profile_data";
1708
+ tableName: "user_identities";
1709
+ dataType: "json";
1710
+ columnType: "PgJsonb";
1711
+ data: unknown;
1712
+ driverParam: unknown;
1713
+ notNull: false;
1714
+ hasDefault: false;
1715
+ isPrimaryKey: false;
1716
+ isAutoincrement: false;
1717
+ hasRuntimeDefault: false;
1718
+ enumValues: undefined;
1719
+ baseColumn: never;
1720
+ identity: undefined;
1721
+ generated: undefined;
1722
+ }, {}, {}>;
1723
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1724
+ name: "created_at";
1725
+ tableName: "user_identities";
1726
+ dataType: "date";
1727
+ columnType: "PgTimestamp";
1728
+ data: Date;
1729
+ driverParam: string;
1730
+ notNull: true;
1731
+ hasDefault: true;
1732
+ isPrimaryKey: false;
1733
+ isAutoincrement: false;
1734
+ hasRuntimeDefault: false;
1735
+ enumValues: undefined;
1736
+ baseColumn: never;
1737
+ identity: undefined;
1738
+ generated: undefined;
1739
+ }, {}, {}>;
1740
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1741
+ name: "updated_at";
1742
+ tableName: "user_identities";
1743
+ dataType: "date";
1744
+ columnType: "PgTimestamp";
1745
+ data: Date;
1746
+ driverParam: string;
1747
+ notNull: true;
1748
+ hasDefault: true;
1749
+ isPrimaryKey: false;
1750
+ isAutoincrement: false;
1751
+ hasRuntimeDefault: false;
1752
+ enumValues: undefined;
1753
+ baseColumn: never;
1754
+ identity: undefined;
1755
+ generated: undefined;
1756
+ }, {}, {}>;
1757
+ };
1758
+ dialect: "pg";
1759
+ }>;
1760
+ export declare const mfaFactors: import("drizzle-orm/pg-core").PgTableWithColumns<{
1761
+ name: "mfa_factors";
1762
+ schema: undefined;
1763
+ columns: {
1764
+ id: import("drizzle-orm/pg-core").PgColumn<{
1765
+ name: "id";
1766
+ tableName: "mfa_factors";
1767
+ dataType: "string";
1768
+ columnType: "PgUUID";
1769
+ data: string;
1770
+ driverParam: string;
1771
+ notNull: true;
1772
+ hasDefault: true;
1773
+ isPrimaryKey: true;
1774
+ isAutoincrement: false;
1775
+ hasRuntimeDefault: false;
1776
+ enumValues: undefined;
1777
+ baseColumn: never;
1778
+ identity: undefined;
1779
+ generated: undefined;
1780
+ }, {}, {}>;
1781
+ userId: import("drizzle-orm/pg-core").PgColumn<{
1782
+ name: "user_id";
1783
+ tableName: "mfa_factors";
1784
+ dataType: "string";
1785
+ columnType: "PgUUID";
1786
+ data: string;
1787
+ driverParam: string;
1788
+ notNull: true;
1789
+ hasDefault: false;
1790
+ isPrimaryKey: false;
1791
+ isAutoincrement: false;
1792
+ hasRuntimeDefault: false;
1793
+ enumValues: undefined;
1794
+ baseColumn: never;
1795
+ identity: undefined;
1796
+ generated: undefined;
1797
+ }, {}, {}>;
1798
+ factorType: import("drizzle-orm/pg-core").PgColumn<{
1799
+ name: "factor_type";
1800
+ tableName: "mfa_factors";
1801
+ dataType: "string";
1802
+ columnType: "PgVarchar";
1803
+ data: string;
1804
+ driverParam: string;
1805
+ notNull: true;
1806
+ hasDefault: false;
1807
+ isPrimaryKey: false;
1808
+ isAutoincrement: false;
1809
+ hasRuntimeDefault: false;
1810
+ enumValues: [string, ...string[]];
1811
+ baseColumn: never;
1812
+ identity: undefined;
1813
+ generated: undefined;
1814
+ }, {}, {
1815
+ length: 20;
1816
+ }>;
1817
+ secretEncrypted: import("drizzle-orm/pg-core").PgColumn<{
1818
+ name: "secret_encrypted";
1819
+ tableName: "mfa_factors";
1820
+ dataType: "string";
1821
+ columnType: "PgVarchar";
1822
+ data: string;
1823
+ driverParam: string;
1824
+ notNull: true;
1825
+ hasDefault: false;
1826
+ isPrimaryKey: false;
1827
+ isAutoincrement: false;
1828
+ hasRuntimeDefault: false;
1829
+ enumValues: [string, ...string[]];
1830
+ baseColumn: never;
1831
+ identity: undefined;
1832
+ generated: undefined;
1833
+ }, {}, {
1834
+ length: 500;
1835
+ }>;
1836
+ friendlyName: import("drizzle-orm/pg-core").PgColumn<{
1837
+ name: "friendly_name";
1838
+ tableName: "mfa_factors";
1839
+ dataType: "string";
1840
+ columnType: "PgVarchar";
1841
+ data: string;
1842
+ driverParam: string;
1843
+ notNull: false;
1844
+ hasDefault: false;
1845
+ isPrimaryKey: false;
1846
+ isAutoincrement: false;
1847
+ hasRuntimeDefault: false;
1848
+ enumValues: [string, ...string[]];
1849
+ baseColumn: never;
1850
+ identity: undefined;
1851
+ generated: undefined;
1852
+ }, {}, {
1853
+ length: 255;
1854
+ }>;
1855
+ verified: import("drizzle-orm/pg-core").PgColumn<{
1856
+ name: "verified";
1857
+ tableName: "mfa_factors";
1858
+ dataType: "boolean";
1859
+ columnType: "PgBoolean";
1860
+ data: boolean;
1861
+ driverParam: boolean;
1862
+ notNull: true;
1863
+ hasDefault: true;
1864
+ isPrimaryKey: false;
1865
+ isAutoincrement: false;
1866
+ hasRuntimeDefault: false;
1867
+ enumValues: undefined;
1868
+ baseColumn: never;
1869
+ identity: undefined;
1870
+ generated: undefined;
1871
+ }, {}, {}>;
1872
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1873
+ name: "created_at";
1874
+ tableName: "mfa_factors";
1875
+ dataType: "date";
1876
+ columnType: "PgTimestamp";
1877
+ data: Date;
1878
+ driverParam: string;
1879
+ notNull: true;
1880
+ hasDefault: true;
1881
+ isPrimaryKey: false;
1882
+ isAutoincrement: false;
1883
+ hasRuntimeDefault: false;
1884
+ enumValues: undefined;
1885
+ baseColumn: never;
1886
+ identity: undefined;
1887
+ generated: undefined;
1888
+ }, {}, {}>;
1889
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1890
+ name: "updated_at";
1891
+ tableName: "mfa_factors";
1892
+ dataType: "date";
1893
+ columnType: "PgTimestamp";
1894
+ data: Date;
1895
+ driverParam: string;
1896
+ notNull: true;
1897
+ hasDefault: true;
1898
+ isPrimaryKey: false;
1899
+ isAutoincrement: false;
1900
+ hasRuntimeDefault: false;
1901
+ enumValues: undefined;
1902
+ baseColumn: never;
1903
+ identity: undefined;
1904
+ generated: undefined;
1905
+ }, {}, {}>;
1906
+ };
1907
+ dialect: "pg";
1908
+ }>;
1909
+ export declare const mfaChallenges: import("drizzle-orm/pg-core").PgTableWithColumns<{
1910
+ name: "mfa_challenges";
1911
+ schema: undefined;
1912
+ columns: {
1913
+ id: import("drizzle-orm/pg-core").PgColumn<{
1914
+ name: "id";
1915
+ tableName: "mfa_challenges";
1916
+ dataType: "string";
1917
+ columnType: "PgUUID";
1918
+ data: string;
1919
+ driverParam: string;
1920
+ notNull: true;
1921
+ hasDefault: true;
1922
+ isPrimaryKey: true;
1923
+ isAutoincrement: false;
1924
+ hasRuntimeDefault: false;
1925
+ enumValues: undefined;
1926
+ baseColumn: never;
1927
+ identity: undefined;
1928
+ generated: undefined;
1929
+ }, {}, {}>;
1930
+ factorId: import("drizzle-orm/pg-core").PgColumn<{
1931
+ name: "factor_id";
1932
+ tableName: "mfa_challenges";
1933
+ dataType: "string";
1934
+ columnType: "PgUUID";
1935
+ data: string;
1936
+ driverParam: string;
1937
+ notNull: true;
1938
+ hasDefault: false;
1939
+ isPrimaryKey: false;
1940
+ isAutoincrement: false;
1941
+ hasRuntimeDefault: false;
1942
+ enumValues: undefined;
1943
+ baseColumn: never;
1944
+ identity: undefined;
1945
+ generated: undefined;
1946
+ }, {}, {}>;
1947
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1948
+ name: "created_at";
1949
+ tableName: "mfa_challenges";
1950
+ dataType: "date";
1951
+ columnType: "PgTimestamp";
1952
+ data: Date;
1953
+ driverParam: string;
1954
+ notNull: true;
1955
+ hasDefault: true;
1956
+ isPrimaryKey: false;
1957
+ isAutoincrement: false;
1958
+ hasRuntimeDefault: false;
1959
+ enumValues: undefined;
1960
+ baseColumn: never;
1961
+ identity: undefined;
1962
+ generated: undefined;
1963
+ }, {}, {}>;
1964
+ verifiedAt: import("drizzle-orm/pg-core").PgColumn<{
1965
+ name: "verified_at";
1966
+ tableName: "mfa_challenges";
1967
+ dataType: "date";
1968
+ columnType: "PgTimestamp";
1969
+ data: Date;
1970
+ driverParam: string;
1971
+ notNull: false;
1972
+ hasDefault: false;
1973
+ isPrimaryKey: false;
1974
+ isAutoincrement: false;
1975
+ hasRuntimeDefault: false;
1976
+ enumValues: undefined;
1977
+ baseColumn: never;
1978
+ identity: undefined;
1979
+ generated: undefined;
1980
+ }, {}, {}>;
1981
+ ipAddress: import("drizzle-orm/pg-core").PgColumn<{
1982
+ name: "ip_address";
1983
+ tableName: "mfa_challenges";
1984
+ dataType: "string";
1985
+ columnType: "PgVarchar";
1986
+ data: string;
1987
+ driverParam: string;
1988
+ notNull: false;
1989
+ hasDefault: false;
1990
+ isPrimaryKey: false;
1991
+ isAutoincrement: false;
1992
+ hasRuntimeDefault: false;
1993
+ enumValues: [string, ...string[]];
1994
+ baseColumn: never;
1995
+ identity: undefined;
1996
+ generated: undefined;
1997
+ }, {}, {
1998
+ length: 45;
1999
+ }>;
2000
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
2001
+ name: "expires_at";
2002
+ tableName: "mfa_challenges";
2003
+ dataType: "date";
2004
+ columnType: "PgTimestamp";
2005
+ data: Date;
2006
+ driverParam: string;
2007
+ notNull: true;
2008
+ hasDefault: false;
2009
+ isPrimaryKey: false;
2010
+ isAutoincrement: false;
2011
+ hasRuntimeDefault: false;
2012
+ enumValues: undefined;
2013
+ baseColumn: never;
2014
+ identity: undefined;
2015
+ generated: undefined;
2016
+ }, {}, {}>;
2017
+ };
2018
+ dialect: "pg";
2019
+ }>;
2020
+ export declare const recoveryCodes: import("drizzle-orm/pg-core").PgTableWithColumns<{
2021
+ name: "recovery_codes";
2022
+ schema: undefined;
2023
+ columns: {
2024
+ id: import("drizzle-orm/pg-core").PgColumn<{
2025
+ name: "id";
2026
+ tableName: "recovery_codes";
2027
+ dataType: "string";
2028
+ columnType: "PgUUID";
2029
+ data: string;
2030
+ driverParam: string;
2031
+ notNull: true;
2032
+ hasDefault: true;
2033
+ isPrimaryKey: true;
2034
+ isAutoincrement: false;
2035
+ hasRuntimeDefault: false;
2036
+ enumValues: undefined;
2037
+ baseColumn: never;
2038
+ identity: undefined;
2039
+ generated: undefined;
2040
+ }, {}, {}>;
2041
+ userId: import("drizzle-orm/pg-core").PgColumn<{
2042
+ name: "user_id";
2043
+ tableName: "recovery_codes";
2044
+ dataType: "string";
2045
+ columnType: "PgUUID";
2046
+ data: string;
2047
+ driverParam: string;
2048
+ notNull: true;
2049
+ hasDefault: false;
2050
+ isPrimaryKey: false;
2051
+ isAutoincrement: false;
2052
+ hasRuntimeDefault: false;
2053
+ enumValues: undefined;
2054
+ baseColumn: never;
2055
+ identity: undefined;
2056
+ generated: undefined;
2057
+ }, {}, {}>;
2058
+ codeHash: import("drizzle-orm/pg-core").PgColumn<{
2059
+ name: "code_hash";
2060
+ tableName: "recovery_codes";
2061
+ dataType: "string";
2062
+ columnType: "PgVarchar";
2063
+ data: string;
2064
+ driverParam: string;
2065
+ notNull: true;
2066
+ hasDefault: false;
2067
+ isPrimaryKey: false;
2068
+ isAutoincrement: false;
2069
+ hasRuntimeDefault: false;
2070
+ enumValues: [string, ...string[]];
2071
+ baseColumn: never;
2072
+ identity: undefined;
2073
+ generated: undefined;
2074
+ }, {}, {
2075
+ length: 255;
2076
+ }>;
2077
+ usedAt: import("drizzle-orm/pg-core").PgColumn<{
2078
+ name: "used_at";
2079
+ tableName: "recovery_codes";
2080
+ dataType: "date";
2081
+ columnType: "PgTimestamp";
2082
+ data: Date;
2083
+ driverParam: string;
2084
+ notNull: false;
2085
+ hasDefault: false;
2086
+ isPrimaryKey: false;
2087
+ isAutoincrement: false;
2088
+ hasRuntimeDefault: false;
2089
+ enumValues: undefined;
2090
+ baseColumn: never;
2091
+ identity: undefined;
2092
+ generated: undefined;
2093
+ }, {}, {}>;
2094
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2095
+ name: "created_at";
2096
+ tableName: "recovery_codes";
2097
+ dataType: "date";
2098
+ columnType: "PgTimestamp";
2099
+ data: Date;
2100
+ driverParam: string;
2101
+ notNull: true;
2102
+ hasDefault: true;
2103
+ isPrimaryKey: false;
2104
+ isAutoincrement: false;
2105
+ hasRuntimeDefault: false;
2106
+ enumValues: undefined;
2107
+ baseColumn: never;
2108
+ identity: undefined;
2109
+ generated: undefined;
2110
+ }, {}, {}>;
2111
+ };
2112
+ dialect: "pg";
2113
+ }>;
2114
+ export declare const usersRelations: import("drizzle-orm").Relations<"users", {
2115
+ refreshTokens: import("drizzle-orm").Many<"refresh_tokens">;
2116
+ passwordResetTokens: import("drizzle-orm").Many<"password_reset_tokens">;
2117
+ userIdentities: import("drizzle-orm").Many<"user_identities">;
2118
+ mfaFactors: import("drizzle-orm").Many<"mfa_factors">;
2119
+ recoveryCodes: import("drizzle-orm").Many<"recovery_codes">;
2120
+ }>;
2121
+ export declare const refreshTokensRelations: import("drizzle-orm").Relations<"refresh_tokens", {
2122
+ user: import("drizzle-orm").One<"users", true>;
2123
+ }>;
2124
+ export declare const passwordResetTokensRelations: import("drizzle-orm").Relations<"password_reset_tokens", {
2125
+ user: import("drizzle-orm").One<"users", true>;
2126
+ }>;
2127
+ export declare const userIdentitiesRelations: import("drizzle-orm").Relations<"user_identities", {
2128
+ user: import("drizzle-orm").One<"users", true>;
2129
+ }>;
2130
+ export declare const mfaFactorsRelations: import("drizzle-orm").Relations<"mfa_factors", {
2131
+ user: import("drizzle-orm").One<"users", true>;
2132
+ challenges: import("drizzle-orm").Many<"mfa_challenges">;
2133
+ }>;
2134
+ export declare const mfaChallengesRelations: import("drizzle-orm").Relations<"mfa_challenges", {
2135
+ factor: import("drizzle-orm").One<"mfa_factors", true>;
2136
+ }>;
2137
+ export declare const recoveryCodesRelations: import("drizzle-orm").Relations<"recovery_codes", {
2138
+ user: import("drizzle-orm").One<"users", true>;
45
2139
  }>;
46
2140
  export type User = typeof users.$inferSelect;
47
2141
  export type NewUser = typeof users.$inferInsert;
48
- export type Role = typeof roles.$inferSelect;
49
- export type NewRole = typeof roles.$inferInsert;
50
- export type UserRole = typeof userRoles.$inferSelect;
51
2142
  export type RefreshToken = typeof refreshTokens.$inferSelect;
52
2143
  export type PasswordResetToken = typeof passwordResetTokens.$inferSelect;
53
2144
  export type AppConfig = typeof appConfig.$inferSelect;
54
2145
  export type UserIdentity = typeof userIdentities.$inferSelect;
55
2146
  export type NewUserIdentity = typeof userIdentities.$inferInsert;
2147
+ export type MfaFactorRow = typeof mfaFactors.$inferSelect;
2148
+ export type MfaChallengeRow = typeof mfaChallenges.$inferSelect;
2149
+ export type RecoveryCodeRow = typeof recoveryCodes.$inferSelect;