@rebasepro/server-postgresql 0.2.3 → 0.2.4

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