@flow-industries/id 0.23.4 → 0.24.1

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 (33) hide show
  1. package/README.md +76 -0
  2. package/dist/sdk/browser-contract.d.ts +1 -0
  3. package/dist/sdk/browser-contract.js +1 -0
  4. package/dist/sdk/browser-session-route.js +3 -3
  5. package/dist/sdk/client/atproto.d.ts +5 -0
  6. package/dist/sdk/client/atproto.js +49 -0
  7. package/dist/sdk/client/create-flow.js +2 -1
  8. package/dist/sdk/db/handle.d.ts +11 -0
  9. package/dist/sdk/db/handle.js +0 -0
  10. package/dist/sdk/db/schema.d.ts +4626 -0
  11. package/dist/sdk/db/schema.js +782 -0
  12. package/dist/sdk/oauth/encryption.d.ts +4 -0
  13. package/dist/sdk/oauth/encryption.js +29 -0
  14. package/dist/sdk/oauth/stores.d.ts +16 -0
  15. package/dist/sdk/oauth/stores.js +159 -0
  16. package/dist/sdk/settings/appearance.d.ts +3 -0
  17. package/dist/sdk/settings/appearance.js +167 -0
  18. package/dist/sdk/settings/cosmetics.d.ts +149 -0
  19. package/dist/sdk/settings/cosmetics.js +408 -0
  20. package/dist/sdk/settings/hair-items.json +312 -0
  21. package/dist/sdk/settings/registry.d.ts +11 -0
  22. package/dist/sdk/settings/registry.js +136 -0
  23. package/dist/sdk/settings/surfaces.d.ts +4 -0
  24. package/dist/sdk/settings/surfaces.js +37 -0
  25. package/dist/sdk/types/account-data.d.ts +11 -0
  26. package/dist/sdk/types/atproto-storage.d.ts +9 -0
  27. package/dist/sdk/types/atproto-storage.js +0 -0
  28. package/dist/sdk/types/atproto.d.ts +25 -0
  29. package/dist/sdk/types/atproto.js +0 -0
  30. package/dist/sdk/types/auth.d.ts +1 -0
  31. package/dist/sdk/types/cosmetics.d.ts +2 -1
  32. package/dist/sdk/types/index.d.ts +1 -0
  33. package/package.json +6 -2
package/dist/sdk/db/schema.d.ts ADDED
@@ -0,0 +1,4626 @@
1
+ import type { RawRecord } from "../json";
2
+ import type { StoredSettings } from "../settings/registry";
3
+ import type { RoomEventRecurrence } from "../types/room-events";
4
+ export declare const user: import("drizzle-orm/pg-core").PgTableWithColumns<{
5
+ name: "user";
6
+ schema: undefined;
7
+ columns: {
8
+ id: import("drizzle-orm/pg-core").PgColumn<{
9
+ name: "id";
10
+ tableName: "user";
11
+ dataType: "string";
12
+ columnType: "PgText";
13
+ data: string;
14
+ driverParam: string;
15
+ notNull: true;
16
+ hasDefault: false;
17
+ isPrimaryKey: true;
18
+ isAutoincrement: false;
19
+ hasRuntimeDefault: false;
20
+ enumValues: [string, ...string[]];
21
+ baseColumn: never;
22
+ identity: undefined;
23
+ generated: undefined;
24
+ }, {}, {}>;
25
+ username: import("drizzle-orm/pg-core").PgColumn<{
26
+ name: "username";
27
+ tableName: "user";
28
+ dataType: "string";
29
+ columnType: "PgText";
30
+ data: string;
31
+ driverParam: string;
32
+ notNull: true;
33
+ hasDefault: false;
34
+ isPrimaryKey: false;
35
+ isAutoincrement: false;
36
+ hasRuntimeDefault: false;
37
+ enumValues: [string, ...string[]];
38
+ baseColumn: never;
39
+ identity: undefined;
40
+ generated: undefined;
41
+ }, {}, {}>;
42
+ name: import("drizzle-orm/pg-core").PgColumn<{
43
+ name: "name";
44
+ tableName: "user";
45
+ dataType: "string";
46
+ columnType: "PgText";
47
+ data: string;
48
+ driverParam: string;
49
+ notNull: false;
50
+ hasDefault: false;
51
+ isPrimaryKey: false;
52
+ isAutoincrement: false;
53
+ hasRuntimeDefault: false;
54
+ enumValues: [string, ...string[]];
55
+ baseColumn: never;
56
+ identity: undefined;
57
+ generated: undefined;
58
+ }, {}, {}>;
59
+ email: import("drizzle-orm/pg-core").PgColumn<{
60
+ name: "email";
61
+ tableName: "user";
62
+ dataType: "string";
63
+ columnType: "PgText";
64
+ data: string;
65
+ driverParam: string;
66
+ notNull: false;
67
+ hasDefault: false;
68
+ isPrimaryKey: false;
69
+ isAutoincrement: false;
70
+ hasRuntimeDefault: false;
71
+ enumValues: [string, ...string[]];
72
+ baseColumn: never;
73
+ identity: undefined;
74
+ generated: undefined;
75
+ }, {}, {}>;
76
+ emailVerified: import("drizzle-orm/pg-core").PgColumn<{
77
+ name: "email_verified";
78
+ tableName: "user";
79
+ dataType: "boolean";
80
+ columnType: "PgBoolean";
81
+ data: boolean;
82
+ driverParam: boolean;
83
+ notNull: true;
84
+ hasDefault: true;
85
+ isPrimaryKey: false;
86
+ isAutoincrement: false;
87
+ hasRuntimeDefault: false;
88
+ enumValues: undefined;
89
+ baseColumn: never;
90
+ identity: undefined;
91
+ generated: undefined;
92
+ }, {}, {}>;
93
+ isGuest: import("drizzle-orm/pg-core").PgColumn<{
94
+ name: "is_guest";
95
+ tableName: "user";
96
+ dataType: "boolean";
97
+ columnType: "PgBoolean";
98
+ data: boolean;
99
+ driverParam: boolean;
100
+ notNull: true;
101
+ hasDefault: true;
102
+ isPrimaryKey: false;
103
+ isAutoincrement: false;
104
+ hasRuntimeDefault: false;
105
+ enumValues: undefined;
106
+ baseColumn: never;
107
+ identity: undefined;
108
+ generated: undefined;
109
+ }, {}, {}>;
110
+ role: import("drizzle-orm/pg-core").PgColumn<{
111
+ name: "role";
112
+ tableName: "user";
113
+ dataType: "string";
114
+ columnType: "PgText";
115
+ data: string;
116
+ driverParam: string;
117
+ notNull: true;
118
+ hasDefault: true;
119
+ isPrimaryKey: false;
120
+ isAutoincrement: false;
121
+ hasRuntimeDefault: false;
122
+ enumValues: [string, ...string[]];
123
+ baseColumn: never;
124
+ identity: undefined;
125
+ generated: undefined;
126
+ }, {}, {}>;
127
+ image: import("drizzle-orm/pg-core").PgColumn<{
128
+ name: "image";
129
+ tableName: "user";
130
+ dataType: "string";
131
+ columnType: "PgText";
132
+ data: string;
133
+ driverParam: string;
134
+ notNull: false;
135
+ hasDefault: false;
136
+ isPrimaryKey: false;
137
+ isAutoincrement: false;
138
+ hasRuntimeDefault: false;
139
+ enumValues: [string, ...string[]];
140
+ baseColumn: never;
141
+ identity: undefined;
142
+ generated: undefined;
143
+ }, {}, {}>;
144
+ bio: import("drizzle-orm/pg-core").PgColumn<{
145
+ name: "bio";
146
+ tableName: "user";
147
+ dataType: "string";
148
+ columnType: "PgText";
149
+ data: string;
150
+ driverParam: string;
151
+ notNull: false;
152
+ hasDefault: false;
153
+ isPrimaryKey: false;
154
+ isAutoincrement: false;
155
+ hasRuntimeDefault: false;
156
+ enumValues: [string, ...string[]];
157
+ baseColumn: never;
158
+ identity: undefined;
159
+ generated: undefined;
160
+ }, {}, {}>;
161
+ walletAddress: import("drizzle-orm/pg-core").PgColumn<{
162
+ name: "wallet_address";
163
+ tableName: "user";
164
+ dataType: "string";
165
+ columnType: "PgText";
166
+ data: string;
167
+ driverParam: string;
168
+ notNull: false;
169
+ hasDefault: false;
170
+ isPrimaryKey: false;
171
+ isAutoincrement: false;
172
+ hasRuntimeDefault: false;
173
+ enumValues: [string, ...string[]];
174
+ baseColumn: never;
175
+ identity: undefined;
176
+ generated: undefined;
177
+ }, {}, {}>;
178
+ subscribedToNews: import("drizzle-orm/pg-core").PgColumn<{
179
+ name: "subscribed_to_news";
180
+ tableName: "user";
181
+ dataType: "boolean";
182
+ columnType: "PgBoolean";
183
+ data: boolean;
184
+ driverParam: boolean;
185
+ notNull: true;
186
+ hasDefault: true;
187
+ isPrimaryKey: false;
188
+ isAutoincrement: false;
189
+ hasRuntimeDefault: false;
190
+ enumValues: undefined;
191
+ baseColumn: never;
192
+ identity: undefined;
193
+ generated: undefined;
194
+ }, {}, {}>;
195
+ sessionEpoch: import("drizzle-orm/pg-core").PgColumn<{
196
+ name: "session_epoch";
197
+ tableName: "user";
198
+ dataType: "number";
199
+ columnType: "PgInteger";
200
+ data: number;
201
+ driverParam: string | number;
202
+ notNull: true;
203
+ hasDefault: true;
204
+ isPrimaryKey: false;
205
+ isAutoincrement: false;
206
+ hasRuntimeDefault: false;
207
+ enumValues: undefined;
208
+ baseColumn: never;
209
+ identity: undefined;
210
+ generated: undefined;
211
+ }, {}, {}>;
212
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
213
+ name: "created_at";
214
+ tableName: "user";
215
+ dataType: "date";
216
+ columnType: "PgTimestamp";
217
+ data: Date;
218
+ driverParam: string;
219
+ notNull: true;
220
+ hasDefault: true;
221
+ isPrimaryKey: false;
222
+ isAutoincrement: false;
223
+ hasRuntimeDefault: false;
224
+ enumValues: undefined;
225
+ baseColumn: never;
226
+ identity: undefined;
227
+ generated: undefined;
228
+ }, {}, {}>;
229
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
230
+ name: "updated_at";
231
+ tableName: "user";
232
+ dataType: "date";
233
+ columnType: "PgTimestamp";
234
+ data: Date;
235
+ driverParam: string;
236
+ notNull: true;
237
+ hasDefault: true;
238
+ isPrimaryKey: false;
239
+ isAutoincrement: false;
240
+ hasRuntimeDefault: false;
241
+ enumValues: undefined;
242
+ baseColumn: never;
243
+ identity: undefined;
244
+ generated: undefined;
245
+ }, {}, {}>;
246
+ };
247
+ dialect: "pg";
248
+ }>;
249
+ export declare const account: import("drizzle-orm/pg-core").PgTableWithColumns<{
250
+ name: "account";
251
+ schema: undefined;
252
+ columns: {
253
+ id: import("drizzle-orm/pg-core").PgColumn<{
254
+ name: "id";
255
+ tableName: "account";
256
+ dataType: "string";
257
+ columnType: "PgText";
258
+ data: string;
259
+ driverParam: string;
260
+ notNull: true;
261
+ hasDefault: false;
262
+ isPrimaryKey: true;
263
+ isAutoincrement: false;
264
+ hasRuntimeDefault: false;
265
+ enumValues: [string, ...string[]];
266
+ baseColumn: never;
267
+ identity: undefined;
268
+ generated: undefined;
269
+ }, {}, {}>;
270
+ userId: import("drizzle-orm/pg-core").PgColumn<{
271
+ name: "user_id";
272
+ tableName: "account";
273
+ dataType: "string";
274
+ columnType: "PgText";
275
+ data: string;
276
+ driverParam: string;
277
+ notNull: true;
278
+ hasDefault: false;
279
+ isPrimaryKey: false;
280
+ isAutoincrement: false;
281
+ hasRuntimeDefault: false;
282
+ enumValues: [string, ...string[]];
283
+ baseColumn: never;
284
+ identity: undefined;
285
+ generated: undefined;
286
+ }, {}, {}>;
287
+ accountId: import("drizzle-orm/pg-core").PgColumn<{
288
+ name: "account_id";
289
+ tableName: "account";
290
+ dataType: "string";
291
+ columnType: "PgText";
292
+ data: string;
293
+ driverParam: string;
294
+ notNull: true;
295
+ hasDefault: false;
296
+ isPrimaryKey: false;
297
+ isAutoincrement: false;
298
+ hasRuntimeDefault: false;
299
+ enumValues: [string, ...string[]];
300
+ baseColumn: never;
301
+ identity: undefined;
302
+ generated: undefined;
303
+ }, {}, {}>;
304
+ providerId: import("drizzle-orm/pg-core").PgColumn<{
305
+ name: "provider_id";
306
+ tableName: "account";
307
+ dataType: "string";
308
+ columnType: "PgText";
309
+ data: string;
310
+ driverParam: string;
311
+ notNull: true;
312
+ hasDefault: false;
313
+ isPrimaryKey: false;
314
+ isAutoincrement: false;
315
+ hasRuntimeDefault: false;
316
+ enumValues: [string, ...string[]];
317
+ baseColumn: never;
318
+ identity: undefined;
319
+ generated: undefined;
320
+ }, {}, {}>;
321
+ displayName: import("drizzle-orm/pg-core").PgColumn<{
322
+ name: "display_name";
323
+ tableName: "account";
324
+ dataType: "string";
325
+ columnType: "PgText";
326
+ data: string;
327
+ driverParam: string;
328
+ notNull: false;
329
+ hasDefault: false;
330
+ isPrimaryKey: false;
331
+ isAutoincrement: false;
332
+ hasRuntimeDefault: false;
333
+ enumValues: [string, ...string[]];
334
+ baseColumn: never;
335
+ identity: undefined;
336
+ generated: undefined;
337
+ }, {}, {}>;
338
+ accessToken: import("drizzle-orm/pg-core").PgColumn<{
339
+ name: "access_token";
340
+ tableName: "account";
341
+ dataType: "string";
342
+ columnType: "PgText";
343
+ data: string;
344
+ driverParam: string;
345
+ notNull: false;
346
+ hasDefault: false;
347
+ isPrimaryKey: false;
348
+ isAutoincrement: false;
349
+ hasRuntimeDefault: false;
350
+ enumValues: [string, ...string[]];
351
+ baseColumn: never;
352
+ identity: undefined;
353
+ generated: undefined;
354
+ }, {}, {}>;
355
+ refreshToken: import("drizzle-orm/pg-core").PgColumn<{
356
+ name: "refresh_token";
357
+ tableName: "account";
358
+ dataType: "string";
359
+ columnType: "PgText";
360
+ data: string;
361
+ driverParam: string;
362
+ notNull: false;
363
+ hasDefault: false;
364
+ isPrimaryKey: false;
365
+ isAutoincrement: false;
366
+ hasRuntimeDefault: false;
367
+ enumValues: [string, ...string[]];
368
+ baseColumn: never;
369
+ identity: undefined;
370
+ generated: undefined;
371
+ }, {}, {}>;
372
+ accessTokenExpiresAt: import("drizzle-orm/pg-core").PgColumn<{
373
+ name: "access_token_expires_at";
374
+ tableName: "account";
375
+ dataType: "date";
376
+ columnType: "PgTimestamp";
377
+ data: Date;
378
+ driverParam: string;
379
+ notNull: false;
380
+ hasDefault: false;
381
+ isPrimaryKey: false;
382
+ isAutoincrement: false;
383
+ hasRuntimeDefault: false;
384
+ enumValues: undefined;
385
+ baseColumn: never;
386
+ identity: undefined;
387
+ generated: undefined;
388
+ }, {}, {}>;
389
+ refreshTokenExpiresAt: import("drizzle-orm/pg-core").PgColumn<{
390
+ name: "refresh_token_expires_at";
391
+ tableName: "account";
392
+ dataType: "date";
393
+ columnType: "PgTimestamp";
394
+ data: Date;
395
+ driverParam: string;
396
+ notNull: false;
397
+ hasDefault: false;
398
+ isPrimaryKey: false;
399
+ isAutoincrement: false;
400
+ hasRuntimeDefault: false;
401
+ enumValues: undefined;
402
+ baseColumn: never;
403
+ identity: undefined;
404
+ generated: undefined;
405
+ }, {}, {}>;
406
+ scope: import("drizzle-orm/pg-core").PgColumn<{
407
+ name: "scope";
408
+ tableName: "account";
409
+ dataType: "string";
410
+ columnType: "PgText";
411
+ data: string;
412
+ driverParam: string;
413
+ notNull: false;
414
+ hasDefault: false;
415
+ isPrimaryKey: false;
416
+ isAutoincrement: false;
417
+ hasRuntimeDefault: false;
418
+ enumValues: [string, ...string[]];
419
+ baseColumn: never;
420
+ identity: undefined;
421
+ generated: undefined;
422
+ }, {}, {}>;
423
+ idToken: import("drizzle-orm/pg-core").PgColumn<{
424
+ name: "id_token";
425
+ tableName: "account";
426
+ dataType: "string";
427
+ columnType: "PgText";
428
+ data: string;
429
+ driverParam: string;
430
+ notNull: false;
431
+ hasDefault: false;
432
+ isPrimaryKey: false;
433
+ isAutoincrement: false;
434
+ hasRuntimeDefault: false;
435
+ enumValues: [string, ...string[]];
436
+ baseColumn: never;
437
+ identity: undefined;
438
+ generated: undefined;
439
+ }, {}, {}>;
440
+ password: import("drizzle-orm/pg-core").PgColumn<{
441
+ name: "password";
442
+ tableName: "account";
443
+ dataType: "string";
444
+ columnType: "PgText";
445
+ data: string;
446
+ driverParam: string;
447
+ notNull: false;
448
+ hasDefault: false;
449
+ isPrimaryKey: false;
450
+ isAutoincrement: false;
451
+ hasRuntimeDefault: false;
452
+ enumValues: [string, ...string[]];
453
+ baseColumn: never;
454
+ identity: undefined;
455
+ generated: undefined;
456
+ }, {}, {}>;
457
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
458
+ name: "created_at";
459
+ tableName: "account";
460
+ dataType: "date";
461
+ columnType: "PgTimestamp";
462
+ data: Date;
463
+ driverParam: string;
464
+ notNull: true;
465
+ hasDefault: true;
466
+ isPrimaryKey: false;
467
+ isAutoincrement: false;
468
+ hasRuntimeDefault: false;
469
+ enumValues: undefined;
470
+ baseColumn: never;
471
+ identity: undefined;
472
+ generated: undefined;
473
+ }, {}, {}>;
474
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
475
+ name: "updated_at";
476
+ tableName: "account";
477
+ dataType: "date";
478
+ columnType: "PgTimestamp";
479
+ data: Date;
480
+ driverParam: string;
481
+ notNull: true;
482
+ hasDefault: true;
483
+ isPrimaryKey: false;
484
+ isAutoincrement: false;
485
+ hasRuntimeDefault: false;
486
+ enumValues: undefined;
487
+ baseColumn: never;
488
+ identity: undefined;
489
+ generated: undefined;
490
+ }, {}, {}>;
491
+ };
492
+ dialect: "pg";
493
+ }>;
494
+ export declare const session: import("drizzle-orm/pg-core").PgTableWithColumns<{
495
+ name: "session";
496
+ schema: undefined;
497
+ columns: {
498
+ id: import("drizzle-orm/pg-core").PgColumn<{
499
+ name: "id";
500
+ tableName: "session";
501
+ dataType: "string";
502
+ columnType: "PgText";
503
+ data: string;
504
+ driverParam: string;
505
+ notNull: true;
506
+ hasDefault: false;
507
+ isPrimaryKey: true;
508
+ isAutoincrement: false;
509
+ hasRuntimeDefault: false;
510
+ enumValues: [string, ...string[]];
511
+ baseColumn: never;
512
+ identity: undefined;
513
+ generated: undefined;
514
+ }, {}, {}>;
515
+ userId: import("drizzle-orm/pg-core").PgColumn<{
516
+ name: "user_id";
517
+ tableName: "session";
518
+ dataType: "string";
519
+ columnType: "PgText";
520
+ data: string;
521
+ driverParam: string;
522
+ notNull: true;
523
+ hasDefault: false;
524
+ isPrimaryKey: false;
525
+ isAutoincrement: false;
526
+ hasRuntimeDefault: false;
527
+ enumValues: [string, ...string[]];
528
+ baseColumn: never;
529
+ identity: undefined;
530
+ generated: undefined;
531
+ }, {}, {}>;
532
+ token: import("drizzle-orm/pg-core").PgColumn<{
533
+ name: "token";
534
+ tableName: "session";
535
+ dataType: "string";
536
+ columnType: "PgText";
537
+ data: string;
538
+ driverParam: string;
539
+ notNull: true;
540
+ hasDefault: false;
541
+ isPrimaryKey: false;
542
+ isAutoincrement: false;
543
+ hasRuntimeDefault: false;
544
+ enumValues: [string, ...string[]];
545
+ baseColumn: never;
546
+ identity: undefined;
547
+ generated: undefined;
548
+ }, {}, {}>;
549
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
550
+ name: "expires_at";
551
+ tableName: "session";
552
+ dataType: "date";
553
+ columnType: "PgTimestamp";
554
+ data: Date;
555
+ driverParam: string;
556
+ notNull: true;
557
+ hasDefault: false;
558
+ isPrimaryKey: false;
559
+ isAutoincrement: false;
560
+ hasRuntimeDefault: false;
561
+ enumValues: undefined;
562
+ baseColumn: never;
563
+ identity: undefined;
564
+ generated: undefined;
565
+ }, {}, {}>;
566
+ ipAddress: import("drizzle-orm/pg-core").PgColumn<{
567
+ name: "ip_address";
568
+ tableName: "session";
569
+ dataType: "string";
570
+ columnType: "PgText";
571
+ data: string;
572
+ driverParam: string;
573
+ notNull: false;
574
+ hasDefault: false;
575
+ isPrimaryKey: false;
576
+ isAutoincrement: false;
577
+ hasRuntimeDefault: false;
578
+ enumValues: [string, ...string[]];
579
+ baseColumn: never;
580
+ identity: undefined;
581
+ generated: undefined;
582
+ }, {}, {}>;
583
+ userAgent: import("drizzle-orm/pg-core").PgColumn<{
584
+ name: "user_agent";
585
+ tableName: "session";
586
+ dataType: "string";
587
+ columnType: "PgText";
588
+ data: string;
589
+ driverParam: string;
590
+ notNull: false;
591
+ hasDefault: false;
592
+ isPrimaryKey: false;
593
+ isAutoincrement: false;
594
+ hasRuntimeDefault: false;
595
+ enumValues: [string, ...string[]];
596
+ baseColumn: never;
597
+ identity: undefined;
598
+ generated: undefined;
599
+ }, {}, {}>;
600
+ audience: import("drizzle-orm/pg-core").PgColumn<{
601
+ name: "audience";
602
+ tableName: "session";
603
+ dataType: "string";
604
+ columnType: "PgText";
605
+ data: string;
606
+ driverParam: string;
607
+ notNull: false;
608
+ hasDefault: false;
609
+ isPrimaryKey: false;
610
+ isAutoincrement: false;
611
+ hasRuntimeDefault: false;
612
+ enumValues: [string, ...string[]];
613
+ baseColumn: never;
614
+ identity: undefined;
615
+ generated: undefined;
616
+ }, {}, {}>;
617
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
618
+ name: "created_at";
619
+ tableName: "session";
620
+ dataType: "date";
621
+ columnType: "PgTimestamp";
622
+ data: Date;
623
+ driverParam: string;
624
+ notNull: true;
625
+ hasDefault: true;
626
+ isPrimaryKey: false;
627
+ isAutoincrement: false;
628
+ hasRuntimeDefault: false;
629
+ enumValues: undefined;
630
+ baseColumn: never;
631
+ identity: undefined;
632
+ generated: undefined;
633
+ }, {}, {}>;
634
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
635
+ name: "updated_at";
636
+ tableName: "session";
637
+ dataType: "date";
638
+ columnType: "PgTimestamp";
639
+ data: Date;
640
+ driverParam: string;
641
+ notNull: true;
642
+ hasDefault: true;
643
+ isPrimaryKey: false;
644
+ isAutoincrement: false;
645
+ hasRuntimeDefault: false;
646
+ enumValues: undefined;
647
+ baseColumn: never;
648
+ identity: undefined;
649
+ generated: undefined;
650
+ }, {}, {}>;
651
+ };
652
+ dialect: "pg";
653
+ }>;
654
+ export declare const refreshToken: import("drizzle-orm/pg-core").PgTableWithColumns<{
655
+ name: "refresh_token";
656
+ schema: undefined;
657
+ columns: {
658
+ id: import("drizzle-orm/pg-core").PgColumn<{
659
+ name: "id";
660
+ tableName: "refresh_token";
661
+ dataType: "string";
662
+ columnType: "PgText";
663
+ data: string;
664
+ driverParam: string;
665
+ notNull: true;
666
+ hasDefault: false;
667
+ isPrimaryKey: true;
668
+ isAutoincrement: false;
669
+ hasRuntimeDefault: false;
670
+ enumValues: [string, ...string[]];
671
+ baseColumn: never;
672
+ identity: undefined;
673
+ generated: undefined;
674
+ }, {}, {}>;
675
+ userId: import("drizzle-orm/pg-core").PgColumn<{
676
+ name: "user_id";
677
+ tableName: "refresh_token";
678
+ dataType: "string";
679
+ columnType: "PgText";
680
+ data: string;
681
+ driverParam: string;
682
+ notNull: true;
683
+ hasDefault: false;
684
+ isPrimaryKey: false;
685
+ isAutoincrement: false;
686
+ hasRuntimeDefault: false;
687
+ enumValues: [string, ...string[]];
688
+ baseColumn: never;
689
+ identity: undefined;
690
+ generated: undefined;
691
+ }, {}, {}>;
692
+ tokenHash: import("drizzle-orm/pg-core").PgColumn<{
693
+ name: "token_hash";
694
+ tableName: "refresh_token";
695
+ dataType: "string";
696
+ columnType: "PgText";
697
+ data: string;
698
+ driverParam: string;
699
+ notNull: true;
700
+ hasDefault: false;
701
+ isPrimaryKey: false;
702
+ isAutoincrement: false;
703
+ hasRuntimeDefault: false;
704
+ enumValues: [string, ...string[]];
705
+ baseColumn: never;
706
+ identity: undefined;
707
+ generated: undefined;
708
+ }, {}, {}>;
709
+ audience: import("drizzle-orm/pg-core").PgColumn<{
710
+ name: "audience";
711
+ tableName: "refresh_token";
712
+ dataType: "string";
713
+ columnType: "PgText";
714
+ data: string;
715
+ driverParam: string;
716
+ notNull: true;
717
+ hasDefault: false;
718
+ isPrimaryKey: false;
719
+ isAutoincrement: false;
720
+ hasRuntimeDefault: false;
721
+ enumValues: [string, ...string[]];
722
+ baseColumn: never;
723
+ identity: undefined;
724
+ generated: undefined;
725
+ }, {}, {}>;
726
+ guest: import("drizzle-orm/pg-core").PgColumn<{
727
+ name: "guest";
728
+ tableName: "refresh_token";
729
+ dataType: "boolean";
730
+ columnType: "PgBoolean";
731
+ data: boolean;
732
+ driverParam: boolean;
733
+ notNull: true;
734
+ hasDefault: false;
735
+ isPrimaryKey: false;
736
+ isAutoincrement: false;
737
+ hasRuntimeDefault: false;
738
+ enumValues: undefined;
739
+ baseColumn: never;
740
+ identity: undefined;
741
+ generated: undefined;
742
+ }, {}, {}>;
743
+ epoch: import("drizzle-orm/pg-core").PgColumn<{
744
+ name: "epoch";
745
+ tableName: "refresh_token";
746
+ dataType: "number";
747
+ columnType: "PgInteger";
748
+ data: number;
749
+ driverParam: string | number;
750
+ notNull: true;
751
+ hasDefault: true;
752
+ isPrimaryKey: false;
753
+ isAutoincrement: false;
754
+ hasRuntimeDefault: false;
755
+ enumValues: undefined;
756
+ baseColumn: never;
757
+ identity: undefined;
758
+ generated: undefined;
759
+ }, {}, {}>;
760
+ userEpoch: import("drizzle-orm/pg-core").PgColumn<{
761
+ name: "user_epoch";
762
+ tableName: "refresh_token";
763
+ dataType: "number";
764
+ columnType: "PgInteger";
765
+ data: number;
766
+ driverParam: string | number;
767
+ notNull: true;
768
+ hasDefault: true;
769
+ isPrimaryKey: false;
770
+ isAutoincrement: false;
771
+ hasRuntimeDefault: false;
772
+ enumValues: undefined;
773
+ baseColumn: never;
774
+ identity: undefined;
775
+ generated: undefined;
776
+ }, {}, {}>;
777
+ lineageId: import("drizzle-orm/pg-core").PgColumn<{
778
+ name: "lineage_id";
779
+ tableName: "refresh_token";
780
+ dataType: "string";
781
+ columnType: "PgText";
782
+ data: string;
783
+ driverParam: string;
784
+ notNull: true;
785
+ hasDefault: false;
786
+ isPrimaryKey: false;
787
+ isAutoincrement: false;
788
+ hasRuntimeDefault: false;
789
+ enumValues: [string, ...string[]];
790
+ baseColumn: never;
791
+ identity: undefined;
792
+ generated: undefined;
793
+ }, {}, {}>;
794
+ sessionId: import("drizzle-orm/pg-core").PgColumn<{
795
+ name: "session_id";
796
+ tableName: "refresh_token";
797
+ dataType: "string";
798
+ columnType: "PgText";
799
+ data: string;
800
+ driverParam: string;
801
+ notNull: false;
802
+ hasDefault: false;
803
+ isPrimaryKey: false;
804
+ isAutoincrement: false;
805
+ hasRuntimeDefault: false;
806
+ enumValues: [string, ...string[]];
807
+ baseColumn: never;
808
+ identity: undefined;
809
+ generated: undefined;
810
+ }, {}, {}>;
811
+ replacedBy: import("drizzle-orm/pg-core").PgColumn<{
812
+ name: "replaced_by";
813
+ tableName: "refresh_token";
814
+ dataType: "string";
815
+ columnType: "PgText";
816
+ data: string;
817
+ driverParam: string;
818
+ notNull: false;
819
+ hasDefault: false;
820
+ isPrimaryKey: false;
821
+ isAutoincrement: false;
822
+ hasRuntimeDefault: false;
823
+ enumValues: [string, ...string[]];
824
+ baseColumn: never;
825
+ identity: undefined;
826
+ generated: undefined;
827
+ }, {}, {}>;
828
+ graceToken: import("drizzle-orm/pg-core").PgColumn<{
829
+ name: "grace_token";
830
+ tableName: "refresh_token";
831
+ dataType: "string";
832
+ columnType: "PgText";
833
+ data: string;
834
+ driverParam: string;
835
+ notNull: false;
836
+ hasDefault: false;
837
+ isPrimaryKey: false;
838
+ isAutoincrement: false;
839
+ hasRuntimeDefault: false;
840
+ enumValues: [string, ...string[]];
841
+ baseColumn: never;
842
+ identity: undefined;
843
+ generated: undefined;
844
+ }, {}, {}>;
845
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
846
+ name: "expires_at";
847
+ tableName: "refresh_token";
848
+ dataType: "date";
849
+ columnType: "PgTimestamp";
850
+ data: Date;
851
+ driverParam: string;
852
+ notNull: true;
853
+ hasDefault: false;
854
+ isPrimaryKey: false;
855
+ isAutoincrement: false;
856
+ hasRuntimeDefault: false;
857
+ enumValues: undefined;
858
+ baseColumn: never;
859
+ identity: undefined;
860
+ generated: undefined;
861
+ }, {}, {}>;
862
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
863
+ name: "created_at";
864
+ tableName: "refresh_token";
865
+ dataType: "date";
866
+ columnType: "PgTimestamp";
867
+ data: Date;
868
+ driverParam: string;
869
+ notNull: true;
870
+ hasDefault: true;
871
+ isPrimaryKey: false;
872
+ isAutoincrement: false;
873
+ hasRuntimeDefault: false;
874
+ enumValues: undefined;
875
+ baseColumn: never;
876
+ identity: undefined;
877
+ generated: undefined;
878
+ }, {}, {}>;
879
+ revokedAt: import("drizzle-orm/pg-core").PgColumn<{
880
+ name: "revoked_at";
881
+ tableName: "refresh_token";
882
+ dataType: "date";
883
+ columnType: "PgTimestamp";
884
+ data: Date;
885
+ driverParam: string;
886
+ notNull: false;
887
+ hasDefault: false;
888
+ isPrimaryKey: false;
889
+ isAutoincrement: false;
890
+ hasRuntimeDefault: false;
891
+ enumValues: undefined;
892
+ baseColumn: never;
893
+ identity: undefined;
894
+ generated: undefined;
895
+ }, {}, {}>;
896
+ };
897
+ dialect: "pg";
898
+ }>;
899
+ export declare const passkey: import("drizzle-orm/pg-core").PgTableWithColumns<{
900
+ name: "passkey";
901
+ schema: undefined;
902
+ columns: {
903
+ id: import("drizzle-orm/pg-core").PgColumn<{
904
+ name: "id";
905
+ tableName: "passkey";
906
+ dataType: "string";
907
+ columnType: "PgText";
908
+ data: string;
909
+ driverParam: string;
910
+ notNull: true;
911
+ hasDefault: false;
912
+ isPrimaryKey: true;
913
+ isAutoincrement: false;
914
+ hasRuntimeDefault: false;
915
+ enumValues: [string, ...string[]];
916
+ baseColumn: never;
917
+ identity: undefined;
918
+ generated: undefined;
919
+ }, {}, {}>;
920
+ name: import("drizzle-orm/pg-core").PgColumn<{
921
+ name: "name";
922
+ tableName: "passkey";
923
+ dataType: "string";
924
+ columnType: "PgText";
925
+ data: string;
926
+ driverParam: string;
927
+ notNull: false;
928
+ hasDefault: false;
929
+ isPrimaryKey: false;
930
+ isAutoincrement: false;
931
+ hasRuntimeDefault: false;
932
+ enumValues: [string, ...string[]];
933
+ baseColumn: never;
934
+ identity: undefined;
935
+ generated: undefined;
936
+ }, {}, {}>;
937
+ publicKey: import("drizzle-orm/pg-core").PgColumn<{
938
+ name: "public_key";
939
+ tableName: "passkey";
940
+ dataType: "string";
941
+ columnType: "PgText";
942
+ data: string;
943
+ driverParam: string;
944
+ notNull: true;
945
+ hasDefault: false;
946
+ isPrimaryKey: false;
947
+ isAutoincrement: false;
948
+ hasRuntimeDefault: false;
949
+ enumValues: [string, ...string[]];
950
+ baseColumn: never;
951
+ identity: undefined;
952
+ generated: undefined;
953
+ }, {}, {}>;
954
+ userId: import("drizzle-orm/pg-core").PgColumn<{
955
+ name: "user_id";
956
+ tableName: "passkey";
957
+ dataType: "string";
958
+ columnType: "PgText";
959
+ data: string;
960
+ driverParam: string;
961
+ notNull: true;
962
+ hasDefault: false;
963
+ isPrimaryKey: false;
964
+ isAutoincrement: false;
965
+ hasRuntimeDefault: false;
966
+ enumValues: [string, ...string[]];
967
+ baseColumn: never;
968
+ identity: undefined;
969
+ generated: undefined;
970
+ }, {}, {}>;
971
+ credentialId: import("drizzle-orm/pg-core").PgColumn<{
972
+ name: "credential_id";
973
+ tableName: "passkey";
974
+ dataType: "string";
975
+ columnType: "PgText";
976
+ data: string;
977
+ driverParam: string;
978
+ notNull: true;
979
+ hasDefault: false;
980
+ isPrimaryKey: false;
981
+ isAutoincrement: false;
982
+ hasRuntimeDefault: false;
983
+ enumValues: [string, ...string[]];
984
+ baseColumn: never;
985
+ identity: undefined;
986
+ generated: undefined;
987
+ }, {}, {}>;
988
+ counter: import("drizzle-orm/pg-core").PgColumn<{
989
+ name: "counter";
990
+ tableName: "passkey";
991
+ dataType: "number";
992
+ columnType: "PgInteger";
993
+ data: number;
994
+ driverParam: string | number;
995
+ notNull: true;
996
+ hasDefault: true;
997
+ isPrimaryKey: false;
998
+ isAutoincrement: false;
999
+ hasRuntimeDefault: false;
1000
+ enumValues: undefined;
1001
+ baseColumn: never;
1002
+ identity: undefined;
1003
+ generated: undefined;
1004
+ }, {}, {}>;
1005
+ deviceType: import("drizzle-orm/pg-core").PgColumn<{
1006
+ name: "device_type";
1007
+ tableName: "passkey";
1008
+ dataType: "string";
1009
+ columnType: "PgText";
1010
+ data: string;
1011
+ driverParam: string;
1012
+ notNull: false;
1013
+ hasDefault: false;
1014
+ isPrimaryKey: false;
1015
+ isAutoincrement: false;
1016
+ hasRuntimeDefault: false;
1017
+ enumValues: [string, ...string[]];
1018
+ baseColumn: never;
1019
+ identity: undefined;
1020
+ generated: undefined;
1021
+ }, {}, {}>;
1022
+ backedUp: import("drizzle-orm/pg-core").PgColumn<{
1023
+ name: "backed_up";
1024
+ tableName: "passkey";
1025
+ dataType: "boolean";
1026
+ columnType: "PgBoolean";
1027
+ data: boolean;
1028
+ driverParam: boolean;
1029
+ notNull: false;
1030
+ hasDefault: true;
1031
+ isPrimaryKey: false;
1032
+ isAutoincrement: false;
1033
+ hasRuntimeDefault: false;
1034
+ enumValues: undefined;
1035
+ baseColumn: never;
1036
+ identity: undefined;
1037
+ generated: undefined;
1038
+ }, {}, {}>;
1039
+ transports: import("drizzle-orm/pg-core").PgColumn<{
1040
+ name: "transports";
1041
+ tableName: "passkey";
1042
+ dataType: "string";
1043
+ columnType: "PgText";
1044
+ data: string;
1045
+ driverParam: string;
1046
+ notNull: false;
1047
+ hasDefault: false;
1048
+ isPrimaryKey: false;
1049
+ isAutoincrement: false;
1050
+ hasRuntimeDefault: false;
1051
+ enumValues: [string, ...string[]];
1052
+ baseColumn: never;
1053
+ identity: undefined;
1054
+ generated: undefined;
1055
+ }, {}, {}>;
1056
+ aaguid: import("drizzle-orm/pg-core").PgColumn<{
1057
+ name: "aaguid";
1058
+ tableName: "passkey";
1059
+ dataType: "string";
1060
+ columnType: "PgText";
1061
+ data: string;
1062
+ driverParam: string;
1063
+ notNull: false;
1064
+ hasDefault: false;
1065
+ isPrimaryKey: false;
1066
+ isAutoincrement: false;
1067
+ hasRuntimeDefault: false;
1068
+ enumValues: [string, ...string[]];
1069
+ baseColumn: never;
1070
+ identity: undefined;
1071
+ generated: undefined;
1072
+ }, {}, {}>;
1073
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1074
+ name: "created_at";
1075
+ tableName: "passkey";
1076
+ dataType: "date";
1077
+ columnType: "PgTimestamp";
1078
+ data: Date;
1079
+ driverParam: string;
1080
+ notNull: true;
1081
+ hasDefault: true;
1082
+ isPrimaryKey: false;
1083
+ isAutoincrement: false;
1084
+ hasRuntimeDefault: false;
1085
+ enumValues: undefined;
1086
+ baseColumn: never;
1087
+ identity: undefined;
1088
+ generated: undefined;
1089
+ }, {}, {}>;
1090
+ };
1091
+ dialect: "pg";
1092
+ }>;
1093
+ export declare const verification: import("drizzle-orm/pg-core").PgTableWithColumns<{
1094
+ name: "verification";
1095
+ schema: undefined;
1096
+ columns: {
1097
+ id: import("drizzle-orm/pg-core").PgColumn<{
1098
+ name: "id";
1099
+ tableName: "verification";
1100
+ dataType: "string";
1101
+ columnType: "PgText";
1102
+ data: string;
1103
+ driverParam: string;
1104
+ notNull: true;
1105
+ hasDefault: false;
1106
+ isPrimaryKey: true;
1107
+ isAutoincrement: false;
1108
+ hasRuntimeDefault: false;
1109
+ enumValues: [string, ...string[]];
1110
+ baseColumn: never;
1111
+ identity: undefined;
1112
+ generated: undefined;
1113
+ }, {}, {}>;
1114
+ identifier: import("drizzle-orm/pg-core").PgColumn<{
1115
+ name: "identifier";
1116
+ tableName: "verification";
1117
+ dataType: "string";
1118
+ columnType: "PgText";
1119
+ data: string;
1120
+ driverParam: string;
1121
+ notNull: true;
1122
+ hasDefault: false;
1123
+ isPrimaryKey: false;
1124
+ isAutoincrement: false;
1125
+ hasRuntimeDefault: false;
1126
+ enumValues: [string, ...string[]];
1127
+ baseColumn: never;
1128
+ identity: undefined;
1129
+ generated: undefined;
1130
+ }, {}, {}>;
1131
+ value: import("drizzle-orm/pg-core").PgColumn<{
1132
+ name: "value";
1133
+ tableName: "verification";
1134
+ dataType: "string";
1135
+ columnType: "PgText";
1136
+ data: string;
1137
+ driverParam: string;
1138
+ notNull: true;
1139
+ hasDefault: false;
1140
+ isPrimaryKey: false;
1141
+ isAutoincrement: false;
1142
+ hasRuntimeDefault: false;
1143
+ enumValues: [string, ...string[]];
1144
+ baseColumn: never;
1145
+ identity: undefined;
1146
+ generated: undefined;
1147
+ }, {}, {}>;
1148
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
1149
+ name: "expires_at";
1150
+ tableName: "verification";
1151
+ dataType: "date";
1152
+ columnType: "PgTimestamp";
1153
+ data: Date;
1154
+ driverParam: string;
1155
+ notNull: true;
1156
+ hasDefault: false;
1157
+ isPrimaryKey: false;
1158
+ isAutoincrement: false;
1159
+ hasRuntimeDefault: false;
1160
+ enumValues: undefined;
1161
+ baseColumn: never;
1162
+ identity: undefined;
1163
+ generated: undefined;
1164
+ }, {}, {}>;
1165
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1166
+ name: "created_at";
1167
+ tableName: "verification";
1168
+ dataType: "date";
1169
+ columnType: "PgTimestamp";
1170
+ data: Date;
1171
+ driverParam: string;
1172
+ notNull: true;
1173
+ hasDefault: true;
1174
+ isPrimaryKey: false;
1175
+ isAutoincrement: false;
1176
+ hasRuntimeDefault: false;
1177
+ enumValues: undefined;
1178
+ baseColumn: never;
1179
+ identity: undefined;
1180
+ generated: undefined;
1181
+ }, {}, {}>;
1182
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1183
+ name: "updated_at";
1184
+ tableName: "verification";
1185
+ dataType: "date";
1186
+ columnType: "PgTimestamp";
1187
+ data: Date;
1188
+ driverParam: string;
1189
+ notNull: true;
1190
+ hasDefault: true;
1191
+ isPrimaryKey: false;
1192
+ isAutoincrement: false;
1193
+ hasRuntimeDefault: false;
1194
+ enumValues: undefined;
1195
+ baseColumn: never;
1196
+ identity: undefined;
1197
+ generated: undefined;
1198
+ }, {}, {}>;
1199
+ };
1200
+ dialect: "pg";
1201
+ }>;
1202
+ export declare const userSettings: import("drizzle-orm/pg-core").PgTableWithColumns<{
1203
+ name: "user_settings";
1204
+ schema: undefined;
1205
+ columns: {
1206
+ userId: import("drizzle-orm/pg-core").PgColumn<{
1207
+ name: "user_id";
1208
+ tableName: "user_settings";
1209
+ dataType: "string";
1210
+ columnType: "PgText";
1211
+ data: string;
1212
+ driverParam: string;
1213
+ notNull: true;
1214
+ hasDefault: false;
1215
+ isPrimaryKey: false;
1216
+ isAutoincrement: false;
1217
+ hasRuntimeDefault: false;
1218
+ enumValues: [string, ...string[]];
1219
+ baseColumn: never;
1220
+ identity: undefined;
1221
+ generated: undefined;
1222
+ }, {}, {}>;
1223
+ surface: import("drizzle-orm/pg-core").PgColumn<{
1224
+ name: "surface";
1225
+ tableName: "user_settings";
1226
+ dataType: "string";
1227
+ columnType: "PgText";
1228
+ data: string;
1229
+ driverParam: string;
1230
+ notNull: true;
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
+ data: import("drizzle-orm/pg-core").PgColumn<{
1241
+ name: "data";
1242
+ tableName: "user_settings";
1243
+ dataType: "json";
1244
+ columnType: "PgJsonb";
1245
+ data: StoredSettings;
1246
+ driverParam: unknown;
1247
+ notNull: true;
1248
+ hasDefault: true;
1249
+ isPrimaryKey: false;
1250
+ isAutoincrement: false;
1251
+ hasRuntimeDefault: false;
1252
+ enumValues: undefined;
1253
+ baseColumn: never;
1254
+ identity: undefined;
1255
+ generated: undefined;
1256
+ }, {}, {
1257
+ $type: StoredSettings;
1258
+ }>;
1259
+ version: import("drizzle-orm/pg-core").PgColumn<{
1260
+ name: "version";
1261
+ tableName: "user_settings";
1262
+ dataType: "number";
1263
+ columnType: "PgInteger";
1264
+ data: number;
1265
+ driverParam: string | number;
1266
+ notNull: true;
1267
+ hasDefault: true;
1268
+ isPrimaryKey: false;
1269
+ isAutoincrement: false;
1270
+ hasRuntimeDefault: false;
1271
+ enumValues: undefined;
1272
+ baseColumn: never;
1273
+ identity: undefined;
1274
+ generated: undefined;
1275
+ }, {}, {}>;
1276
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1277
+ name: "updated_at";
1278
+ tableName: "user_settings";
1279
+ dataType: "date";
1280
+ columnType: "PgTimestamp";
1281
+ data: Date;
1282
+ driverParam: string;
1283
+ notNull: true;
1284
+ hasDefault: true;
1285
+ isPrimaryKey: false;
1286
+ isAutoincrement: false;
1287
+ hasRuntimeDefault: false;
1288
+ enumValues: undefined;
1289
+ baseColumn: never;
1290
+ identity: undefined;
1291
+ generated: undefined;
1292
+ }, {}, {}>;
1293
+ };
1294
+ dialect: "pg";
1295
+ }>;
1296
+ export declare const userXp: import("drizzle-orm/pg-core").PgTableWithColumns<{
1297
+ name: "user_xp";
1298
+ schema: undefined;
1299
+ columns: {
1300
+ userId: import("drizzle-orm/pg-core").PgColumn<{
1301
+ name: "user_id";
1302
+ tableName: "user_xp";
1303
+ dataType: "string";
1304
+ columnType: "PgText";
1305
+ data: string;
1306
+ driverParam: string;
1307
+ notNull: true;
1308
+ hasDefault: false;
1309
+ isPrimaryKey: true;
1310
+ isAutoincrement: false;
1311
+ hasRuntimeDefault: false;
1312
+ enumValues: [string, ...string[]];
1313
+ baseColumn: never;
1314
+ identity: undefined;
1315
+ generated: undefined;
1316
+ }, {}, {}>;
1317
+ totalXp: import("drizzle-orm/pg-core").PgColumn<{
1318
+ name: "total_xp";
1319
+ tableName: "user_xp";
1320
+ dataType: "number";
1321
+ columnType: "PgBigInt53";
1322
+ data: number;
1323
+ driverParam: string | number;
1324
+ notNull: true;
1325
+ hasDefault: true;
1326
+ isPrimaryKey: false;
1327
+ isAutoincrement: false;
1328
+ hasRuntimeDefault: false;
1329
+ enumValues: undefined;
1330
+ baseColumn: never;
1331
+ identity: undefined;
1332
+ generated: undefined;
1333
+ }, {}, {}>;
1334
+ flowScore: import("drizzle-orm/pg-core").PgColumn<{
1335
+ name: "flow_score";
1336
+ tableName: "user_xp";
1337
+ dataType: "number";
1338
+ columnType: "PgInteger";
1339
+ data: number;
1340
+ driverParam: string | number;
1341
+ notNull: true;
1342
+ hasDefault: true;
1343
+ isPrimaryKey: false;
1344
+ isAutoincrement: false;
1345
+ hasRuntimeDefault: false;
1346
+ enumValues: undefined;
1347
+ baseColumn: never;
1348
+ identity: undefined;
1349
+ generated: undefined;
1350
+ }, {}, {}>;
1351
+ lastVisitDate: import("drizzle-orm/pg-core").PgColumn<{
1352
+ name: "last_visit_date";
1353
+ tableName: "user_xp";
1354
+ dataType: "string";
1355
+ columnType: "PgDateString";
1356
+ data: string;
1357
+ driverParam: string;
1358
+ notNull: false;
1359
+ hasDefault: false;
1360
+ isPrimaryKey: false;
1361
+ isAutoincrement: false;
1362
+ hasRuntimeDefault: false;
1363
+ enumValues: undefined;
1364
+ baseColumn: never;
1365
+ identity: undefined;
1366
+ generated: undefined;
1367
+ }, {}, {}>;
1368
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1369
+ name: "updated_at";
1370
+ tableName: "user_xp";
1371
+ dataType: "date";
1372
+ columnType: "PgTimestamp";
1373
+ data: Date;
1374
+ driverParam: string;
1375
+ notNull: true;
1376
+ hasDefault: true;
1377
+ isPrimaryKey: false;
1378
+ isAutoincrement: false;
1379
+ hasRuntimeDefault: false;
1380
+ enumValues: undefined;
1381
+ baseColumn: never;
1382
+ identity: undefined;
1383
+ generated: undefined;
1384
+ }, {}, {}>;
1385
+ };
1386
+ dialect: "pg";
1387
+ }>;
1388
+ export declare const xpLedger: import("drizzle-orm/pg-core").PgTableWithColumns<{
1389
+ name: "xp_ledger";
1390
+ schema: undefined;
1391
+ columns: {
1392
+ id: import("drizzle-orm/pg-core").PgColumn<{
1393
+ name: "id";
1394
+ tableName: "xp_ledger";
1395
+ dataType: "string";
1396
+ columnType: "PgText";
1397
+ data: string;
1398
+ driverParam: string;
1399
+ notNull: true;
1400
+ hasDefault: false;
1401
+ isPrimaryKey: true;
1402
+ isAutoincrement: false;
1403
+ hasRuntimeDefault: false;
1404
+ enumValues: [string, ...string[]];
1405
+ baseColumn: never;
1406
+ identity: undefined;
1407
+ generated: undefined;
1408
+ }, {}, {}>;
1409
+ userId: import("drizzle-orm/pg-core").PgColumn<{
1410
+ name: "user_id";
1411
+ tableName: "xp_ledger";
1412
+ dataType: "string";
1413
+ columnType: "PgText";
1414
+ data: string;
1415
+ driverParam: string;
1416
+ notNull: true;
1417
+ hasDefault: false;
1418
+ isPrimaryKey: false;
1419
+ isAutoincrement: false;
1420
+ hasRuntimeDefault: false;
1421
+ enumValues: [string, ...string[]];
1422
+ baseColumn: never;
1423
+ identity: undefined;
1424
+ generated: undefined;
1425
+ }, {}, {}>;
1426
+ source: import("drizzle-orm/pg-core").PgColumn<{
1427
+ name: "source";
1428
+ tableName: "xp_ledger";
1429
+ dataType: "string";
1430
+ columnType: "PgText";
1431
+ data: string;
1432
+ driverParam: string;
1433
+ notNull: true;
1434
+ hasDefault: false;
1435
+ isPrimaryKey: false;
1436
+ isAutoincrement: false;
1437
+ hasRuntimeDefault: false;
1438
+ enumValues: [string, ...string[]];
1439
+ baseColumn: never;
1440
+ identity: undefined;
1441
+ generated: undefined;
1442
+ }, {}, {}>;
1443
+ baseAmount: import("drizzle-orm/pg-core").PgColumn<{
1444
+ name: "base_amount";
1445
+ tableName: "xp_ledger";
1446
+ dataType: "number";
1447
+ columnType: "PgInteger";
1448
+ data: number;
1449
+ driverParam: string | number;
1450
+ notNull: true;
1451
+ hasDefault: false;
1452
+ isPrimaryKey: false;
1453
+ isAutoincrement: false;
1454
+ hasRuntimeDefault: false;
1455
+ enumValues: undefined;
1456
+ baseColumn: never;
1457
+ identity: undefined;
1458
+ generated: undefined;
1459
+ }, {}, {}>;
1460
+ flowScore: import("drizzle-orm/pg-core").PgColumn<{
1461
+ name: "flow_score";
1462
+ tableName: "xp_ledger";
1463
+ dataType: "number";
1464
+ columnType: "PgInteger";
1465
+ data: number;
1466
+ driverParam: string | number;
1467
+ notNull: true;
1468
+ hasDefault: true;
1469
+ isPrimaryKey: false;
1470
+ isAutoincrement: false;
1471
+ hasRuntimeDefault: false;
1472
+ enumValues: undefined;
1473
+ baseColumn: never;
1474
+ identity: undefined;
1475
+ generated: undefined;
1476
+ }, {}, {}>;
1477
+ amount: import("drizzle-orm/pg-core").PgColumn<{
1478
+ name: "amount";
1479
+ tableName: "xp_ledger";
1480
+ dataType: "number";
1481
+ columnType: "PgInteger";
1482
+ data: number;
1483
+ driverParam: string | number;
1484
+ notNull: true;
1485
+ hasDefault: false;
1486
+ isPrimaryKey: false;
1487
+ isAutoincrement: false;
1488
+ hasRuntimeDefault: false;
1489
+ enumValues: undefined;
1490
+ baseColumn: never;
1491
+ identity: undefined;
1492
+ generated: undefined;
1493
+ }, {}, {}>;
1494
+ metadata: import("drizzle-orm/pg-core").PgColumn<{
1495
+ name: "metadata";
1496
+ tableName: "xp_ledger";
1497
+ dataType: "json";
1498
+ columnType: "PgJsonb";
1499
+ data: RawRecord;
1500
+ driverParam: unknown;
1501
+ notNull: false;
1502
+ hasDefault: false;
1503
+ isPrimaryKey: false;
1504
+ isAutoincrement: false;
1505
+ hasRuntimeDefault: false;
1506
+ enumValues: undefined;
1507
+ baseColumn: never;
1508
+ identity: undefined;
1509
+ generated: undefined;
1510
+ }, {}, {
1511
+ $type: RawRecord;
1512
+ }>;
1513
+ idempotencyKey: import("drizzle-orm/pg-core").PgColumn<{
1514
+ name: "idempotency_key";
1515
+ tableName: "xp_ledger";
1516
+ dataType: "string";
1517
+ columnType: "PgText";
1518
+ data: string;
1519
+ driverParam: string;
1520
+ notNull: false;
1521
+ hasDefault: false;
1522
+ isPrimaryKey: false;
1523
+ isAutoincrement: false;
1524
+ hasRuntimeDefault: false;
1525
+ enumValues: [string, ...string[]];
1526
+ baseColumn: never;
1527
+ identity: undefined;
1528
+ generated: undefined;
1529
+ }, {}, {}>;
1530
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1531
+ name: "created_at";
1532
+ tableName: "xp_ledger";
1533
+ dataType: "date";
1534
+ columnType: "PgTimestamp";
1535
+ data: Date;
1536
+ driverParam: string;
1537
+ notNull: true;
1538
+ hasDefault: true;
1539
+ isPrimaryKey: false;
1540
+ isAutoincrement: false;
1541
+ hasRuntimeDefault: false;
1542
+ enumValues: undefined;
1543
+ baseColumn: never;
1544
+ identity: undefined;
1545
+ generated: undefined;
1546
+ }, {}, {}>;
1547
+ };
1548
+ dialect: "pg";
1549
+ }>;
1550
+ export declare const actionSession: import("drizzle-orm/pg-core").PgTableWithColumns<{
1551
+ name: "action_session";
1552
+ schema: undefined;
1553
+ columns: {
1554
+ id: import("drizzle-orm/pg-core").PgColumn<{
1555
+ name: "id";
1556
+ tableName: "action_session";
1557
+ dataType: "string";
1558
+ columnType: "PgText";
1559
+ data: string;
1560
+ driverParam: string;
1561
+ notNull: true;
1562
+ hasDefault: false;
1563
+ isPrimaryKey: true;
1564
+ isAutoincrement: false;
1565
+ hasRuntimeDefault: false;
1566
+ enumValues: [string, ...string[]];
1567
+ baseColumn: never;
1568
+ identity: undefined;
1569
+ generated: undefined;
1570
+ }, {}, {}>;
1571
+ userId: import("drizzle-orm/pg-core").PgColumn<{
1572
+ name: "user_id";
1573
+ tableName: "action_session";
1574
+ dataType: "string";
1575
+ columnType: "PgText";
1576
+ data: string;
1577
+ driverParam: string;
1578
+ notNull: true;
1579
+ hasDefault: false;
1580
+ isPrimaryKey: false;
1581
+ isAutoincrement: false;
1582
+ hasRuntimeDefault: false;
1583
+ enumValues: [string, ...string[]];
1584
+ baseColumn: never;
1585
+ identity: undefined;
1586
+ generated: undefined;
1587
+ }, {}, {}>;
1588
+ source: import("drizzle-orm/pg-core").PgColumn<{
1589
+ name: "source";
1590
+ tableName: "action_session";
1591
+ dataType: "string";
1592
+ columnType: "PgText";
1593
+ data: string;
1594
+ driverParam: string;
1595
+ notNull: true;
1596
+ hasDefault: false;
1597
+ isPrimaryKey: false;
1598
+ isAutoincrement: false;
1599
+ hasRuntimeDefault: false;
1600
+ enumValues: [string, ...string[]];
1601
+ baseColumn: never;
1602
+ identity: undefined;
1603
+ generated: undefined;
1604
+ }, {}, {}>;
1605
+ state: import("drizzle-orm/pg-core").PgColumn<{
1606
+ name: "state";
1607
+ tableName: "action_session";
1608
+ dataType: "string";
1609
+ columnType: "PgText";
1610
+ data: string;
1611
+ driverParam: string;
1612
+ notNull: true;
1613
+ hasDefault: true;
1614
+ isPrimaryKey: false;
1615
+ isAutoincrement: false;
1616
+ hasRuntimeDefault: false;
1617
+ enumValues: [string, ...string[]];
1618
+ baseColumn: never;
1619
+ identity: undefined;
1620
+ generated: undefined;
1621
+ }, {}, {}>;
1622
+ subjectId: import("drizzle-orm/pg-core").PgColumn<{
1623
+ name: "subject_id";
1624
+ tableName: "action_session";
1625
+ dataType: "string";
1626
+ columnType: "PgText";
1627
+ data: string;
1628
+ driverParam: string;
1629
+ notNull: false;
1630
+ hasDefault: false;
1631
+ isPrimaryKey: false;
1632
+ isAutoincrement: false;
1633
+ hasRuntimeDefault: false;
1634
+ enumValues: [string, ...string[]];
1635
+ baseColumn: never;
1636
+ identity: undefined;
1637
+ generated: undefined;
1638
+ }, {}, {}>;
1639
+ accruedSeconds: import("drizzle-orm/pg-core").PgColumn<{
1640
+ name: "accrued_seconds";
1641
+ tableName: "action_session";
1642
+ dataType: "number";
1643
+ columnType: "PgDoublePrecision";
1644
+ data: number;
1645
+ driverParam: string | number;
1646
+ notNull: true;
1647
+ hasDefault: true;
1648
+ isPrimaryKey: false;
1649
+ isAutoincrement: false;
1650
+ hasRuntimeDefault: false;
1651
+ enumValues: undefined;
1652
+ baseColumn: never;
1653
+ identity: undefined;
1654
+ generated: undefined;
1655
+ }, {}, {}>;
1656
+ focusedSeconds: import("drizzle-orm/pg-core").PgColumn<{
1657
+ name: "focused_seconds";
1658
+ tableName: "action_session";
1659
+ dataType: "number";
1660
+ columnType: "PgDoublePrecision";
1661
+ data: number;
1662
+ driverParam: string | number;
1663
+ notNull: true;
1664
+ hasDefault: true;
1665
+ isPrimaryKey: false;
1666
+ isAutoincrement: false;
1667
+ hasRuntimeDefault: false;
1668
+ enumValues: undefined;
1669
+ baseColumn: never;
1670
+ identity: undefined;
1671
+ generated: undefined;
1672
+ }, {}, {}>;
1673
+ xpGranted: import("drizzle-orm/pg-core").PgColumn<{
1674
+ name: "xp_granted";
1675
+ tableName: "action_session";
1676
+ dataType: "number";
1677
+ columnType: "PgInteger";
1678
+ data: number;
1679
+ driverParam: string | number;
1680
+ notNull: false;
1681
+ hasDefault: false;
1682
+ isPrimaryKey: false;
1683
+ isAutoincrement: false;
1684
+ hasRuntimeDefault: false;
1685
+ enumValues: undefined;
1686
+ baseColumn: never;
1687
+ identity: undefined;
1688
+ generated: undefined;
1689
+ }, {}, {}>;
1690
+ metadata: import("drizzle-orm/pg-core").PgColumn<{
1691
+ name: "metadata";
1692
+ tableName: "action_session";
1693
+ dataType: "json";
1694
+ columnType: "PgJsonb";
1695
+ data: RawRecord;
1696
+ driverParam: unknown;
1697
+ notNull: false;
1698
+ hasDefault: false;
1699
+ isPrimaryKey: false;
1700
+ isAutoincrement: false;
1701
+ hasRuntimeDefault: false;
1702
+ enumValues: undefined;
1703
+ baseColumn: never;
1704
+ identity: undefined;
1705
+ generated: undefined;
1706
+ }, {}, {
1707
+ $type: RawRecord;
1708
+ }>;
1709
+ startedAt: import("drizzle-orm/pg-core").PgColumn<{
1710
+ name: "started_at";
1711
+ tableName: "action_session";
1712
+ dataType: "date";
1713
+ columnType: "PgTimestamp";
1714
+ data: Date;
1715
+ driverParam: string;
1716
+ notNull: true;
1717
+ hasDefault: true;
1718
+ isPrimaryKey: false;
1719
+ isAutoincrement: false;
1720
+ hasRuntimeDefault: false;
1721
+ enumValues: undefined;
1722
+ baseColumn: never;
1723
+ identity: undefined;
1724
+ generated: undefined;
1725
+ }, {}, {}>;
1726
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1727
+ name: "updated_at";
1728
+ tableName: "action_session";
1729
+ dataType: "date";
1730
+ columnType: "PgTimestamp";
1731
+ data: Date;
1732
+ driverParam: string;
1733
+ notNull: true;
1734
+ hasDefault: true;
1735
+ isPrimaryKey: false;
1736
+ isAutoincrement: false;
1737
+ hasRuntimeDefault: false;
1738
+ enumValues: undefined;
1739
+ baseColumn: never;
1740
+ identity: undefined;
1741
+ generated: undefined;
1742
+ }, {}, {}>;
1743
+ finishedAt: import("drizzle-orm/pg-core").PgColumn<{
1744
+ name: "finished_at";
1745
+ tableName: "action_session";
1746
+ dataType: "date";
1747
+ columnType: "PgTimestamp";
1748
+ data: Date;
1749
+ driverParam: string;
1750
+ notNull: false;
1751
+ hasDefault: false;
1752
+ isPrimaryKey: false;
1753
+ isAutoincrement: false;
1754
+ hasRuntimeDefault: false;
1755
+ enumValues: undefined;
1756
+ baseColumn: never;
1757
+ identity: undefined;
1758
+ generated: undefined;
1759
+ }, {}, {}>;
1760
+ };
1761
+ dialect: "pg";
1762
+ }>;
1763
+ export declare const actionEvent: import("drizzle-orm/pg-core").PgTableWithColumns<{
1764
+ name: "action_event";
1765
+ schema: undefined;
1766
+ columns: {
1767
+ id: import("drizzle-orm/pg-core").PgColumn<{
1768
+ name: "id";
1769
+ tableName: "action_event";
1770
+ dataType: "string";
1771
+ columnType: "PgText";
1772
+ data: string;
1773
+ driverParam: string;
1774
+ notNull: true;
1775
+ hasDefault: false;
1776
+ isPrimaryKey: true;
1777
+ isAutoincrement: false;
1778
+ hasRuntimeDefault: false;
1779
+ enumValues: [string, ...string[]];
1780
+ baseColumn: never;
1781
+ identity: undefined;
1782
+ generated: undefined;
1783
+ }, {}, {}>;
1784
+ sessionId: import("drizzle-orm/pg-core").PgColumn<{
1785
+ name: "session_id";
1786
+ tableName: "action_event";
1787
+ dataType: "string";
1788
+ columnType: "PgText";
1789
+ data: string;
1790
+ driverParam: string;
1791
+ notNull: true;
1792
+ hasDefault: false;
1793
+ isPrimaryKey: false;
1794
+ isAutoincrement: false;
1795
+ hasRuntimeDefault: false;
1796
+ enumValues: [string, ...string[]];
1797
+ baseColumn: never;
1798
+ identity: undefined;
1799
+ generated: undefined;
1800
+ }, {}, {}>;
1801
+ kind: import("drizzle-orm/pg-core").PgColumn<{
1802
+ name: "kind";
1803
+ tableName: "action_event";
1804
+ dataType: "string";
1805
+ columnType: "PgText";
1806
+ data: string;
1807
+ driverParam: string;
1808
+ notNull: true;
1809
+ hasDefault: false;
1810
+ isPrimaryKey: false;
1811
+ isAutoincrement: false;
1812
+ hasRuntimeDefault: false;
1813
+ enumValues: [string, ...string[]];
1814
+ baseColumn: never;
1815
+ identity: undefined;
1816
+ generated: undefined;
1817
+ }, {}, {}>;
1818
+ accruedSeconds: import("drizzle-orm/pg-core").PgColumn<{
1819
+ name: "accrued_seconds";
1820
+ tableName: "action_event";
1821
+ dataType: "number";
1822
+ columnType: "PgInteger";
1823
+ data: number;
1824
+ driverParam: string | number;
1825
+ notNull: true;
1826
+ hasDefault: true;
1827
+ isPrimaryKey: false;
1828
+ isAutoincrement: false;
1829
+ hasRuntimeDefault: false;
1830
+ enumValues: undefined;
1831
+ baseColumn: never;
1832
+ identity: undefined;
1833
+ generated: undefined;
1834
+ }, {}, {}>;
1835
+ at: import("drizzle-orm/pg-core").PgColumn<{
1836
+ name: "at";
1837
+ tableName: "action_event";
1838
+ dataType: "date";
1839
+ columnType: "PgTimestamp";
1840
+ data: Date;
1841
+ driverParam: string;
1842
+ notNull: true;
1843
+ hasDefault: true;
1844
+ isPrimaryKey: false;
1845
+ isAutoincrement: false;
1846
+ hasRuntimeDefault: false;
1847
+ enumValues: undefined;
1848
+ baseColumn: never;
1849
+ identity: undefined;
1850
+ generated: undefined;
1851
+ }, {}, {}>;
1852
+ };
1853
+ dialect: "pg";
1854
+ }>;
1855
+ export declare const characterStateTime: import("drizzle-orm/pg-core").PgTableWithColumns<{
1856
+ name: "character_state_time";
1857
+ schema: undefined;
1858
+ columns: {
1859
+ userId: import("drizzle-orm/pg-core").PgColumn<{
1860
+ name: "user_id";
1861
+ tableName: "character_state_time";
1862
+ dataType: "string";
1863
+ columnType: "PgText";
1864
+ data: string;
1865
+ driverParam: string;
1866
+ notNull: true;
1867
+ hasDefault: false;
1868
+ isPrimaryKey: false;
1869
+ isAutoincrement: false;
1870
+ hasRuntimeDefault: false;
1871
+ enumValues: [string, ...string[]];
1872
+ baseColumn: never;
1873
+ identity: undefined;
1874
+ generated: undefined;
1875
+ }, {}, {}>;
1876
+ day: import("drizzle-orm/pg-core").PgColumn<{
1877
+ name: "day";
1878
+ tableName: "character_state_time";
1879
+ dataType: "string";
1880
+ columnType: "PgDateString";
1881
+ data: string;
1882
+ driverParam: string;
1883
+ notNull: true;
1884
+ hasDefault: false;
1885
+ isPrimaryKey: false;
1886
+ isAutoincrement: false;
1887
+ hasRuntimeDefault: false;
1888
+ enumValues: undefined;
1889
+ baseColumn: never;
1890
+ identity: undefined;
1891
+ generated: undefined;
1892
+ }, {}, {}>;
1893
+ state: import("drizzle-orm/pg-core").PgColumn<{
1894
+ name: "state";
1895
+ tableName: "character_state_time";
1896
+ dataType: "string";
1897
+ columnType: "PgText";
1898
+ data: string;
1899
+ driverParam: string;
1900
+ notNull: true;
1901
+ hasDefault: false;
1902
+ isPrimaryKey: false;
1903
+ isAutoincrement: false;
1904
+ hasRuntimeDefault: false;
1905
+ enumValues: [string, ...string[]];
1906
+ baseColumn: never;
1907
+ identity: undefined;
1908
+ generated: undefined;
1909
+ }, {}, {}>;
1910
+ seconds: import("drizzle-orm/pg-core").PgColumn<{
1911
+ name: "seconds";
1912
+ tableName: "character_state_time";
1913
+ dataType: "number";
1914
+ columnType: "PgInteger";
1915
+ data: number;
1916
+ driverParam: string | number;
1917
+ notNull: true;
1918
+ hasDefault: true;
1919
+ isPrimaryKey: false;
1920
+ isAutoincrement: false;
1921
+ hasRuntimeDefault: false;
1922
+ enumValues: undefined;
1923
+ baseColumn: never;
1924
+ identity: undefined;
1925
+ generated: undefined;
1926
+ }, {}, {}>;
1927
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1928
+ name: "updated_at";
1929
+ tableName: "character_state_time";
1930
+ dataType: "date";
1931
+ columnType: "PgTimestamp";
1932
+ data: Date;
1933
+ driverParam: string;
1934
+ notNull: true;
1935
+ hasDefault: true;
1936
+ isPrimaryKey: false;
1937
+ isAutoincrement: false;
1938
+ hasRuntimeDefault: false;
1939
+ enumValues: undefined;
1940
+ baseColumn: never;
1941
+ identity: undefined;
1942
+ generated: undefined;
1943
+ }, {}, {}>;
1944
+ };
1945
+ dialect: "pg";
1946
+ }>;
1947
+ export declare const room: import("drizzle-orm/pg-core").PgTableWithColumns<{
1948
+ name: "room";
1949
+ schema: undefined;
1950
+ columns: {
1951
+ id: import("drizzle-orm/pg-core").PgColumn<{
1952
+ name: "id";
1953
+ tableName: "room";
1954
+ dataType: "string";
1955
+ columnType: "PgText";
1956
+ data: string;
1957
+ driverParam: string;
1958
+ notNull: true;
1959
+ hasDefault: false;
1960
+ isPrimaryKey: true;
1961
+ isAutoincrement: false;
1962
+ hasRuntimeDefault: false;
1963
+ enumValues: [string, ...string[]];
1964
+ baseColumn: never;
1965
+ identity: undefined;
1966
+ generated: undefined;
1967
+ }, {}, {}>;
1968
+ slug: import("drizzle-orm/pg-core").PgColumn<{
1969
+ name: "slug";
1970
+ tableName: "room";
1971
+ dataType: "string";
1972
+ columnType: "PgText";
1973
+ data: string;
1974
+ driverParam: string;
1975
+ notNull: true;
1976
+ hasDefault: false;
1977
+ isPrimaryKey: false;
1978
+ isAutoincrement: false;
1979
+ hasRuntimeDefault: false;
1980
+ enumValues: [string, ...string[]];
1981
+ baseColumn: never;
1982
+ identity: undefined;
1983
+ generated: undefined;
1984
+ }, {}, {}>;
1985
+ displayName: import("drizzle-orm/pg-core").PgColumn<{
1986
+ name: "display_name";
1987
+ tableName: "room";
1988
+ dataType: "string";
1989
+ columnType: "PgText";
1990
+ data: string;
1991
+ driverParam: string;
1992
+ notNull: true;
1993
+ hasDefault: false;
1994
+ isPrimaryKey: false;
1995
+ isAutoincrement: false;
1996
+ hasRuntimeDefault: false;
1997
+ enumValues: [string, ...string[]];
1998
+ baseColumn: never;
1999
+ identity: undefined;
2000
+ generated: undefined;
2001
+ }, {}, {}>;
2002
+ description: import("drizzle-orm/pg-core").PgColumn<{
2003
+ name: "description";
2004
+ tableName: "room";
2005
+ dataType: "string";
2006
+ columnType: "PgText";
2007
+ data: string;
2008
+ driverParam: string;
2009
+ notNull: false;
2010
+ hasDefault: false;
2011
+ isPrimaryKey: false;
2012
+ isAutoincrement: false;
2013
+ hasRuntimeDefault: false;
2014
+ enumValues: [string, ...string[]];
2015
+ baseColumn: never;
2016
+ identity: undefined;
2017
+ generated: undefined;
2018
+ }, {}, {}>;
2019
+ ownerId: import("drizzle-orm/pg-core").PgColumn<{
2020
+ name: "owner_id";
2021
+ tableName: "room";
2022
+ dataType: "string";
2023
+ columnType: "PgText";
2024
+ data: string;
2025
+ driverParam: string;
2026
+ notNull: false;
2027
+ hasDefault: false;
2028
+ isPrimaryKey: false;
2029
+ isAutoincrement: false;
2030
+ hasRuntimeDefault: false;
2031
+ enumValues: [string, ...string[]];
2032
+ baseColumn: never;
2033
+ identity: undefined;
2034
+ generated: undefined;
2035
+ }, {}, {}>;
2036
+ visibility: import("drizzle-orm/pg-core").PgColumn<{
2037
+ name: "visibility";
2038
+ tableName: "room";
2039
+ dataType: "string";
2040
+ columnType: "PgText";
2041
+ data: string;
2042
+ driverParam: string;
2043
+ notNull: true;
2044
+ hasDefault: true;
2045
+ isPrimaryKey: false;
2046
+ isAutoincrement: false;
2047
+ hasRuntimeDefault: false;
2048
+ enumValues: [string, ...string[]];
2049
+ baseColumn: never;
2050
+ identity: undefined;
2051
+ generated: undefined;
2052
+ }, {}, {}>;
2053
+ isSystem: import("drizzle-orm/pg-core").PgColumn<{
2054
+ name: "is_system";
2055
+ tableName: "room";
2056
+ dataType: "boolean";
2057
+ columnType: "PgBoolean";
2058
+ data: boolean;
2059
+ driverParam: boolean;
2060
+ notNull: true;
2061
+ hasDefault: true;
2062
+ isPrimaryKey: false;
2063
+ isAutoincrement: false;
2064
+ hasRuntimeDefault: false;
2065
+ enumValues: undefined;
2066
+ baseColumn: never;
2067
+ identity: undefined;
2068
+ generated: undefined;
2069
+ }, {}, {}>;
2070
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2071
+ name: "created_at";
2072
+ tableName: "room";
2073
+ dataType: "date";
2074
+ columnType: "PgTimestamp";
2075
+ data: Date;
2076
+ driverParam: string;
2077
+ notNull: true;
2078
+ hasDefault: true;
2079
+ isPrimaryKey: false;
2080
+ isAutoincrement: false;
2081
+ hasRuntimeDefault: false;
2082
+ enumValues: undefined;
2083
+ baseColumn: never;
2084
+ identity: undefined;
2085
+ generated: undefined;
2086
+ }, {}, {}>;
2087
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2088
+ name: "updated_at";
2089
+ tableName: "room";
2090
+ dataType: "date";
2091
+ columnType: "PgTimestamp";
2092
+ data: Date;
2093
+ driverParam: string;
2094
+ notNull: true;
2095
+ hasDefault: true;
2096
+ isPrimaryKey: false;
2097
+ isAutoincrement: false;
2098
+ hasRuntimeDefault: false;
2099
+ enumValues: undefined;
2100
+ baseColumn: never;
2101
+ identity: undefined;
2102
+ generated: undefined;
2103
+ }, {}, {}>;
2104
+ };
2105
+ dialect: "pg";
2106
+ }>;
2107
+ export declare const roomMember: import("drizzle-orm/pg-core").PgTableWithColumns<{
2108
+ name: "room_member";
2109
+ schema: undefined;
2110
+ columns: {
2111
+ roomId: import("drizzle-orm/pg-core").PgColumn<{
2112
+ name: "room_id";
2113
+ tableName: "room_member";
2114
+ dataType: "string";
2115
+ columnType: "PgText";
2116
+ data: string;
2117
+ driverParam: string;
2118
+ notNull: true;
2119
+ hasDefault: false;
2120
+ isPrimaryKey: false;
2121
+ isAutoincrement: false;
2122
+ hasRuntimeDefault: false;
2123
+ enumValues: [string, ...string[]];
2124
+ baseColumn: never;
2125
+ identity: undefined;
2126
+ generated: undefined;
2127
+ }, {}, {}>;
2128
+ userId: import("drizzle-orm/pg-core").PgColumn<{
2129
+ name: "user_id";
2130
+ tableName: "room_member";
2131
+ dataType: "string";
2132
+ columnType: "PgText";
2133
+ data: string;
2134
+ driverParam: string;
2135
+ notNull: true;
2136
+ hasDefault: false;
2137
+ isPrimaryKey: false;
2138
+ isAutoincrement: false;
2139
+ hasRuntimeDefault: false;
2140
+ enumValues: [string, ...string[]];
2141
+ baseColumn: never;
2142
+ identity: undefined;
2143
+ generated: undefined;
2144
+ }, {}, {}>;
2145
+ role: import("drizzle-orm/pg-core").PgColumn<{
2146
+ name: "role";
2147
+ tableName: "room_member";
2148
+ dataType: "string";
2149
+ columnType: "PgText";
2150
+ data: string;
2151
+ driverParam: string;
2152
+ notNull: true;
2153
+ hasDefault: true;
2154
+ isPrimaryKey: false;
2155
+ isAutoincrement: false;
2156
+ hasRuntimeDefault: false;
2157
+ enumValues: [string, ...string[]];
2158
+ baseColumn: never;
2159
+ identity: undefined;
2160
+ generated: undefined;
2161
+ }, {}, {}>;
2162
+ joinedAt: import("drizzle-orm/pg-core").PgColumn<{
2163
+ name: "joined_at";
2164
+ tableName: "room_member";
2165
+ dataType: "date";
2166
+ columnType: "PgTimestamp";
2167
+ data: Date;
2168
+ driverParam: string;
2169
+ notNull: true;
2170
+ hasDefault: true;
2171
+ isPrimaryKey: false;
2172
+ isAutoincrement: false;
2173
+ hasRuntimeDefault: false;
2174
+ enumValues: undefined;
2175
+ baseColumn: never;
2176
+ identity: undefined;
2177
+ generated: undefined;
2178
+ }, {}, {}>;
2179
+ };
2180
+ dialect: "pg";
2181
+ }>;
2182
+ export declare const roomRestriction: import("drizzle-orm/pg-core").PgTableWithColumns<{
2183
+ name: "room_restriction";
2184
+ schema: undefined;
2185
+ columns: {
2186
+ id: import("drizzle-orm/pg-core").PgColumn<{
2187
+ name: "id";
2188
+ tableName: "room_restriction";
2189
+ dataType: "string";
2190
+ columnType: "PgText";
2191
+ data: string;
2192
+ driverParam: string;
2193
+ notNull: true;
2194
+ hasDefault: false;
2195
+ isPrimaryKey: true;
2196
+ isAutoincrement: false;
2197
+ hasRuntimeDefault: false;
2198
+ enumValues: [string, ...string[]];
2199
+ baseColumn: never;
2200
+ identity: undefined;
2201
+ generated: undefined;
2202
+ }, {}, {}>;
2203
+ roomId: import("drizzle-orm/pg-core").PgColumn<{
2204
+ name: "room_id";
2205
+ tableName: "room_restriction";
2206
+ dataType: "string";
2207
+ columnType: "PgText";
2208
+ data: string;
2209
+ driverParam: string;
2210
+ notNull: true;
2211
+ hasDefault: false;
2212
+ isPrimaryKey: false;
2213
+ isAutoincrement: false;
2214
+ hasRuntimeDefault: false;
2215
+ enumValues: [string, ...string[]];
2216
+ baseColumn: never;
2217
+ identity: undefined;
2218
+ generated: undefined;
2219
+ }, {}, {}>;
2220
+ userId: import("drizzle-orm/pg-core").PgColumn<{
2221
+ name: "user_id";
2222
+ tableName: "room_restriction";
2223
+ dataType: "string";
2224
+ columnType: "PgText";
2225
+ data: string;
2226
+ driverParam: string;
2227
+ notNull: true;
2228
+ hasDefault: false;
2229
+ isPrimaryKey: false;
2230
+ isAutoincrement: false;
2231
+ hasRuntimeDefault: false;
2232
+ enumValues: [string, ...string[]];
2233
+ baseColumn: never;
2234
+ identity: undefined;
2235
+ generated: undefined;
2236
+ }, {}, {}>;
2237
+ kind: import("drizzle-orm/pg-core").PgColumn<{
2238
+ name: "kind";
2239
+ tableName: "room_restriction";
2240
+ dataType: "string";
2241
+ columnType: "PgText";
2242
+ data: string;
2243
+ driverParam: string;
2244
+ notNull: true;
2245
+ hasDefault: false;
2246
+ isPrimaryKey: false;
2247
+ isAutoincrement: false;
2248
+ hasRuntimeDefault: false;
2249
+ enumValues: [string, ...string[]];
2250
+ baseColumn: never;
2251
+ identity: undefined;
2252
+ generated: undefined;
2253
+ }, {}, {}>;
2254
+ reason: import("drizzle-orm/pg-core").PgColumn<{
2255
+ name: "reason";
2256
+ tableName: "room_restriction";
2257
+ dataType: "string";
2258
+ columnType: "PgText";
2259
+ data: string;
2260
+ driverParam: string;
2261
+ notNull: false;
2262
+ hasDefault: false;
2263
+ isPrimaryKey: false;
2264
+ isAutoincrement: false;
2265
+ hasRuntimeDefault: false;
2266
+ enumValues: [string, ...string[]];
2267
+ baseColumn: never;
2268
+ identity: undefined;
2269
+ generated: undefined;
2270
+ }, {}, {}>;
2271
+ issuedBy: import("drizzle-orm/pg-core").PgColumn<{
2272
+ name: "issued_by";
2273
+ tableName: "room_restriction";
2274
+ dataType: "string";
2275
+ columnType: "PgText";
2276
+ data: string;
2277
+ driverParam: string;
2278
+ notNull: false;
2279
+ hasDefault: false;
2280
+ isPrimaryKey: false;
2281
+ isAutoincrement: false;
2282
+ hasRuntimeDefault: false;
2283
+ enumValues: [string, ...string[]];
2284
+ baseColumn: never;
2285
+ identity: undefined;
2286
+ generated: undefined;
2287
+ }, {}, {}>;
2288
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
2289
+ name: "expires_at";
2290
+ tableName: "room_restriction";
2291
+ dataType: "date";
2292
+ columnType: "PgTimestamp";
2293
+ data: Date;
2294
+ driverParam: string;
2295
+ notNull: false;
2296
+ hasDefault: false;
2297
+ isPrimaryKey: false;
2298
+ isAutoincrement: false;
2299
+ hasRuntimeDefault: false;
2300
+ enumValues: undefined;
2301
+ baseColumn: never;
2302
+ identity: undefined;
2303
+ generated: undefined;
2304
+ }, {}, {}>;
2305
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2306
+ name: "created_at";
2307
+ tableName: "room_restriction";
2308
+ dataType: "date";
2309
+ columnType: "PgTimestamp";
2310
+ data: Date;
2311
+ driverParam: string;
2312
+ notNull: true;
2313
+ hasDefault: true;
2314
+ isPrimaryKey: false;
2315
+ isAutoincrement: false;
2316
+ hasRuntimeDefault: false;
2317
+ enumValues: undefined;
2318
+ baseColumn: never;
2319
+ identity: undefined;
2320
+ generated: undefined;
2321
+ }, {}, {}>;
2322
+ };
2323
+ dialect: "pg";
2324
+ }>;
2325
+ export declare const roomSettings: import("drizzle-orm/pg-core").PgTableWithColumns<{
2326
+ name: "room_settings";
2327
+ schema: undefined;
2328
+ columns: {
2329
+ roomId: import("drizzle-orm/pg-core").PgColumn<{
2330
+ name: "room_id";
2331
+ tableName: "room_settings";
2332
+ dataType: "string";
2333
+ columnType: "PgText";
2334
+ data: string;
2335
+ driverParam: string;
2336
+ notNull: true;
2337
+ hasDefault: false;
2338
+ isPrimaryKey: false;
2339
+ isAutoincrement: false;
2340
+ hasRuntimeDefault: false;
2341
+ enumValues: [string, ...string[]];
2342
+ baseColumn: never;
2343
+ identity: undefined;
2344
+ generated: undefined;
2345
+ }, {}, {}>;
2346
+ surface: import("drizzle-orm/pg-core").PgColumn<{
2347
+ name: "surface";
2348
+ tableName: "room_settings";
2349
+ dataType: "string";
2350
+ columnType: "PgText";
2351
+ data: string;
2352
+ driverParam: string;
2353
+ notNull: true;
2354
+ hasDefault: false;
2355
+ isPrimaryKey: false;
2356
+ isAutoincrement: false;
2357
+ hasRuntimeDefault: false;
2358
+ enumValues: [string, ...string[]];
2359
+ baseColumn: never;
2360
+ identity: undefined;
2361
+ generated: undefined;
2362
+ }, {}, {}>;
2363
+ data: import("drizzle-orm/pg-core").PgColumn<{
2364
+ name: "data";
2365
+ tableName: "room_settings";
2366
+ dataType: "json";
2367
+ columnType: "PgJsonb";
2368
+ data: StoredSettings;
2369
+ driverParam: unknown;
2370
+ notNull: true;
2371
+ hasDefault: true;
2372
+ isPrimaryKey: false;
2373
+ isAutoincrement: false;
2374
+ hasRuntimeDefault: false;
2375
+ enumValues: undefined;
2376
+ baseColumn: never;
2377
+ identity: undefined;
2378
+ generated: undefined;
2379
+ }, {}, {
2380
+ $type: StoredSettings;
2381
+ }>;
2382
+ version: import("drizzle-orm/pg-core").PgColumn<{
2383
+ name: "version";
2384
+ tableName: "room_settings";
2385
+ dataType: "number";
2386
+ columnType: "PgInteger";
2387
+ data: number;
2388
+ driverParam: string | number;
2389
+ notNull: true;
2390
+ hasDefault: true;
2391
+ isPrimaryKey: false;
2392
+ isAutoincrement: false;
2393
+ hasRuntimeDefault: false;
2394
+ enumValues: undefined;
2395
+ baseColumn: never;
2396
+ identity: undefined;
2397
+ generated: undefined;
2398
+ }, {}, {}>;
2399
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2400
+ name: "updated_at";
2401
+ tableName: "room_settings";
2402
+ dataType: "date";
2403
+ columnType: "PgTimestamp";
2404
+ data: Date;
2405
+ driverParam: string;
2406
+ notNull: true;
2407
+ hasDefault: true;
2408
+ isPrimaryKey: false;
2409
+ isAutoincrement: false;
2410
+ hasRuntimeDefault: false;
2411
+ enumValues: undefined;
2412
+ baseColumn: never;
2413
+ identity: undefined;
2414
+ generated: undefined;
2415
+ }, {}, {}>;
2416
+ };
2417
+ dialect: "pg";
2418
+ }>;
2419
+ export declare const roomPresence: import("drizzle-orm/pg-core").PgTableWithColumns<{
2420
+ name: "room_presence";
2421
+ schema: undefined;
2422
+ columns: {
2423
+ roomId: import("drizzle-orm/pg-core").PgColumn<{
2424
+ name: "room_id";
2425
+ tableName: "room_presence";
2426
+ dataType: "string";
2427
+ columnType: "PgText";
2428
+ data: string;
2429
+ driverParam: string;
2430
+ notNull: true;
2431
+ hasDefault: false;
2432
+ isPrimaryKey: false;
2433
+ isAutoincrement: false;
2434
+ hasRuntimeDefault: false;
2435
+ enumValues: [string, ...string[]];
2436
+ baseColumn: never;
2437
+ identity: undefined;
2438
+ generated: undefined;
2439
+ }, {}, {}>;
2440
+ userId: import("drizzle-orm/pg-core").PgColumn<{
2441
+ name: "user_id";
2442
+ tableName: "room_presence";
2443
+ dataType: "string";
2444
+ columnType: "PgText";
2445
+ data: string;
2446
+ driverParam: string;
2447
+ notNull: true;
2448
+ hasDefault: false;
2449
+ isPrimaryKey: false;
2450
+ isAutoincrement: false;
2451
+ hasRuntimeDefault: false;
2452
+ enumValues: [string, ...string[]];
2453
+ baseColumn: never;
2454
+ identity: undefined;
2455
+ generated: undefined;
2456
+ }, {}, {}>;
2457
+ channel: import("drizzle-orm/pg-core").PgColumn<{
2458
+ name: "channel";
2459
+ tableName: "room_presence";
2460
+ dataType: "string";
2461
+ columnType: "PgText";
2462
+ data: string;
2463
+ driverParam: string;
2464
+ notNull: true;
2465
+ hasDefault: false;
2466
+ isPrimaryKey: false;
2467
+ isAutoincrement: false;
2468
+ hasRuntimeDefault: false;
2469
+ enumValues: [string, ...string[]];
2470
+ baseColumn: never;
2471
+ identity: undefined;
2472
+ generated: undefined;
2473
+ }, {}, {}>;
2474
+ joinedAt: import("drizzle-orm/pg-core").PgColumn<{
2475
+ name: "joined_at";
2476
+ tableName: "room_presence";
2477
+ dataType: "date";
2478
+ columnType: "PgTimestamp";
2479
+ data: Date;
2480
+ driverParam: string;
2481
+ notNull: true;
2482
+ hasDefault: true;
2483
+ isPrimaryKey: false;
2484
+ isAutoincrement: false;
2485
+ hasRuntimeDefault: false;
2486
+ enumValues: undefined;
2487
+ baseColumn: never;
2488
+ identity: undefined;
2489
+ generated: undefined;
2490
+ }, {}, {}>;
2491
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2492
+ name: "updated_at";
2493
+ tableName: "room_presence";
2494
+ dataType: "date";
2495
+ columnType: "PgTimestamp";
2496
+ data: Date;
2497
+ driverParam: string;
2498
+ notNull: true;
2499
+ hasDefault: true;
2500
+ isPrimaryKey: false;
2501
+ isAutoincrement: false;
2502
+ hasRuntimeDefault: false;
2503
+ enumValues: undefined;
2504
+ baseColumn: never;
2505
+ identity: undefined;
2506
+ generated: undefined;
2507
+ }, {}, {}>;
2508
+ };
2509
+ dialect: "pg";
2510
+ }>;
2511
+ export declare const roomPlayerState: import("drizzle-orm/pg-core").PgTableWithColumns<{
2512
+ name: "room_player_state";
2513
+ schema: undefined;
2514
+ columns: {
2515
+ roomId: import("drizzle-orm/pg-core").PgColumn<{
2516
+ name: "room_id";
2517
+ tableName: "room_player_state";
2518
+ dataType: "string";
2519
+ columnType: "PgText";
2520
+ data: string;
2521
+ driverParam: string;
2522
+ notNull: true;
2523
+ hasDefault: false;
2524
+ isPrimaryKey: false;
2525
+ isAutoincrement: false;
2526
+ hasRuntimeDefault: false;
2527
+ enumValues: [string, ...string[]];
2528
+ baseColumn: never;
2529
+ identity: undefined;
2530
+ generated: undefined;
2531
+ }, {}, {}>;
2532
+ userId: import("drizzle-orm/pg-core").PgColumn<{
2533
+ name: "user_id";
2534
+ tableName: "room_player_state";
2535
+ dataType: "string";
2536
+ columnType: "PgText";
2537
+ data: string;
2538
+ driverParam: string;
2539
+ notNull: true;
2540
+ hasDefault: false;
2541
+ isPrimaryKey: false;
2542
+ isAutoincrement: false;
2543
+ hasRuntimeDefault: false;
2544
+ enumValues: [string, ...string[]];
2545
+ baseColumn: never;
2546
+ identity: undefined;
2547
+ generated: undefined;
2548
+ }, {}, {}>;
2549
+ x: import("drizzle-orm/pg-core").PgColumn<{
2550
+ name: "x";
2551
+ tableName: "room_player_state";
2552
+ dataType: "number";
2553
+ columnType: "PgReal";
2554
+ data: number;
2555
+ driverParam: string | number;
2556
+ notNull: true;
2557
+ hasDefault: false;
2558
+ isPrimaryKey: false;
2559
+ isAutoincrement: false;
2560
+ hasRuntimeDefault: false;
2561
+ enumValues: undefined;
2562
+ baseColumn: never;
2563
+ identity: undefined;
2564
+ generated: undefined;
2565
+ }, {}, {}>;
2566
+ y: import("drizzle-orm/pg-core").PgColumn<{
2567
+ name: "y";
2568
+ tableName: "room_player_state";
2569
+ dataType: "number";
2570
+ columnType: "PgReal";
2571
+ data: number;
2572
+ driverParam: string | number;
2573
+ notNull: true;
2574
+ hasDefault: false;
2575
+ isPrimaryKey: false;
2576
+ isAutoincrement: false;
2577
+ hasRuntimeDefault: false;
2578
+ enumValues: undefined;
2579
+ baseColumn: never;
2580
+ identity: undefined;
2581
+ generated: undefined;
2582
+ }, {}, {}>;
2583
+ z: import("drizzle-orm/pg-core").PgColumn<{
2584
+ name: "z";
2585
+ tableName: "room_player_state";
2586
+ dataType: "number";
2587
+ columnType: "PgReal";
2588
+ data: number;
2589
+ driverParam: string | number;
2590
+ notNull: true;
2591
+ hasDefault: false;
2592
+ isPrimaryKey: false;
2593
+ isAutoincrement: false;
2594
+ hasRuntimeDefault: false;
2595
+ enumValues: undefined;
2596
+ baseColumn: never;
2597
+ identity: undefined;
2598
+ generated: undefined;
2599
+ }, {}, {}>;
2600
+ yaw: import("drizzle-orm/pg-core").PgColumn<{
2601
+ name: "yaw";
2602
+ tableName: "room_player_state";
2603
+ dataType: "number";
2604
+ columnType: "PgReal";
2605
+ data: number;
2606
+ driverParam: string | number;
2607
+ notNull: true;
2608
+ hasDefault: false;
2609
+ isPrimaryKey: false;
2610
+ isAutoincrement: false;
2611
+ hasRuntimeDefault: false;
2612
+ enumValues: undefined;
2613
+ baseColumn: never;
2614
+ identity: undefined;
2615
+ generated: undefined;
2616
+ }, {}, {}>;
2617
+ worldId: import("drizzle-orm/pg-core").PgColumn<{
2618
+ name: "world_id";
2619
+ tableName: "room_player_state";
2620
+ dataType: "string";
2621
+ columnType: "PgText";
2622
+ data: string;
2623
+ driverParam: string;
2624
+ notNull: true;
2625
+ hasDefault: false;
2626
+ isPrimaryKey: false;
2627
+ isAutoincrement: false;
2628
+ hasRuntimeDefault: false;
2629
+ enumValues: [string, ...string[]];
2630
+ baseColumn: never;
2631
+ identity: undefined;
2632
+ generated: undefined;
2633
+ }, {}, {}>;
2634
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2635
+ name: "updated_at";
2636
+ tableName: "room_player_state";
2637
+ dataType: "date";
2638
+ columnType: "PgTimestamp";
2639
+ data: Date;
2640
+ driverParam: string;
2641
+ notNull: true;
2642
+ hasDefault: true;
2643
+ isPrimaryKey: false;
2644
+ isAutoincrement: false;
2645
+ hasRuntimeDefault: false;
2646
+ enumValues: undefined;
2647
+ baseColumn: never;
2648
+ identity: undefined;
2649
+ generated: undefined;
2650
+ }, {}, {}>;
2651
+ };
2652
+ dialect: "pg";
2653
+ }>;
2654
+ export declare const roomEvent: import("drizzle-orm/pg-core").PgTableWithColumns<{
2655
+ name: "room_event";
2656
+ schema: undefined;
2657
+ columns: {
2658
+ id: import("drizzle-orm/pg-core").PgColumn<{
2659
+ name: "id";
2660
+ tableName: "room_event";
2661
+ dataType: "string";
2662
+ columnType: "PgText";
2663
+ data: string;
2664
+ driverParam: string;
2665
+ notNull: true;
2666
+ hasDefault: false;
2667
+ isPrimaryKey: true;
2668
+ isAutoincrement: false;
2669
+ hasRuntimeDefault: false;
2670
+ enumValues: [string, ...string[]];
2671
+ baseColumn: never;
2672
+ identity: undefined;
2673
+ generated: undefined;
2674
+ }, {}, {}>;
2675
+ roomId: import("drizzle-orm/pg-core").PgColumn<{
2676
+ name: "room_id";
2677
+ tableName: "room_event";
2678
+ dataType: "string";
2679
+ columnType: "PgText";
2680
+ data: string;
2681
+ driverParam: string;
2682
+ notNull: true;
2683
+ hasDefault: false;
2684
+ isPrimaryKey: false;
2685
+ isAutoincrement: false;
2686
+ hasRuntimeDefault: false;
2687
+ enumValues: [string, ...string[]];
2688
+ baseColumn: never;
2689
+ identity: undefined;
2690
+ generated: undefined;
2691
+ }, {}, {}>;
2692
+ createdBy: import("drizzle-orm/pg-core").PgColumn<{
2693
+ name: "created_by";
2694
+ tableName: "room_event";
2695
+ dataType: "string";
2696
+ columnType: "PgText";
2697
+ data: string;
2698
+ driverParam: string;
2699
+ notNull: false;
2700
+ hasDefault: false;
2701
+ isPrimaryKey: false;
2702
+ isAutoincrement: false;
2703
+ hasRuntimeDefault: false;
2704
+ enumValues: [string, ...string[]];
2705
+ baseColumn: never;
2706
+ identity: undefined;
2707
+ generated: undefined;
2708
+ }, {}, {}>;
2709
+ title: import("drizzle-orm/pg-core").PgColumn<{
2710
+ name: "title";
2711
+ tableName: "room_event";
2712
+ dataType: "string";
2713
+ columnType: "PgText";
2714
+ data: string;
2715
+ driverParam: string;
2716
+ notNull: true;
2717
+ hasDefault: false;
2718
+ isPrimaryKey: false;
2719
+ isAutoincrement: false;
2720
+ hasRuntimeDefault: false;
2721
+ enumValues: [string, ...string[]];
2722
+ baseColumn: never;
2723
+ identity: undefined;
2724
+ generated: undefined;
2725
+ }, {}, {}>;
2726
+ description: import("drizzle-orm/pg-core").PgColumn<{
2727
+ name: "description";
2728
+ tableName: "room_event";
2729
+ dataType: "string";
2730
+ columnType: "PgText";
2731
+ data: string;
2732
+ driverParam: string;
2733
+ notNull: false;
2734
+ hasDefault: false;
2735
+ isPrimaryKey: false;
2736
+ isAutoincrement: false;
2737
+ hasRuntimeDefault: false;
2738
+ enumValues: [string, ...string[]];
2739
+ baseColumn: never;
2740
+ identity: undefined;
2741
+ generated: undefined;
2742
+ }, {}, {}>;
2743
+ coverUrl: import("drizzle-orm/pg-core").PgColumn<{
2744
+ name: "cover_url";
2745
+ tableName: "room_event";
2746
+ dataType: "string";
2747
+ columnType: "PgText";
2748
+ data: string;
2749
+ driverParam: string;
2750
+ notNull: false;
2751
+ hasDefault: false;
2752
+ isPrimaryKey: false;
2753
+ isAutoincrement: false;
2754
+ hasRuntimeDefault: false;
2755
+ enumValues: [string, ...string[]];
2756
+ baseColumn: never;
2757
+ identity: undefined;
2758
+ generated: undefined;
2759
+ }, {}, {}>;
2760
+ startsAt: import("drizzle-orm/pg-core").PgColumn<{
2761
+ name: "starts_at";
2762
+ tableName: "room_event";
2763
+ dataType: "date";
2764
+ columnType: "PgTimestamp";
2765
+ data: Date;
2766
+ driverParam: string;
2767
+ notNull: true;
2768
+ hasDefault: false;
2769
+ isPrimaryKey: false;
2770
+ isAutoincrement: false;
2771
+ hasRuntimeDefault: false;
2772
+ enumValues: undefined;
2773
+ baseColumn: never;
2774
+ identity: undefined;
2775
+ generated: undefined;
2776
+ }, {}, {}>;
2777
+ endsAt: import("drizzle-orm/pg-core").PgColumn<{
2778
+ name: "ends_at";
2779
+ tableName: "room_event";
2780
+ dataType: "date";
2781
+ columnType: "PgTimestamp";
2782
+ data: Date;
2783
+ driverParam: string;
2784
+ notNull: false;
2785
+ hasDefault: false;
2786
+ isPrimaryKey: false;
2787
+ isAutoincrement: false;
2788
+ hasRuntimeDefault: false;
2789
+ enumValues: undefined;
2790
+ baseColumn: never;
2791
+ identity: undefined;
2792
+ generated: undefined;
2793
+ }, {}, {}>;
2794
+ timezone: import("drizzle-orm/pg-core").PgColumn<{
2795
+ name: "timezone";
2796
+ tableName: "room_event";
2797
+ dataType: "string";
2798
+ columnType: "PgText";
2799
+ data: string;
2800
+ driverParam: string;
2801
+ notNull: true;
2802
+ hasDefault: true;
2803
+ isPrimaryKey: false;
2804
+ isAutoincrement: false;
2805
+ hasRuntimeDefault: false;
2806
+ enumValues: [string, ...string[]];
2807
+ baseColumn: never;
2808
+ identity: undefined;
2809
+ generated: undefined;
2810
+ }, {}, {}>;
2811
+ recurrence: import("drizzle-orm/pg-core").PgColumn<{
2812
+ name: "recurrence";
2813
+ tableName: "room_event";
2814
+ dataType: "json";
2815
+ columnType: "PgJsonb";
2816
+ data: RoomEventRecurrence;
2817
+ driverParam: unknown;
2818
+ notNull: false;
2819
+ hasDefault: false;
2820
+ isPrimaryKey: false;
2821
+ isAutoincrement: false;
2822
+ hasRuntimeDefault: false;
2823
+ enumValues: undefined;
2824
+ baseColumn: never;
2825
+ identity: undefined;
2826
+ generated: undefined;
2827
+ }, {}, {
2828
+ $type: RoomEventRecurrence;
2829
+ }>;
2830
+ discordEventId: import("drizzle-orm/pg-core").PgColumn<{
2831
+ name: "discord_event_id";
2832
+ tableName: "room_event";
2833
+ dataType: "string";
2834
+ columnType: "PgText";
2835
+ data: string;
2836
+ driverParam: string;
2837
+ notNull: false;
2838
+ hasDefault: false;
2839
+ isPrimaryKey: false;
2840
+ isAutoincrement: false;
2841
+ hasRuntimeDefault: false;
2842
+ enumValues: [string, ...string[]];
2843
+ baseColumn: never;
2844
+ identity: undefined;
2845
+ generated: undefined;
2846
+ }, {}, {}>;
2847
+ discordSyncedAt: import("drizzle-orm/pg-core").PgColumn<{
2848
+ name: "discord_synced_at";
2849
+ tableName: "room_event";
2850
+ dataType: "date";
2851
+ columnType: "PgTimestamp";
2852
+ data: Date;
2853
+ driverParam: string;
2854
+ notNull: false;
2855
+ hasDefault: false;
2856
+ isPrimaryKey: false;
2857
+ isAutoincrement: false;
2858
+ hasRuntimeDefault: false;
2859
+ enumValues: undefined;
2860
+ baseColumn: never;
2861
+ identity: undefined;
2862
+ generated: undefined;
2863
+ }, {}, {}>;
2864
+ reminderOffsets: import("drizzle-orm/pg-core").PgColumn<{
2865
+ name: "reminder_offsets";
2866
+ tableName: "room_event";
2867
+ dataType: "json";
2868
+ columnType: "PgJsonb";
2869
+ data: number[];
2870
+ driverParam: unknown;
2871
+ notNull: false;
2872
+ hasDefault: false;
2873
+ isPrimaryKey: false;
2874
+ isAutoincrement: false;
2875
+ hasRuntimeDefault: false;
2876
+ enumValues: undefined;
2877
+ baseColumn: never;
2878
+ identity: undefined;
2879
+ generated: undefined;
2880
+ }, {}, {
2881
+ $type: number[];
2882
+ }>;
2883
+ status: import("drizzle-orm/pg-core").PgColumn<{
2884
+ name: "status";
2885
+ tableName: "room_event";
2886
+ dataType: "string";
2887
+ columnType: "PgText";
2888
+ data: string;
2889
+ driverParam: string;
2890
+ notNull: true;
2891
+ hasDefault: true;
2892
+ isPrimaryKey: false;
2893
+ isAutoincrement: false;
2894
+ hasRuntimeDefault: false;
2895
+ enumValues: [string, ...string[]];
2896
+ baseColumn: never;
2897
+ identity: undefined;
2898
+ generated: undefined;
2899
+ }, {}, {}>;
2900
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2901
+ name: "created_at";
2902
+ tableName: "room_event";
2903
+ dataType: "date";
2904
+ columnType: "PgTimestamp";
2905
+ data: Date;
2906
+ driverParam: string;
2907
+ notNull: true;
2908
+ hasDefault: true;
2909
+ isPrimaryKey: false;
2910
+ isAutoincrement: false;
2911
+ hasRuntimeDefault: false;
2912
+ enumValues: undefined;
2913
+ baseColumn: never;
2914
+ identity: undefined;
2915
+ generated: undefined;
2916
+ }, {}, {}>;
2917
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2918
+ name: "updated_at";
2919
+ tableName: "room_event";
2920
+ dataType: "date";
2921
+ columnType: "PgTimestamp";
2922
+ data: Date;
2923
+ driverParam: string;
2924
+ notNull: true;
2925
+ hasDefault: true;
2926
+ isPrimaryKey: false;
2927
+ isAutoincrement: false;
2928
+ hasRuntimeDefault: false;
2929
+ enumValues: undefined;
2930
+ baseColumn: never;
2931
+ identity: undefined;
2932
+ generated: undefined;
2933
+ }, {}, {}>;
2934
+ };
2935
+ dialect: "pg";
2936
+ }>;
2937
+ export declare const roomEventOccurrence: import("drizzle-orm/pg-core").PgTableWithColumns<{
2938
+ name: "room_event_occurrence";
2939
+ schema: undefined;
2940
+ columns: {
2941
+ id: import("drizzle-orm/pg-core").PgColumn<{
2942
+ name: "id";
2943
+ tableName: "room_event_occurrence";
2944
+ dataType: "string";
2945
+ columnType: "PgText";
2946
+ data: string;
2947
+ driverParam: string;
2948
+ notNull: true;
2949
+ hasDefault: false;
2950
+ isPrimaryKey: true;
2951
+ isAutoincrement: false;
2952
+ hasRuntimeDefault: false;
2953
+ enumValues: [string, ...string[]];
2954
+ baseColumn: never;
2955
+ identity: undefined;
2956
+ generated: undefined;
2957
+ }, {}, {}>;
2958
+ eventId: import("drizzle-orm/pg-core").PgColumn<{
2959
+ name: "event_id";
2960
+ tableName: "room_event_occurrence";
2961
+ dataType: "string";
2962
+ columnType: "PgText";
2963
+ data: string;
2964
+ driverParam: string;
2965
+ notNull: true;
2966
+ hasDefault: false;
2967
+ isPrimaryKey: false;
2968
+ isAutoincrement: false;
2969
+ hasRuntimeDefault: false;
2970
+ enumValues: [string, ...string[]];
2971
+ baseColumn: never;
2972
+ identity: undefined;
2973
+ generated: undefined;
2974
+ }, {}, {}>;
2975
+ roomId: import("drizzle-orm/pg-core").PgColumn<{
2976
+ name: "room_id";
2977
+ tableName: "room_event_occurrence";
2978
+ dataType: "string";
2979
+ columnType: "PgText";
2980
+ data: string;
2981
+ driverParam: string;
2982
+ notNull: true;
2983
+ hasDefault: false;
2984
+ isPrimaryKey: false;
2985
+ isAutoincrement: false;
2986
+ hasRuntimeDefault: false;
2987
+ enumValues: [string, ...string[]];
2988
+ baseColumn: never;
2989
+ identity: undefined;
2990
+ generated: undefined;
2991
+ }, {}, {}>;
2992
+ recurrenceId: import("drizzle-orm/pg-core").PgColumn<{
2993
+ name: "recurrence_id";
2994
+ tableName: "room_event_occurrence";
2995
+ dataType: "date";
2996
+ columnType: "PgTimestamp";
2997
+ data: Date;
2998
+ driverParam: string;
2999
+ notNull: true;
3000
+ hasDefault: false;
3001
+ isPrimaryKey: false;
3002
+ isAutoincrement: false;
3003
+ hasRuntimeDefault: false;
3004
+ enumValues: undefined;
3005
+ baseColumn: never;
3006
+ identity: undefined;
3007
+ generated: undefined;
3008
+ }, {}, {}>;
3009
+ startsAt: import("drizzle-orm/pg-core").PgColumn<{
3010
+ name: "starts_at";
3011
+ tableName: "room_event_occurrence";
3012
+ dataType: "date";
3013
+ columnType: "PgTimestamp";
3014
+ data: Date;
3015
+ driverParam: string;
3016
+ notNull: true;
3017
+ hasDefault: false;
3018
+ isPrimaryKey: false;
3019
+ isAutoincrement: false;
3020
+ hasRuntimeDefault: false;
3021
+ enumValues: undefined;
3022
+ baseColumn: never;
3023
+ identity: undefined;
3024
+ generated: undefined;
3025
+ }, {}, {}>;
3026
+ endsAt: import("drizzle-orm/pg-core").PgColumn<{
3027
+ name: "ends_at";
3028
+ tableName: "room_event_occurrence";
3029
+ dataType: "date";
3030
+ columnType: "PgTimestamp";
3031
+ data: Date;
3032
+ driverParam: string;
3033
+ notNull: false;
3034
+ hasDefault: false;
3035
+ isPrimaryKey: false;
3036
+ isAutoincrement: false;
3037
+ hasRuntimeDefault: false;
3038
+ enumValues: undefined;
3039
+ baseColumn: never;
3040
+ identity: undefined;
3041
+ generated: undefined;
3042
+ }, {}, {}>;
3043
+ status: import("drizzle-orm/pg-core").PgColumn<{
3044
+ name: "status";
3045
+ tableName: "room_event_occurrence";
3046
+ dataType: "string";
3047
+ columnType: "PgText";
3048
+ data: string;
3049
+ driverParam: string;
3050
+ notNull: true;
3051
+ hasDefault: true;
3052
+ isPrimaryKey: false;
3053
+ isAutoincrement: false;
3054
+ hasRuntimeDefault: false;
3055
+ enumValues: [string, ...string[]];
3056
+ baseColumn: never;
3057
+ identity: undefined;
3058
+ generated: undefined;
3059
+ }, {}, {}>;
3060
+ overridden: import("drizzle-orm/pg-core").PgColumn<{
3061
+ name: "overridden";
3062
+ tableName: "room_event_occurrence";
3063
+ dataType: "boolean";
3064
+ columnType: "PgBoolean";
3065
+ data: boolean;
3066
+ driverParam: boolean;
3067
+ notNull: true;
3068
+ hasDefault: true;
3069
+ isPrimaryKey: false;
3070
+ isAutoincrement: false;
3071
+ hasRuntimeDefault: false;
3072
+ enumValues: undefined;
3073
+ baseColumn: never;
3074
+ identity: undefined;
3075
+ generated: undefined;
3076
+ }, {}, {}>;
3077
+ attendeeCount: import("drizzle-orm/pg-core").PgColumn<{
3078
+ name: "attendee_count";
3079
+ tableName: "room_event_occurrence";
3080
+ dataType: "number";
3081
+ columnType: "PgInteger";
3082
+ data: number;
3083
+ driverParam: string | number;
3084
+ notNull: false;
3085
+ hasDefault: false;
3086
+ isPrimaryKey: false;
3087
+ isAutoincrement: false;
3088
+ hasRuntimeDefault: false;
3089
+ enumValues: undefined;
3090
+ baseColumn: never;
3091
+ identity: undefined;
3092
+ generated: undefined;
3093
+ }, {}, {}>;
3094
+ peakConcurrent: import("drizzle-orm/pg-core").PgColumn<{
3095
+ name: "peak_concurrent";
3096
+ tableName: "room_event_occurrence";
3097
+ dataType: "number";
3098
+ columnType: "PgInteger";
3099
+ data: number;
3100
+ driverParam: string | number;
3101
+ notNull: false;
3102
+ hasDefault: false;
3103
+ isPrimaryKey: false;
3104
+ isAutoincrement: false;
3105
+ hasRuntimeDefault: false;
3106
+ enumValues: undefined;
3107
+ baseColumn: never;
3108
+ identity: undefined;
3109
+ generated: undefined;
3110
+ }, {}, {}>;
3111
+ discordEventId: import("drizzle-orm/pg-core").PgColumn<{
3112
+ name: "discord_event_id";
3113
+ tableName: "room_event_occurrence";
3114
+ dataType: "string";
3115
+ columnType: "PgText";
3116
+ data: string;
3117
+ driverParam: string;
3118
+ notNull: false;
3119
+ hasDefault: false;
3120
+ isPrimaryKey: false;
3121
+ isAutoincrement: false;
3122
+ hasRuntimeDefault: false;
3123
+ enumValues: [string, ...string[]];
3124
+ baseColumn: never;
3125
+ identity: undefined;
3126
+ generated: undefined;
3127
+ }, {}, {}>;
3128
+ discordSyncedAt: import("drizzle-orm/pg-core").PgColumn<{
3129
+ name: "discord_synced_at";
3130
+ tableName: "room_event_occurrence";
3131
+ dataType: "date";
3132
+ columnType: "PgTimestamp";
3133
+ data: Date;
3134
+ driverParam: string;
3135
+ notNull: false;
3136
+ hasDefault: false;
3137
+ isPrimaryKey: false;
3138
+ isAutoincrement: false;
3139
+ hasRuntimeDefault: false;
3140
+ enumValues: undefined;
3141
+ baseColumn: never;
3142
+ identity: undefined;
3143
+ generated: undefined;
3144
+ }, {}, {}>;
3145
+ actualStartedAt: import("drizzle-orm/pg-core").PgColumn<{
3146
+ name: "actual_started_at";
3147
+ tableName: "room_event_occurrence";
3148
+ dataType: "date";
3149
+ columnType: "PgTimestamp";
3150
+ data: Date;
3151
+ driverParam: string;
3152
+ notNull: false;
3153
+ hasDefault: false;
3154
+ isPrimaryKey: false;
3155
+ isAutoincrement: false;
3156
+ hasRuntimeDefault: false;
3157
+ enumValues: undefined;
3158
+ baseColumn: never;
3159
+ identity: undefined;
3160
+ generated: undefined;
3161
+ }, {}, {}>;
3162
+ actualEndedAt: import("drizzle-orm/pg-core").PgColumn<{
3163
+ name: "actual_ended_at";
3164
+ tableName: "room_event_occurrence";
3165
+ dataType: "date";
3166
+ columnType: "PgTimestamp";
3167
+ data: Date;
3168
+ driverParam: string;
3169
+ notNull: false;
3170
+ hasDefault: false;
3171
+ isPrimaryKey: false;
3172
+ isAutoincrement: false;
3173
+ hasRuntimeDefault: false;
3174
+ enumValues: undefined;
3175
+ baseColumn: never;
3176
+ identity: undefined;
3177
+ generated: undefined;
3178
+ }, {}, {}>;
3179
+ activatedAt: import("drizzle-orm/pg-core").PgColumn<{
3180
+ name: "activated_at";
3181
+ tableName: "room_event_occurrence";
3182
+ dataType: "date";
3183
+ columnType: "PgTimestamp";
3184
+ data: Date;
3185
+ driverParam: string;
3186
+ notNull: false;
3187
+ hasDefault: false;
3188
+ isPrimaryKey: false;
3189
+ isAutoincrement: false;
3190
+ hasRuntimeDefault: false;
3191
+ enumValues: undefined;
3192
+ baseColumn: never;
3193
+ identity: undefined;
3194
+ generated: undefined;
3195
+ }, {}, {}>;
3196
+ completedAt: import("drizzle-orm/pg-core").PgColumn<{
3197
+ name: "completed_at";
3198
+ tableName: "room_event_occurrence";
3199
+ dataType: "date";
3200
+ columnType: "PgTimestamp";
3201
+ data: Date;
3202
+ driverParam: string;
3203
+ notNull: false;
3204
+ hasDefault: false;
3205
+ isPrimaryKey: false;
3206
+ isAutoincrement: false;
3207
+ hasRuntimeDefault: false;
3208
+ enumValues: undefined;
3209
+ baseColumn: never;
3210
+ identity: undefined;
3211
+ generated: undefined;
3212
+ }, {}, {}>;
3213
+ cancelledAt: import("drizzle-orm/pg-core").PgColumn<{
3214
+ name: "cancelled_at";
3215
+ tableName: "room_event_occurrence";
3216
+ dataType: "date";
3217
+ columnType: "PgTimestamp";
3218
+ data: Date;
3219
+ driverParam: string;
3220
+ notNull: false;
3221
+ hasDefault: false;
3222
+ isPrimaryKey: false;
3223
+ isAutoincrement: false;
3224
+ hasRuntimeDefault: false;
3225
+ enumValues: undefined;
3226
+ baseColumn: never;
3227
+ identity: undefined;
3228
+ generated: undefined;
3229
+ }, {}, {}>;
3230
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
3231
+ name: "created_at";
3232
+ tableName: "room_event_occurrence";
3233
+ dataType: "date";
3234
+ columnType: "PgTimestamp";
3235
+ data: Date;
3236
+ driverParam: string;
3237
+ notNull: true;
3238
+ hasDefault: true;
3239
+ isPrimaryKey: false;
3240
+ isAutoincrement: false;
3241
+ hasRuntimeDefault: false;
3242
+ enumValues: undefined;
3243
+ baseColumn: never;
3244
+ identity: undefined;
3245
+ generated: undefined;
3246
+ }, {}, {}>;
3247
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
3248
+ name: "updated_at";
3249
+ tableName: "room_event_occurrence";
3250
+ dataType: "date";
3251
+ columnType: "PgTimestamp";
3252
+ data: Date;
3253
+ driverParam: string;
3254
+ notNull: true;
3255
+ hasDefault: true;
3256
+ isPrimaryKey: false;
3257
+ isAutoincrement: false;
3258
+ hasRuntimeDefault: false;
3259
+ enumValues: undefined;
3260
+ baseColumn: never;
3261
+ identity: undefined;
3262
+ generated: undefined;
3263
+ }, {}, {}>;
3264
+ };
3265
+ dialect: "pg";
3266
+ }>;
3267
+ export declare const roomEventRsvp: import("drizzle-orm/pg-core").PgTableWithColumns<{
3268
+ name: "room_event_rsvp";
3269
+ schema: undefined;
3270
+ columns: {
3271
+ occurrenceId: import("drizzle-orm/pg-core").PgColumn<{
3272
+ name: "occurrence_id";
3273
+ tableName: "room_event_rsvp";
3274
+ dataType: "string";
3275
+ columnType: "PgText";
3276
+ data: string;
3277
+ driverParam: string;
3278
+ notNull: true;
3279
+ hasDefault: false;
3280
+ isPrimaryKey: false;
3281
+ isAutoincrement: false;
3282
+ hasRuntimeDefault: false;
3283
+ enumValues: [string, ...string[]];
3284
+ baseColumn: never;
3285
+ identity: undefined;
3286
+ generated: undefined;
3287
+ }, {}, {}>;
3288
+ userId: import("drizzle-orm/pg-core").PgColumn<{
3289
+ name: "user_id";
3290
+ tableName: "room_event_rsvp";
3291
+ dataType: "string";
3292
+ columnType: "PgText";
3293
+ data: string;
3294
+ driverParam: string;
3295
+ notNull: true;
3296
+ hasDefault: false;
3297
+ isPrimaryKey: false;
3298
+ isAutoincrement: false;
3299
+ hasRuntimeDefault: false;
3300
+ enumValues: [string, ...string[]];
3301
+ baseColumn: never;
3302
+ identity: undefined;
3303
+ generated: undefined;
3304
+ }, {}, {}>;
3305
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
3306
+ name: "created_at";
3307
+ tableName: "room_event_rsvp";
3308
+ dataType: "date";
3309
+ columnType: "PgTimestamp";
3310
+ data: Date;
3311
+ driverParam: string;
3312
+ notNull: true;
3313
+ hasDefault: true;
3314
+ isPrimaryKey: false;
3315
+ isAutoincrement: false;
3316
+ hasRuntimeDefault: false;
3317
+ enumValues: undefined;
3318
+ baseColumn: never;
3319
+ identity: undefined;
3320
+ generated: undefined;
3321
+ }, {}, {}>;
3322
+ };
3323
+ dialect: "pg";
3324
+ }>;
3325
+ export declare const roomEventFollow: import("drizzle-orm/pg-core").PgTableWithColumns<{
3326
+ name: "room_event_follow";
3327
+ schema: undefined;
3328
+ columns: {
3329
+ eventId: import("drizzle-orm/pg-core").PgColumn<{
3330
+ name: "event_id";
3331
+ tableName: "room_event_follow";
3332
+ dataType: "string";
3333
+ columnType: "PgText";
3334
+ data: string;
3335
+ driverParam: string;
3336
+ notNull: true;
3337
+ hasDefault: false;
3338
+ isPrimaryKey: false;
3339
+ isAutoincrement: false;
3340
+ hasRuntimeDefault: false;
3341
+ enumValues: [string, ...string[]];
3342
+ baseColumn: never;
3343
+ identity: undefined;
3344
+ generated: undefined;
3345
+ }, {}, {}>;
3346
+ userId: import("drizzle-orm/pg-core").PgColumn<{
3347
+ name: "user_id";
3348
+ tableName: "room_event_follow";
3349
+ dataType: "string";
3350
+ columnType: "PgText";
3351
+ data: string;
3352
+ driverParam: string;
3353
+ notNull: true;
3354
+ hasDefault: false;
3355
+ isPrimaryKey: false;
3356
+ isAutoincrement: false;
3357
+ hasRuntimeDefault: false;
3358
+ enumValues: [string, ...string[]];
3359
+ baseColumn: never;
3360
+ identity: undefined;
3361
+ generated: undefined;
3362
+ }, {}, {}>;
3363
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
3364
+ name: "created_at";
3365
+ tableName: "room_event_follow";
3366
+ dataType: "date";
3367
+ columnType: "PgTimestamp";
3368
+ data: Date;
3369
+ driverParam: string;
3370
+ notNull: true;
3371
+ hasDefault: true;
3372
+ isPrimaryKey: false;
3373
+ isAutoincrement: false;
3374
+ hasRuntimeDefault: false;
3375
+ enumValues: undefined;
3376
+ baseColumn: never;
3377
+ identity: undefined;
3378
+ generated: undefined;
3379
+ }, {}, {}>;
3380
+ };
3381
+ dialect: "pg";
3382
+ }>;
3383
+ export declare const roomEventDispatch: import("drizzle-orm/pg-core").PgTableWithColumns<{
3384
+ name: "room_event_dispatch";
3385
+ schema: undefined;
3386
+ columns: {
3387
+ id: import("drizzle-orm/pg-core").PgColumn<{
3388
+ name: "id";
3389
+ tableName: "room_event_dispatch";
3390
+ dataType: "string";
3391
+ columnType: "PgText";
3392
+ data: string;
3393
+ driverParam: string;
3394
+ notNull: true;
3395
+ hasDefault: false;
3396
+ isPrimaryKey: true;
3397
+ isAutoincrement: false;
3398
+ hasRuntimeDefault: false;
3399
+ enumValues: [string, ...string[]];
3400
+ baseColumn: never;
3401
+ identity: undefined;
3402
+ generated: undefined;
3403
+ }, {}, {}>;
3404
+ occurrenceId: import("drizzle-orm/pg-core").PgColumn<{
3405
+ name: "occurrence_id";
3406
+ tableName: "room_event_dispatch";
3407
+ dataType: "string";
3408
+ columnType: "PgText";
3409
+ data: string;
3410
+ driverParam: string;
3411
+ notNull: true;
3412
+ hasDefault: false;
3413
+ isPrimaryKey: false;
3414
+ isAutoincrement: false;
3415
+ hasRuntimeDefault: false;
3416
+ enumValues: [string, ...string[]];
3417
+ baseColumn: never;
3418
+ identity: undefined;
3419
+ generated: undefined;
3420
+ }, {}, {}>;
3421
+ kind: import("drizzle-orm/pg-core").PgColumn<{
3422
+ name: "kind";
3423
+ tableName: "room_event_dispatch";
3424
+ dataType: "string";
3425
+ columnType: "PgText";
3426
+ data: string;
3427
+ driverParam: string;
3428
+ notNull: true;
3429
+ hasDefault: false;
3430
+ isPrimaryKey: false;
3431
+ isAutoincrement: false;
3432
+ hasRuntimeDefault: false;
3433
+ enumValues: [string, ...string[]];
3434
+ baseColumn: never;
3435
+ identity: undefined;
3436
+ generated: undefined;
3437
+ }, {}, {}>;
3438
+ channel: import("drizzle-orm/pg-core").PgColumn<{
3439
+ name: "channel";
3440
+ tableName: "room_event_dispatch";
3441
+ dataType: "string";
3442
+ columnType: "PgText";
3443
+ data: string;
3444
+ driverParam: string;
3445
+ notNull: true;
3446
+ hasDefault: false;
3447
+ isPrimaryKey: false;
3448
+ isAutoincrement: false;
3449
+ hasRuntimeDefault: false;
3450
+ enumValues: [string, ...string[]];
3451
+ baseColumn: never;
3452
+ identity: undefined;
3453
+ generated: undefined;
3454
+ }, {}, {}>;
3455
+ outcome: import("drizzle-orm/pg-core").PgColumn<{
3456
+ name: "outcome";
3457
+ tableName: "room_event_dispatch";
3458
+ dataType: "string";
3459
+ columnType: "PgText";
3460
+ data: string;
3461
+ driverParam: string;
3462
+ notNull: true;
3463
+ hasDefault: true;
3464
+ isPrimaryKey: false;
3465
+ isAutoincrement: false;
3466
+ hasRuntimeDefault: false;
3467
+ enumValues: [string, ...string[]];
3468
+ baseColumn: never;
3469
+ identity: undefined;
3470
+ generated: undefined;
3471
+ }, {}, {}>;
3472
+ recipients: import("drizzle-orm/pg-core").PgColumn<{
3473
+ name: "recipients";
3474
+ tableName: "room_event_dispatch";
3475
+ dataType: "number";
3476
+ columnType: "PgInteger";
3477
+ data: number;
3478
+ driverParam: string | number;
3479
+ notNull: true;
3480
+ hasDefault: true;
3481
+ isPrimaryKey: false;
3482
+ isAutoincrement: false;
3483
+ hasRuntimeDefault: false;
3484
+ enumValues: undefined;
3485
+ baseColumn: never;
3486
+ identity: undefined;
3487
+ generated: undefined;
3488
+ }, {}, {}>;
3489
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
3490
+ name: "created_at";
3491
+ tableName: "room_event_dispatch";
3492
+ dataType: "date";
3493
+ columnType: "PgTimestamp";
3494
+ data: Date;
3495
+ driverParam: string;
3496
+ notNull: true;
3497
+ hasDefault: true;
3498
+ isPrimaryKey: false;
3499
+ isAutoincrement: false;
3500
+ hasRuntimeDefault: false;
3501
+ enumValues: undefined;
3502
+ baseColumn: never;
3503
+ identity: undefined;
3504
+ generated: undefined;
3505
+ }, {}, {}>;
3506
+ };
3507
+ dialect: "pg";
3508
+ }>;
3509
+ export declare const roomEventAttendance: import("drizzle-orm/pg-core").PgTableWithColumns<{
3510
+ name: "room_event_attendance";
3511
+ schema: undefined;
3512
+ columns: {
3513
+ occurrenceId: import("drizzle-orm/pg-core").PgColumn<{
3514
+ name: "occurrence_id";
3515
+ tableName: "room_event_attendance";
3516
+ dataType: "string";
3517
+ columnType: "PgText";
3518
+ data: string;
3519
+ driverParam: string;
3520
+ notNull: true;
3521
+ hasDefault: false;
3522
+ isPrimaryKey: false;
3523
+ isAutoincrement: false;
3524
+ hasRuntimeDefault: false;
3525
+ enumValues: [string, ...string[]];
3526
+ baseColumn: never;
3527
+ identity: undefined;
3528
+ generated: undefined;
3529
+ }, {}, {}>;
3530
+ userId: import("drizzle-orm/pg-core").PgColumn<{
3531
+ name: "user_id";
3532
+ tableName: "room_event_attendance";
3533
+ dataType: "string";
3534
+ columnType: "PgText";
3535
+ data: string;
3536
+ driverParam: string;
3537
+ notNull: true;
3538
+ hasDefault: false;
3539
+ isPrimaryKey: false;
3540
+ isAutoincrement: false;
3541
+ hasRuntimeDefault: false;
3542
+ enumValues: [string, ...string[]];
3543
+ baseColumn: never;
3544
+ identity: undefined;
3545
+ generated: undefined;
3546
+ }, {}, {}>;
3547
+ firstSeenAt: import("drizzle-orm/pg-core").PgColumn<{
3548
+ name: "first_seen_at";
3549
+ tableName: "room_event_attendance";
3550
+ dataType: "date";
3551
+ columnType: "PgTimestamp";
3552
+ data: Date;
3553
+ driverParam: string;
3554
+ notNull: true;
3555
+ hasDefault: true;
3556
+ isPrimaryKey: false;
3557
+ isAutoincrement: false;
3558
+ hasRuntimeDefault: false;
3559
+ enumValues: undefined;
3560
+ baseColumn: never;
3561
+ identity: undefined;
3562
+ generated: undefined;
3563
+ }, {}, {}>;
3564
+ lastSeenAt: import("drizzle-orm/pg-core").PgColumn<{
3565
+ name: "last_seen_at";
3566
+ tableName: "room_event_attendance";
3567
+ dataType: "date";
3568
+ columnType: "PgTimestamp";
3569
+ data: Date;
3570
+ driverParam: string;
3571
+ notNull: true;
3572
+ hasDefault: true;
3573
+ isPrimaryKey: false;
3574
+ isAutoincrement: false;
3575
+ hasRuntimeDefault: false;
3576
+ enumValues: undefined;
3577
+ baseColumn: never;
3578
+ identity: undefined;
3579
+ generated: undefined;
3580
+ }, {}, {}>;
3581
+ };
3582
+ dialect: "pg";
3583
+ }>;
3584
+ export declare const gameEvent: import("drizzle-orm/pg-core").PgTableWithColumns<{
3585
+ name: "game_event";
3586
+ schema: undefined;
3587
+ columns: {
3588
+ id: import("drizzle-orm/pg-core").PgColumn<{
3589
+ name: "id";
3590
+ tableName: "game_event";
3591
+ dataType: "string";
3592
+ columnType: "PgText";
3593
+ data: string;
3594
+ driverParam: string;
3595
+ notNull: true;
3596
+ hasDefault: false;
3597
+ isPrimaryKey: true;
3598
+ isAutoincrement: false;
3599
+ hasRuntimeDefault: false;
3600
+ enumValues: [string, ...string[]];
3601
+ baseColumn: never;
3602
+ identity: undefined;
3603
+ generated: undefined;
3604
+ }, {}, {}>;
3605
+ event: import("drizzle-orm/pg-core").PgColumn<{
3606
+ name: "event";
3607
+ tableName: "game_event";
3608
+ dataType: "string";
3609
+ columnType: "PgText";
3610
+ data: string;
3611
+ driverParam: string;
3612
+ notNull: true;
3613
+ hasDefault: false;
3614
+ isPrimaryKey: false;
3615
+ isAutoincrement: false;
3616
+ hasRuntimeDefault: false;
3617
+ enumValues: [string, ...string[]];
3618
+ baseColumn: never;
3619
+ identity: undefined;
3620
+ generated: undefined;
3621
+ }, {}, {}>;
3622
+ occurredAt: import("drizzle-orm/pg-core").PgColumn<{
3623
+ name: "occurred_at";
3624
+ tableName: "game_event";
3625
+ dataType: "date";
3626
+ columnType: "PgTimestamp";
3627
+ data: Date;
3628
+ driverParam: string;
3629
+ notNull: true;
3630
+ hasDefault: false;
3631
+ isPrimaryKey: false;
3632
+ isAutoincrement: false;
3633
+ hasRuntimeDefault: false;
3634
+ enumValues: undefined;
3635
+ baseColumn: never;
3636
+ identity: undefined;
3637
+ generated: undefined;
3638
+ }, {}, {}>;
3639
+ recordedAt: import("drizzle-orm/pg-core").PgColumn<{
3640
+ name: "recorded_at";
3641
+ tableName: "game_event";
3642
+ dataType: "date";
3643
+ columnType: "PgTimestamp";
3644
+ data: Date;
3645
+ driverParam: string;
3646
+ notNull: true;
3647
+ hasDefault: true;
3648
+ isPrimaryKey: false;
3649
+ isAutoincrement: false;
3650
+ hasRuntimeDefault: false;
3651
+ enumValues: undefined;
3652
+ baseColumn: never;
3653
+ identity: undefined;
3654
+ generated: undefined;
3655
+ }, {}, {}>;
3656
+ serverId: import("drizzle-orm/pg-core").PgColumn<{
3657
+ name: "server_id";
3658
+ tableName: "game_event";
3659
+ dataType: "string";
3660
+ columnType: "PgText";
3661
+ data: string;
3662
+ driverParam: string;
3663
+ notNull: true;
3664
+ hasDefault: false;
3665
+ isPrimaryKey: false;
3666
+ isAutoincrement: false;
3667
+ hasRuntimeDefault: false;
3668
+ enumValues: [string, ...string[]];
3669
+ baseColumn: never;
3670
+ identity: undefined;
3671
+ generated: undefined;
3672
+ }, {}, {}>;
3673
+ sessionId: import("drizzle-orm/pg-core").PgColumn<{
3674
+ name: "session_id";
3675
+ tableName: "game_event";
3676
+ dataType: "string";
3677
+ columnType: "PgText";
3678
+ data: string;
3679
+ driverParam: string;
3680
+ notNull: false;
3681
+ hasDefault: false;
3682
+ isPrimaryKey: false;
3683
+ isAutoincrement: false;
3684
+ hasRuntimeDefault: false;
3685
+ enumValues: [string, ...string[]];
3686
+ baseColumn: never;
3687
+ identity: undefined;
3688
+ generated: undefined;
3689
+ }, {}, {}>;
3690
+ roomId: import("drizzle-orm/pg-core").PgColumn<{
3691
+ name: "room_id";
3692
+ tableName: "game_event";
3693
+ dataType: "string";
3694
+ columnType: "PgText";
3695
+ data: string;
3696
+ driverParam: string;
3697
+ notNull: false;
3698
+ hasDefault: false;
3699
+ isPrimaryKey: false;
3700
+ isAutoincrement: false;
3701
+ hasRuntimeDefault: false;
3702
+ enumValues: [string, ...string[]];
3703
+ baseColumn: never;
3704
+ identity: undefined;
3705
+ generated: undefined;
3706
+ }, {}, {}>;
3707
+ roomSlug: import("drizzle-orm/pg-core").PgColumn<{
3708
+ name: "room_slug";
3709
+ tableName: "game_event";
3710
+ dataType: "string";
3711
+ columnType: "PgText";
3712
+ data: string;
3713
+ driverParam: string;
3714
+ notNull: false;
3715
+ hasDefault: false;
3716
+ isPrimaryKey: false;
3717
+ isAutoincrement: false;
3718
+ hasRuntimeDefault: false;
3719
+ enumValues: [string, ...string[]];
3720
+ baseColumn: never;
3721
+ identity: undefined;
3722
+ generated: undefined;
3723
+ }, {}, {}>;
3724
+ userId: import("drizzle-orm/pg-core").PgColumn<{
3725
+ name: "user_id";
3726
+ tableName: "game_event";
3727
+ dataType: "string";
3728
+ columnType: "PgText";
3729
+ data: string;
3730
+ driverParam: string;
3731
+ notNull: false;
3732
+ hasDefault: false;
3733
+ isPrimaryKey: false;
3734
+ isAutoincrement: false;
3735
+ hasRuntimeDefault: false;
3736
+ enumValues: [string, ...string[]];
3737
+ baseColumn: never;
3738
+ identity: undefined;
3739
+ generated: undefined;
3740
+ }, {}, {}>;
3741
+ reason: import("drizzle-orm/pg-core").PgColumn<{
3742
+ name: "reason";
3743
+ tableName: "game_event";
3744
+ dataType: "string";
3745
+ columnType: "PgText";
3746
+ data: string;
3747
+ driverParam: string;
3748
+ notNull: false;
3749
+ hasDefault: false;
3750
+ isPrimaryKey: false;
3751
+ isAutoincrement: false;
3752
+ hasRuntimeDefault: false;
3753
+ enumValues: [string, ...string[]];
3754
+ baseColumn: never;
3755
+ identity: undefined;
3756
+ generated: undefined;
3757
+ }, {}, {}>;
3758
+ detail: import("drizzle-orm/pg-core").PgColumn<{
3759
+ name: "detail";
3760
+ tableName: "game_event";
3761
+ dataType: "json";
3762
+ columnType: "PgJsonb";
3763
+ data: RawRecord;
3764
+ driverParam: unknown;
3765
+ notNull: false;
3766
+ hasDefault: false;
3767
+ isPrimaryKey: false;
3768
+ isAutoincrement: false;
3769
+ hasRuntimeDefault: false;
3770
+ enumValues: undefined;
3771
+ baseColumn: never;
3772
+ identity: undefined;
3773
+ generated: undefined;
3774
+ }, {}, {
3775
+ $type: RawRecord;
3776
+ }>;
3777
+ };
3778
+ dialect: "pg";
3779
+ }>;
3780
+ export declare const gameEventFeedClock: import("drizzle-orm/pg-core").PgTableWithColumns<{
3781
+ name: "game_event_feed_clock";
3782
+ schema: undefined;
3783
+ columns: {
3784
+ id: import("drizzle-orm/pg-core").PgColumn<{
3785
+ name: "id";
3786
+ tableName: "game_event_feed_clock";
3787
+ dataType: "string";
3788
+ columnType: "PgText";
3789
+ data: string;
3790
+ driverParam: string;
3791
+ notNull: true;
3792
+ hasDefault: false;
3793
+ isPrimaryKey: true;
3794
+ isAutoincrement: false;
3795
+ hasRuntimeDefault: false;
3796
+ enumValues: [string, ...string[]];
3797
+ baseColumn: never;
3798
+ identity: undefined;
3799
+ generated: undefined;
3800
+ }, {}, {}>;
3801
+ recordedAt: import("drizzle-orm/pg-core").PgColumn<{
3802
+ name: "recorded_at";
3803
+ tableName: "game_event_feed_clock";
3804
+ dataType: "date";
3805
+ columnType: "PgTimestamp";
3806
+ data: Date;
3807
+ driverParam: string;
3808
+ notNull: true;
3809
+ hasDefault: false;
3810
+ isPrimaryKey: false;
3811
+ isAutoincrement: false;
3812
+ hasRuntimeDefault: false;
3813
+ enumValues: undefined;
3814
+ baseColumn: never;
3815
+ identity: undefined;
3816
+ generated: undefined;
3817
+ }, {}, {}>;
3818
+ };
3819
+ dialect: "pg";
3820
+ }>;
3821
+ export declare const gameEventFeedTail: import("drizzle-orm/pg-core").PgTableWithColumns<{
3822
+ name: "game_event_feed_tail";
3823
+ schema: undefined;
3824
+ columns: {
3825
+ id: import("drizzle-orm/pg-core").PgColumn<{
3826
+ name: "id";
3827
+ tableName: "game_event_feed_tail";
3828
+ dataType: "string";
3829
+ columnType: "PgText";
3830
+ data: string;
3831
+ driverParam: string;
3832
+ notNull: true;
3833
+ hasDefault: false;
3834
+ isPrimaryKey: true;
3835
+ isAutoincrement: false;
3836
+ hasRuntimeDefault: false;
3837
+ enumValues: [string, ...string[]];
3838
+ baseColumn: never;
3839
+ identity: undefined;
3840
+ generated: undefined;
3841
+ }, {}, {}>;
3842
+ recordedAt: import("drizzle-orm/pg-core").PgColumn<{
3843
+ name: "recorded_at";
3844
+ tableName: "game_event_feed_tail";
3845
+ dataType: "date";
3846
+ columnType: "PgTimestamp";
3847
+ data: Date;
3848
+ driverParam: string;
3849
+ notNull: true;
3850
+ hasDefault: false;
3851
+ isPrimaryKey: false;
3852
+ isAutoincrement: false;
3853
+ hasRuntimeDefault: false;
3854
+ enumValues: undefined;
3855
+ baseColumn: never;
3856
+ identity: undefined;
3857
+ generated: undefined;
3858
+ }, {}, {}>;
3859
+ eventId: import("drizzle-orm/pg-core").PgColumn<{
3860
+ name: "event_id";
3861
+ tableName: "game_event_feed_tail";
3862
+ dataType: "string";
3863
+ columnType: "PgText";
3864
+ data: string;
3865
+ driverParam: string;
3866
+ notNull: true;
3867
+ hasDefault: false;
3868
+ isPrimaryKey: false;
3869
+ isAutoincrement: false;
3870
+ hasRuntimeDefault: false;
3871
+ enumValues: [string, ...string[]];
3872
+ baseColumn: never;
3873
+ identity: undefined;
3874
+ generated: undefined;
3875
+ }, {}, {}>;
3876
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
3877
+ name: "created_at";
3878
+ tableName: "game_event_feed_tail";
3879
+ dataType: "date";
3880
+ columnType: "PgTimestamp";
3881
+ data: Date;
3882
+ driverParam: string;
3883
+ notNull: true;
3884
+ hasDefault: true;
3885
+ isPrimaryKey: false;
3886
+ isAutoincrement: false;
3887
+ hasRuntimeDefault: false;
3888
+ enumValues: undefined;
3889
+ baseColumn: never;
3890
+ identity: undefined;
3891
+ generated: undefined;
3892
+ }, {}, {}>;
3893
+ acknowledgedAt: import("drizzle-orm/pg-core").PgColumn<{
3894
+ name: "acknowledged_at";
3895
+ tableName: "game_event_feed_tail";
3896
+ dataType: "date";
3897
+ columnType: "PgTimestamp";
3898
+ data: Date;
3899
+ driverParam: string;
3900
+ notNull: false;
3901
+ hasDefault: false;
3902
+ isPrimaryKey: false;
3903
+ isAutoincrement: false;
3904
+ hasRuntimeDefault: false;
3905
+ enumValues: undefined;
3906
+ baseColumn: never;
3907
+ identity: undefined;
3908
+ generated: undefined;
3909
+ }, {}, {}>;
3910
+ };
3911
+ dialect: "pg";
3912
+ }>;
3913
+ export declare const securityEvent: import("drizzle-orm/pg-core").PgTableWithColumns<{
3914
+ name: "security_event";
3915
+ schema: undefined;
3916
+ columns: {
3917
+ id: import("drizzle-orm/pg-core").PgColumn<{
3918
+ name: "id";
3919
+ tableName: "security_event";
3920
+ dataType: "string";
3921
+ columnType: "PgText";
3922
+ data: string;
3923
+ driverParam: string;
3924
+ notNull: true;
3925
+ hasDefault: false;
3926
+ isPrimaryKey: true;
3927
+ isAutoincrement: false;
3928
+ hasRuntimeDefault: false;
3929
+ enumValues: [string, ...string[]];
3930
+ baseColumn: never;
3931
+ identity: undefined;
3932
+ generated: undefined;
3933
+ }, {}, {}>;
3934
+ userId: import("drizzle-orm/pg-core").PgColumn<{
3935
+ name: "user_id";
3936
+ tableName: "security_event";
3937
+ dataType: "string";
3938
+ columnType: "PgText";
3939
+ data: string;
3940
+ driverParam: string;
3941
+ notNull: true;
3942
+ hasDefault: false;
3943
+ isPrimaryKey: false;
3944
+ isAutoincrement: false;
3945
+ hasRuntimeDefault: false;
3946
+ enumValues: [string, ...string[]];
3947
+ baseColumn: never;
3948
+ identity: undefined;
3949
+ generated: undefined;
3950
+ }, {}, {}>;
3951
+ event: import("drizzle-orm/pg-core").PgColumn<{
3952
+ name: "event";
3953
+ tableName: "security_event";
3954
+ dataType: "string";
3955
+ columnType: "PgText";
3956
+ data: string;
3957
+ driverParam: string;
3958
+ notNull: true;
3959
+ hasDefault: false;
3960
+ isPrimaryKey: false;
3961
+ isAutoincrement: false;
3962
+ hasRuntimeDefault: false;
3963
+ enumValues: [string, ...string[]];
3964
+ baseColumn: never;
3965
+ identity: undefined;
3966
+ generated: undefined;
3967
+ }, {}, {}>;
3968
+ audience: import("drizzle-orm/pg-core").PgColumn<{
3969
+ name: "audience";
3970
+ tableName: "security_event";
3971
+ dataType: "string";
3972
+ columnType: "PgText";
3973
+ data: string;
3974
+ driverParam: string;
3975
+ notNull: false;
3976
+ hasDefault: false;
3977
+ isPrimaryKey: false;
3978
+ isAutoincrement: false;
3979
+ hasRuntimeDefault: false;
3980
+ enumValues: [string, ...string[]];
3981
+ baseColumn: never;
3982
+ identity: undefined;
3983
+ generated: undefined;
3984
+ }, {}, {}>;
3985
+ ip: import("drizzle-orm/pg-core").PgColumn<{
3986
+ name: "ip";
3987
+ tableName: "security_event";
3988
+ dataType: "string";
3989
+ columnType: "PgText";
3990
+ data: string;
3991
+ driverParam: string;
3992
+ notNull: false;
3993
+ hasDefault: false;
3994
+ isPrimaryKey: false;
3995
+ isAutoincrement: false;
3996
+ hasRuntimeDefault: false;
3997
+ enumValues: [string, ...string[]];
3998
+ baseColumn: never;
3999
+ identity: undefined;
4000
+ generated: undefined;
4001
+ }, {}, {}>;
4002
+ country: import("drizzle-orm/pg-core").PgColumn<{
4003
+ name: "country";
4004
+ tableName: "security_event";
4005
+ dataType: "string";
4006
+ columnType: "PgText";
4007
+ data: string;
4008
+ driverParam: string;
4009
+ notNull: false;
4010
+ hasDefault: false;
4011
+ isPrimaryKey: false;
4012
+ isAutoincrement: false;
4013
+ hasRuntimeDefault: false;
4014
+ enumValues: [string, ...string[]];
4015
+ baseColumn: never;
4016
+ identity: undefined;
4017
+ generated: undefined;
4018
+ }, {}, {}>;
4019
+ userAgent: import("drizzle-orm/pg-core").PgColumn<{
4020
+ name: "user_agent";
4021
+ tableName: "security_event";
4022
+ dataType: "string";
4023
+ columnType: "PgText";
4024
+ data: string;
4025
+ driverParam: string;
4026
+ notNull: false;
4027
+ hasDefault: false;
4028
+ isPrimaryKey: false;
4029
+ isAutoincrement: false;
4030
+ hasRuntimeDefault: false;
4031
+ enumValues: [string, ...string[]];
4032
+ baseColumn: never;
4033
+ identity: undefined;
4034
+ generated: undefined;
4035
+ }, {}, {}>;
4036
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
4037
+ name: "created_at";
4038
+ tableName: "security_event";
4039
+ dataType: "date";
4040
+ columnType: "PgTimestamp";
4041
+ data: Date;
4042
+ driverParam: string;
4043
+ notNull: true;
4044
+ hasDefault: true;
4045
+ isPrimaryKey: false;
4046
+ isAutoincrement: false;
4047
+ hasRuntimeDefault: false;
4048
+ enumValues: undefined;
4049
+ baseColumn: never;
4050
+ identity: undefined;
4051
+ generated: undefined;
4052
+ }, {}, {}>;
4053
+ };
4054
+ dialect: "pg";
4055
+ }>;
4056
+ export declare const accountErasure: import("drizzle-orm/pg-core").PgTableWithColumns<{
4057
+ name: "account_erasure";
4058
+ schema: undefined;
4059
+ columns: {
4060
+ seq: import("drizzle-orm/pg-core").PgColumn<{
4061
+ name: "seq";
4062
+ tableName: "account_erasure";
4063
+ dataType: "number";
4064
+ columnType: "PgBigSerial53";
4065
+ data: number;
4066
+ driverParam: number;
4067
+ notNull: true;
4068
+ hasDefault: true;
4069
+ isPrimaryKey: true;
4070
+ isAutoincrement: false;
4071
+ hasRuntimeDefault: false;
4072
+ enumValues: undefined;
4073
+ baseColumn: never;
4074
+ identity: undefined;
4075
+ generated: undefined;
4076
+ }, {}, {}>;
4077
+ userId: import("drizzle-orm/pg-core").PgColumn<{
4078
+ name: "user_id";
4079
+ tableName: "account_erasure";
4080
+ dataType: "string";
4081
+ columnType: "PgText";
4082
+ data: string;
4083
+ driverParam: string;
4084
+ notNull: true;
4085
+ hasDefault: false;
4086
+ isPrimaryKey: false;
4087
+ isAutoincrement: false;
4088
+ hasRuntimeDefault: false;
4089
+ enumValues: [string, ...string[]];
4090
+ baseColumn: never;
4091
+ identity: undefined;
4092
+ generated: undefined;
4093
+ }, {}, {}>;
4094
+ deletedRoomIds: import("drizzle-orm/pg-core").PgColumn<{
4095
+ name: "deleted_room_ids";
4096
+ tableName: "account_erasure";
4097
+ dataType: "json";
4098
+ columnType: "PgJsonb";
4099
+ data: string[];
4100
+ driverParam: unknown;
4101
+ notNull: true;
4102
+ hasDefault: true;
4103
+ isPrimaryKey: false;
4104
+ isAutoincrement: false;
4105
+ hasRuntimeDefault: false;
4106
+ enumValues: undefined;
4107
+ baseColumn: never;
4108
+ identity: undefined;
4109
+ generated: undefined;
4110
+ }, {}, {
4111
+ $type: string[];
4112
+ }>;
4113
+ avatarUrl: import("drizzle-orm/pg-core").PgColumn<{
4114
+ name: "avatar_url";
4115
+ tableName: "account_erasure";
4116
+ dataType: "string";
4117
+ columnType: "PgText";
4118
+ data: string;
4119
+ driverParam: string;
4120
+ notNull: false;
4121
+ hasDefault: false;
4122
+ isPrimaryKey: false;
4123
+ isAutoincrement: false;
4124
+ hasRuntimeDefault: false;
4125
+ enumValues: [string, ...string[]];
4126
+ baseColumn: never;
4127
+ identity: undefined;
4128
+ generated: undefined;
4129
+ }, {}, {}>;
4130
+ talkAcknowledgedAt: import("drizzle-orm/pg-core").PgColumn<{
4131
+ name: "talk_acknowledged_at";
4132
+ tableName: "account_erasure";
4133
+ dataType: "date";
4134
+ columnType: "PgTimestamp";
4135
+ data: Date;
4136
+ driverParam: string;
4137
+ notNull: false;
4138
+ hasDefault: false;
4139
+ isPrimaryKey: false;
4140
+ isAutoincrement: false;
4141
+ hasRuntimeDefault: false;
4142
+ enumValues: undefined;
4143
+ baseColumn: never;
4144
+ identity: undefined;
4145
+ generated: undefined;
4146
+ }, {}, {}>;
4147
+ erasedAt: import("drizzle-orm/pg-core").PgColumn<{
4148
+ name: "erased_at";
4149
+ tableName: "account_erasure";
4150
+ dataType: "date";
4151
+ columnType: "PgTimestamp";
4152
+ data: Date;
4153
+ driverParam: string;
4154
+ notNull: true;
4155
+ hasDefault: true;
4156
+ isPrimaryKey: false;
4157
+ isAutoincrement: false;
4158
+ hasRuntimeDefault: false;
4159
+ enumValues: undefined;
4160
+ baseColumn: never;
4161
+ identity: undefined;
4162
+ generated: undefined;
4163
+ }, {}, {}>;
4164
+ };
4165
+ dialect: "pg";
4166
+ }>;
4167
+ export declare const jwks: import("drizzle-orm/pg-core").PgTableWithColumns<{
4168
+ name: "jwks";
4169
+ schema: undefined;
4170
+ columns: {
4171
+ id: import("drizzle-orm/pg-core").PgColumn<{
4172
+ name: "id";
4173
+ tableName: "jwks";
4174
+ dataType: "string";
4175
+ columnType: "PgText";
4176
+ data: string;
4177
+ driverParam: string;
4178
+ notNull: true;
4179
+ hasDefault: false;
4180
+ isPrimaryKey: true;
4181
+ isAutoincrement: false;
4182
+ hasRuntimeDefault: false;
4183
+ enumValues: [string, ...string[]];
4184
+ baseColumn: never;
4185
+ identity: undefined;
4186
+ generated: undefined;
4187
+ }, {}, {}>;
4188
+ publicKey: import("drizzle-orm/pg-core").PgColumn<{
4189
+ name: "public_key";
4190
+ tableName: "jwks";
4191
+ dataType: "string";
4192
+ columnType: "PgText";
4193
+ data: string;
4194
+ driverParam: string;
4195
+ notNull: true;
4196
+ hasDefault: false;
4197
+ isPrimaryKey: false;
4198
+ isAutoincrement: false;
4199
+ hasRuntimeDefault: false;
4200
+ enumValues: [string, ...string[]];
4201
+ baseColumn: never;
4202
+ identity: undefined;
4203
+ generated: undefined;
4204
+ }, {}, {}>;
4205
+ privateKey: import("drizzle-orm/pg-core").PgColumn<{
4206
+ name: "private_key";
4207
+ tableName: "jwks";
4208
+ dataType: "string";
4209
+ columnType: "PgText";
4210
+ data: string;
4211
+ driverParam: string;
4212
+ notNull: true;
4213
+ hasDefault: false;
4214
+ isPrimaryKey: false;
4215
+ isAutoincrement: false;
4216
+ hasRuntimeDefault: false;
4217
+ enumValues: [string, ...string[]];
4218
+ baseColumn: never;
4219
+ identity: undefined;
4220
+ generated: undefined;
4221
+ }, {}, {}>;
4222
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
4223
+ name: "created_at";
4224
+ tableName: "jwks";
4225
+ dataType: "date";
4226
+ columnType: "PgTimestamp";
4227
+ data: Date;
4228
+ driverParam: string;
4229
+ notNull: true;
4230
+ hasDefault: true;
4231
+ isPrimaryKey: false;
4232
+ isAutoincrement: false;
4233
+ hasRuntimeDefault: false;
4234
+ enumValues: undefined;
4235
+ baseColumn: never;
4236
+ identity: undefined;
4237
+ generated: undefined;
4238
+ }, {}, {}>;
4239
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
4240
+ name: "expires_at";
4241
+ tableName: "jwks";
4242
+ dataType: "date";
4243
+ columnType: "PgTimestamp";
4244
+ data: Date;
4245
+ driverParam: string;
4246
+ notNull: false;
4247
+ hasDefault: false;
4248
+ isPrimaryKey: false;
4249
+ isAutoincrement: false;
4250
+ hasRuntimeDefault: false;
4251
+ enumValues: undefined;
4252
+ baseColumn: never;
4253
+ identity: undefined;
4254
+ generated: undefined;
4255
+ }, {}, {}>;
4256
+ };
4257
+ dialect: "pg";
4258
+ }>;
4259
+ export declare const rateLimit: import("drizzle-orm/pg-core").PgTableWithColumns<{
4260
+ name: "rate_limit";
4261
+ schema: undefined;
4262
+ columns: {
4263
+ id: import("drizzle-orm/pg-core").PgColumn<{
4264
+ name: "id";
4265
+ tableName: "rate_limit";
4266
+ dataType: "string";
4267
+ columnType: "PgText";
4268
+ data: string;
4269
+ driverParam: string;
4270
+ notNull: true;
4271
+ hasDefault: false;
4272
+ isPrimaryKey: true;
4273
+ isAutoincrement: false;
4274
+ hasRuntimeDefault: false;
4275
+ enumValues: [string, ...string[]];
4276
+ baseColumn: never;
4277
+ identity: undefined;
4278
+ generated: undefined;
4279
+ }, {}, {}>;
4280
+ key: import("drizzle-orm/pg-core").PgColumn<{
4281
+ name: "key";
4282
+ tableName: "rate_limit";
4283
+ dataType: "string";
4284
+ columnType: "PgText";
4285
+ data: string;
4286
+ driverParam: string;
4287
+ notNull: true;
4288
+ hasDefault: false;
4289
+ isPrimaryKey: false;
4290
+ isAutoincrement: false;
4291
+ hasRuntimeDefault: false;
4292
+ enumValues: [string, ...string[]];
4293
+ baseColumn: never;
4294
+ identity: undefined;
4295
+ generated: undefined;
4296
+ }, {}, {}>;
4297
+ count: import("drizzle-orm/pg-core").PgColumn<{
4298
+ name: "count";
4299
+ tableName: "rate_limit";
4300
+ dataType: "number";
4301
+ columnType: "PgInteger";
4302
+ data: number;
4303
+ driverParam: string | number;
4304
+ notNull: true;
4305
+ hasDefault: true;
4306
+ isPrimaryKey: false;
4307
+ isAutoincrement: false;
4308
+ hasRuntimeDefault: false;
4309
+ enumValues: undefined;
4310
+ baseColumn: never;
4311
+ identity: undefined;
4312
+ generated: undefined;
4313
+ }, {}, {}>;
4314
+ lastRequest: import("drizzle-orm/pg-core").PgColumn<{
4315
+ name: "last_request";
4316
+ tableName: "rate_limit";
4317
+ dataType: "number";
4318
+ columnType: "PgBigInt53";
4319
+ data: number;
4320
+ driverParam: string | number;
4321
+ notNull: true;
4322
+ hasDefault: true;
4323
+ isPrimaryKey: false;
4324
+ isAutoincrement: false;
4325
+ hasRuntimeDefault: false;
4326
+ enumValues: undefined;
4327
+ baseColumn: never;
4328
+ identity: undefined;
4329
+ generated: undefined;
4330
+ }, {}, {}>;
4331
+ };
4332
+ dialect: "pg";
4333
+ }>;
4334
+ export declare const studySubject: import("drizzle-orm/pg-core").PgTableWithColumns<{
4335
+ name: "study_subject";
4336
+ schema: undefined;
4337
+ columns: {
4338
+ id: import("drizzle-orm/pg-core").PgColumn<{
4339
+ name: "id";
4340
+ tableName: "study_subject";
4341
+ dataType: "string";
4342
+ columnType: "PgText";
4343
+ data: string;
4344
+ driverParam: string;
4345
+ notNull: true;
4346
+ hasDefault: false;
4347
+ isPrimaryKey: true;
4348
+ isAutoincrement: false;
4349
+ hasRuntimeDefault: false;
4350
+ enumValues: [string, ...string[]];
4351
+ baseColumn: never;
4352
+ identity: undefined;
4353
+ generated: undefined;
4354
+ }, {}, {}>;
4355
+ userId: import("drizzle-orm/pg-core").PgColumn<{
4356
+ name: "user_id";
4357
+ tableName: "study_subject";
4358
+ dataType: "string";
4359
+ columnType: "PgText";
4360
+ data: string;
4361
+ driverParam: string;
4362
+ notNull: true;
4363
+ hasDefault: false;
4364
+ isPrimaryKey: false;
4365
+ isAutoincrement: false;
4366
+ hasRuntimeDefault: false;
4367
+ enumValues: [string, ...string[]];
4368
+ baseColumn: never;
4369
+ identity: undefined;
4370
+ generated: undefined;
4371
+ }, {}, {}>;
4372
+ field: import("drizzle-orm/pg-core").PgColumn<{
4373
+ name: "field";
4374
+ tableName: "study_subject";
4375
+ dataType: "string";
4376
+ columnType: "PgText";
4377
+ data: string;
4378
+ driverParam: string;
4379
+ notNull: false;
4380
+ hasDefault: false;
4381
+ isPrimaryKey: false;
4382
+ isAutoincrement: false;
4383
+ hasRuntimeDefault: false;
4384
+ enumValues: [string, ...string[]];
4385
+ baseColumn: never;
4386
+ identity: undefined;
4387
+ generated: undefined;
4388
+ }, {}, {}>;
4389
+ name: import("drizzle-orm/pg-core").PgColumn<{
4390
+ name: "name";
4391
+ tableName: "study_subject";
4392
+ dataType: "string";
4393
+ columnType: "PgText";
4394
+ data: string;
4395
+ driverParam: string;
4396
+ notNull: true;
4397
+ hasDefault: false;
4398
+ isPrimaryKey: false;
4399
+ isAutoincrement: false;
4400
+ hasRuntimeDefault: false;
4401
+ enumValues: [string, ...string[]];
4402
+ baseColumn: never;
4403
+ identity: undefined;
4404
+ generated: undefined;
4405
+ }, {}, {}>;
4406
+ archivedAt: import("drizzle-orm/pg-core").PgColumn<{
4407
+ name: "archived_at";
4408
+ tableName: "study_subject";
4409
+ dataType: "date";
4410
+ columnType: "PgTimestamp";
4411
+ data: Date;
4412
+ driverParam: string;
4413
+ notNull: false;
4414
+ hasDefault: false;
4415
+ isPrimaryKey: false;
4416
+ isAutoincrement: false;
4417
+ hasRuntimeDefault: false;
4418
+ enumValues: undefined;
4419
+ baseColumn: never;
4420
+ identity: undefined;
4421
+ generated: undefined;
4422
+ }, {}, {}>;
4423
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
4424
+ name: "created_at";
4425
+ tableName: "study_subject";
4426
+ dataType: "date";
4427
+ columnType: "PgTimestamp";
4428
+ data: Date;
4429
+ driverParam: string;
4430
+ notNull: true;
4431
+ hasDefault: true;
4432
+ isPrimaryKey: false;
4433
+ isAutoincrement: false;
4434
+ hasRuntimeDefault: false;
4435
+ enumValues: undefined;
4436
+ baseColumn: never;
4437
+ identity: undefined;
4438
+ generated: undefined;
4439
+ }, {}, {}>;
4440
+ lastUsedAt: import("drizzle-orm/pg-core").PgColumn<{
4441
+ name: "last_used_at";
4442
+ tableName: "study_subject";
4443
+ dataType: "date";
4444
+ columnType: "PgTimestamp";
4445
+ data: Date;
4446
+ driverParam: string;
4447
+ notNull: true;
4448
+ hasDefault: true;
4449
+ isPrimaryKey: false;
4450
+ isAutoincrement: false;
4451
+ hasRuntimeDefault: false;
4452
+ enumValues: undefined;
4453
+ baseColumn: never;
4454
+ identity: undefined;
4455
+ generated: undefined;
4456
+ }, {}, {}>;
4457
+ };
4458
+ dialect: "pg";
4459
+ }>;
4460
+ export declare const oauthSession: import("drizzle-orm/pg-core").PgTableWithColumns<{
4461
+ name: "oauth_session";
4462
+ schema: undefined;
4463
+ columns: {
4464
+ providerId: import("drizzle-orm/pg-core").PgColumn<{
4465
+ name: "provider_id";
4466
+ tableName: "oauth_session";
4467
+ dataType: "string";
4468
+ columnType: "PgText";
4469
+ data: string;
4470
+ driverParam: string;
4471
+ notNull: true;
4472
+ hasDefault: false;
4473
+ isPrimaryKey: false;
4474
+ isAutoincrement: false;
4475
+ hasRuntimeDefault: false;
4476
+ enumValues: [string, ...string[]];
4477
+ baseColumn: never;
4478
+ identity: undefined;
4479
+ generated: undefined;
4480
+ }, {}, {}>;
4481
+ accountId: import("drizzle-orm/pg-core").PgColumn<{
4482
+ name: "account_id";
4483
+ tableName: "oauth_session";
4484
+ dataType: "string";
4485
+ columnType: "PgText";
4486
+ data: string;
4487
+ driverParam: string;
4488
+ notNull: true;
4489
+ hasDefault: false;
4490
+ isPrimaryKey: false;
4491
+ isAutoincrement: false;
4492
+ hasRuntimeDefault: false;
4493
+ enumValues: [string, ...string[]];
4494
+ baseColumn: never;
4495
+ identity: undefined;
4496
+ generated: undefined;
4497
+ }, {}, {}>;
4498
+ data: import("drizzle-orm/pg-core").PgColumn<{
4499
+ name: "data";
4500
+ tableName: "oauth_session";
4501
+ dataType: "string";
4502
+ columnType: "PgText";
4503
+ data: string;
4504
+ driverParam: string;
4505
+ notNull: true;
4506
+ hasDefault: false;
4507
+ isPrimaryKey: false;
4508
+ isAutoincrement: false;
4509
+ hasRuntimeDefault: false;
4510
+ enumValues: [string, ...string[]];
4511
+ baseColumn: never;
4512
+ identity: undefined;
4513
+ generated: undefined;
4514
+ }, {}, {}>;
4515
+ formatVersion: import("drizzle-orm/pg-core").PgColumn<{
4516
+ name: "format_version";
4517
+ tableName: "oauth_session";
4518
+ dataType: "number";
4519
+ columnType: "PgInteger";
4520
+ data: number;
4521
+ driverParam: string | number;
4522
+ notNull: true;
4523
+ hasDefault: true;
4524
+ isPrimaryKey: false;
4525
+ isAutoincrement: false;
4526
+ hasRuntimeDefault: false;
4527
+ enumValues: undefined;
4528
+ baseColumn: never;
4529
+ identity: undefined;
4530
+ generated: undefined;
4531
+ }, {}, {}>;
4532
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
4533
+ name: "updated_at";
4534
+ tableName: "oauth_session";
4535
+ dataType: "date";
4536
+ columnType: "PgTimestamp";
4537
+ data: Date;
4538
+ driverParam: string;
4539
+ notNull: true;
4540
+ hasDefault: true;
4541
+ isPrimaryKey: false;
4542
+ isAutoincrement: false;
4543
+ hasRuntimeDefault: false;
4544
+ enumValues: undefined;
4545
+ baseColumn: never;
4546
+ identity: undefined;
4547
+ generated: undefined;
4548
+ }, {}, {}>;
4549
+ };
4550
+ dialect: "pg";
4551
+ }>;
4552
+ export declare const oauthState: import("drizzle-orm/pg-core").PgTableWithColumns<{
4553
+ name: "oauth_state";
4554
+ schema: undefined;
4555
+ columns: {
4556
+ providerId: import("drizzle-orm/pg-core").PgColumn<{
4557
+ name: "provider_id";
4558
+ tableName: "oauth_state";
4559
+ dataType: "string";
4560
+ columnType: "PgText";
4561
+ data: string;
4562
+ driverParam: string;
4563
+ notNull: true;
4564
+ hasDefault: false;
4565
+ isPrimaryKey: false;
4566
+ isAutoincrement: false;
4567
+ hasRuntimeDefault: false;
4568
+ enumValues: [string, ...string[]];
4569
+ baseColumn: never;
4570
+ identity: undefined;
4571
+ generated: undefined;
4572
+ }, {}, {}>;
4573
+ id: import("drizzle-orm/pg-core").PgColumn<{
4574
+ name: "id";
4575
+ tableName: "oauth_state";
4576
+ dataType: "string";
4577
+ columnType: "PgText";
4578
+ data: string;
4579
+ driverParam: string;
4580
+ notNull: true;
4581
+ hasDefault: false;
4582
+ isPrimaryKey: false;
4583
+ isAutoincrement: false;
4584
+ hasRuntimeDefault: false;
4585
+ enumValues: [string, ...string[]];
4586
+ baseColumn: never;
4587
+ identity: undefined;
4588
+ generated: undefined;
4589
+ }, {}, {}>;
4590
+ data: import("drizzle-orm/pg-core").PgColumn<{
4591
+ name: "data";
4592
+ tableName: "oauth_state";
4593
+ dataType: "string";
4594
+ columnType: "PgText";
4595
+ data: string;
4596
+ driverParam: string;
4597
+ notNull: true;
4598
+ hasDefault: false;
4599
+ isPrimaryKey: false;
4600
+ isAutoincrement: false;
4601
+ hasRuntimeDefault: false;
4602
+ enumValues: [string, ...string[]];
4603
+ baseColumn: never;
4604
+ identity: undefined;
4605
+ generated: undefined;
4606
+ }, {}, {}>;
4607
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
4608
+ name: "expires_at";
4609
+ tableName: "oauth_state";
4610
+ dataType: "date";
4611
+ columnType: "PgTimestamp";
4612
+ data: Date;
4613
+ driverParam: string;
4614
+ notNull: true;
4615
+ hasDefault: false;
4616
+ isPrimaryKey: false;
4617
+ isAutoincrement: false;
4618
+ hasRuntimeDefault: false;
4619
+ enumValues: undefined;
4620
+ baseColumn: never;
4621
+ identity: undefined;
4622
+ generated: undefined;
4623
+ }, {}, {}>;
4624
+ };
4625
+ dialect: "pg";
4626
+ }>;