@fengsoft/auth-db 0.1.0

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