@polaris-auth/client 0.6.1 → 0.8.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,3353 @@
1
+ import type { Client } from "openapi-fetch";
2
+ import type { paths } from "./schema.js";
3
+ import type { Init } from "./namespace.js";
4
+ /** The `passwordless` plugin's routes as methods of `client.passwordless`. */
5
+ export declare function passwordless(client: Client<paths>): {
6
+ /** POST /email-otp/reset-password: Reset the password with an email code */
7
+ emailOtpResetPassword: (init_0: {
8
+ params?: {
9
+ query?: never;
10
+ header?: never;
11
+ path?: never;
12
+ cookie?: never;
13
+ };
14
+ } & {
15
+ body: {
16
+ email: string;
17
+ code: string;
18
+ password: string;
19
+ } & {};
20
+ } & {
21
+ baseUrl?: string;
22
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
23
+ parameters: {
24
+ query?: never;
25
+ header?: never;
26
+ path?: never;
27
+ cookie?: never;
28
+ };
29
+ requestBody: {
30
+ content: {
31
+ "application/json": {
32
+ email: string;
33
+ code: string;
34
+ password: string;
35
+ };
36
+ };
37
+ };
38
+ responses: {
39
+ 200: {
40
+ headers: {
41
+ [name: string]: unknown;
42
+ };
43
+ content: {
44
+ "application/json": {
45
+ data: {
46
+ status: string;
47
+ };
48
+ };
49
+ };
50
+ };
51
+ 422: {
52
+ headers: {
53
+ [name: string]: unknown;
54
+ };
55
+ content: {
56
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
57
+ };
58
+ };
59
+ };
60
+ }>;
61
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
62
+ parameters: {
63
+ query?: never;
64
+ header?: never;
65
+ path?: never;
66
+ cookie?: never;
67
+ };
68
+ requestBody: {
69
+ content: {
70
+ "application/json": {
71
+ email: string;
72
+ code: string;
73
+ password: string;
74
+ };
75
+ };
76
+ };
77
+ responses: {
78
+ 200: {
79
+ headers: {
80
+ [name: string]: unknown;
81
+ };
82
+ content: {
83
+ "application/json": {
84
+ data: {
85
+ status: string;
86
+ };
87
+ };
88
+ };
89
+ };
90
+ 422: {
91
+ headers: {
92
+ [name: string]: unknown;
93
+ };
94
+ content: {
95
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
96
+ };
97
+ };
98
+ };
99
+ }>;
100
+ pathSerializer?: import("openapi-fetch").PathSerializer;
101
+ parseAs?: import("openapi-fetch").ParseAs;
102
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
103
+ headers?: import("openapi-fetch").HeadersOptions;
104
+ middleware?: import("openapi-fetch").Middleware[];
105
+ } & Omit<RequestInit, "body" | "headers"> & {
106
+ [key: string]: unknown;
107
+ }) => Promise<import("openapi-fetch").FetchResponse<{
108
+ parameters: {
109
+ query?: never;
110
+ header?: never;
111
+ path?: never;
112
+ cookie?: never;
113
+ };
114
+ requestBody: {
115
+ content: {
116
+ "application/json": {
117
+ email: string;
118
+ code: string;
119
+ password: string;
120
+ };
121
+ };
122
+ };
123
+ responses: {
124
+ 200: {
125
+ headers: {
126
+ [name: string]: unknown;
127
+ };
128
+ content: {
129
+ "application/json": {
130
+ data: {
131
+ status: string;
132
+ };
133
+ };
134
+ };
135
+ };
136
+ 422: {
137
+ headers: {
138
+ [name: string]: unknown;
139
+ };
140
+ content: {
141
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
142
+ };
143
+ };
144
+ };
145
+ }, {
146
+ params?: {
147
+ query?: never;
148
+ header?: never;
149
+ path?: never;
150
+ cookie?: never;
151
+ };
152
+ } & {
153
+ body: {
154
+ email: string;
155
+ code: string;
156
+ password: string;
157
+ } & {};
158
+ } & {
159
+ baseUrl?: string;
160
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
161
+ parameters: {
162
+ query?: never;
163
+ header?: never;
164
+ path?: never;
165
+ cookie?: never;
166
+ };
167
+ requestBody: {
168
+ content: {
169
+ "application/json": {
170
+ email: string;
171
+ code: string;
172
+ password: string;
173
+ };
174
+ };
175
+ };
176
+ responses: {
177
+ 200: {
178
+ headers: {
179
+ [name: string]: unknown;
180
+ };
181
+ content: {
182
+ "application/json": {
183
+ data: {
184
+ status: string;
185
+ };
186
+ };
187
+ };
188
+ };
189
+ 422: {
190
+ headers: {
191
+ [name: string]: unknown;
192
+ };
193
+ content: {
194
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
195
+ };
196
+ };
197
+ };
198
+ }>;
199
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
200
+ parameters: {
201
+ query?: never;
202
+ header?: never;
203
+ path?: never;
204
+ cookie?: never;
205
+ };
206
+ requestBody: {
207
+ content: {
208
+ "application/json": {
209
+ email: string;
210
+ code: string;
211
+ password: string;
212
+ };
213
+ };
214
+ };
215
+ responses: {
216
+ 200: {
217
+ headers: {
218
+ [name: string]: unknown;
219
+ };
220
+ content: {
221
+ "application/json": {
222
+ data: {
223
+ status: string;
224
+ };
225
+ };
226
+ };
227
+ };
228
+ 422: {
229
+ headers: {
230
+ [name: string]: unknown;
231
+ };
232
+ content: {
233
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
234
+ };
235
+ };
236
+ };
237
+ }>;
238
+ pathSerializer?: import("openapi-fetch").PathSerializer;
239
+ parseAs?: import("openapi-fetch").ParseAs;
240
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
241
+ headers?: import("openapi-fetch").HeadersOptions;
242
+ middleware?: import("openapi-fetch").Middleware[];
243
+ } & Omit<RequestInit, "body" | "headers">, `${string}/${string}`>>;
244
+ /** POST /email-otp/send: Send an email code */
245
+ emailOtpSend: (init_0: {
246
+ params?: {
247
+ query?: never;
248
+ header?: never;
249
+ path?: never;
250
+ cookie?: never;
251
+ };
252
+ } & {
253
+ body: {
254
+ email: string;
255
+ purpose?: "sign-in" | "verify-email" | "reset-password";
256
+ } & {};
257
+ } & {
258
+ baseUrl?: string;
259
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
260
+ parameters: {
261
+ query?: never;
262
+ header?: never;
263
+ path?: never;
264
+ cookie?: never;
265
+ };
266
+ requestBody: {
267
+ content: {
268
+ "application/json": {
269
+ email: string;
270
+ purpose?: "sign-in" | "verify-email" | "reset-password";
271
+ };
272
+ };
273
+ };
274
+ responses: {
275
+ 202: {
276
+ headers: {
277
+ [name: string]: unknown;
278
+ };
279
+ content: {
280
+ "application/json": {
281
+ data: {
282
+ status: string;
283
+ };
284
+ };
285
+ };
286
+ };
287
+ 422: {
288
+ headers: {
289
+ [name: string]: unknown;
290
+ };
291
+ content: {
292
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
293
+ };
294
+ };
295
+ };
296
+ }>;
297
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
298
+ parameters: {
299
+ query?: never;
300
+ header?: never;
301
+ path?: never;
302
+ cookie?: never;
303
+ };
304
+ requestBody: {
305
+ content: {
306
+ "application/json": {
307
+ email: string;
308
+ purpose?: "sign-in" | "verify-email" | "reset-password";
309
+ };
310
+ };
311
+ };
312
+ responses: {
313
+ 202: {
314
+ headers: {
315
+ [name: string]: unknown;
316
+ };
317
+ content: {
318
+ "application/json": {
319
+ data: {
320
+ status: string;
321
+ };
322
+ };
323
+ };
324
+ };
325
+ 422: {
326
+ headers: {
327
+ [name: string]: unknown;
328
+ };
329
+ content: {
330
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
331
+ };
332
+ };
333
+ };
334
+ }>;
335
+ pathSerializer?: import("openapi-fetch").PathSerializer;
336
+ parseAs?: import("openapi-fetch").ParseAs;
337
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
338
+ headers?: import("openapi-fetch").HeadersOptions;
339
+ middleware?: import("openapi-fetch").Middleware[];
340
+ } & Omit<RequestInit, "body" | "headers"> & {
341
+ [key: string]: unknown;
342
+ }) => Promise<import("openapi-fetch").FetchResponse<{
343
+ parameters: {
344
+ query?: never;
345
+ header?: never;
346
+ path?: never;
347
+ cookie?: never;
348
+ };
349
+ requestBody: {
350
+ content: {
351
+ "application/json": {
352
+ email: string;
353
+ purpose?: "sign-in" | "verify-email" | "reset-password";
354
+ };
355
+ };
356
+ };
357
+ responses: {
358
+ 202: {
359
+ headers: {
360
+ [name: string]: unknown;
361
+ };
362
+ content: {
363
+ "application/json": {
364
+ data: {
365
+ status: string;
366
+ };
367
+ };
368
+ };
369
+ };
370
+ 422: {
371
+ headers: {
372
+ [name: string]: unknown;
373
+ };
374
+ content: {
375
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
376
+ };
377
+ };
378
+ };
379
+ }, {
380
+ params?: {
381
+ query?: never;
382
+ header?: never;
383
+ path?: never;
384
+ cookie?: never;
385
+ };
386
+ } & {
387
+ body: {
388
+ email: string;
389
+ purpose?: "sign-in" | "verify-email" | "reset-password";
390
+ } & {};
391
+ } & {
392
+ baseUrl?: string;
393
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
394
+ parameters: {
395
+ query?: never;
396
+ header?: never;
397
+ path?: never;
398
+ cookie?: never;
399
+ };
400
+ requestBody: {
401
+ content: {
402
+ "application/json": {
403
+ email: string;
404
+ purpose?: "sign-in" | "verify-email" | "reset-password";
405
+ };
406
+ };
407
+ };
408
+ responses: {
409
+ 202: {
410
+ headers: {
411
+ [name: string]: unknown;
412
+ };
413
+ content: {
414
+ "application/json": {
415
+ data: {
416
+ status: string;
417
+ };
418
+ };
419
+ };
420
+ };
421
+ 422: {
422
+ headers: {
423
+ [name: string]: unknown;
424
+ };
425
+ content: {
426
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
427
+ };
428
+ };
429
+ };
430
+ }>;
431
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
432
+ parameters: {
433
+ query?: never;
434
+ header?: never;
435
+ path?: never;
436
+ cookie?: never;
437
+ };
438
+ requestBody: {
439
+ content: {
440
+ "application/json": {
441
+ email: string;
442
+ purpose?: "sign-in" | "verify-email" | "reset-password";
443
+ };
444
+ };
445
+ };
446
+ responses: {
447
+ 202: {
448
+ headers: {
449
+ [name: string]: unknown;
450
+ };
451
+ content: {
452
+ "application/json": {
453
+ data: {
454
+ status: string;
455
+ };
456
+ };
457
+ };
458
+ };
459
+ 422: {
460
+ headers: {
461
+ [name: string]: unknown;
462
+ };
463
+ content: {
464
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
465
+ };
466
+ };
467
+ };
468
+ }>;
469
+ pathSerializer?: import("openapi-fetch").PathSerializer;
470
+ parseAs?: import("openapi-fetch").ParseAs;
471
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
472
+ headers?: import("openapi-fetch").HeadersOptions;
473
+ middleware?: import("openapi-fetch").Middleware[];
474
+ } & Omit<RequestInit, "body" | "headers">, `${string}/${string}`>>;
475
+ /** POST /email-otp/verify: Sign in with an email code */
476
+ emailOtpVerify: (init_0: {
477
+ params?: {
478
+ query?: never;
479
+ header?: never;
480
+ path?: never;
481
+ cookie?: never;
482
+ };
483
+ } & {
484
+ body: {
485
+ email: string;
486
+ code: string;
487
+ } & {};
488
+ } & {
489
+ baseUrl?: string;
490
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
491
+ parameters: {
492
+ query?: never;
493
+ header?: never;
494
+ path?: never;
495
+ cookie?: never;
496
+ };
497
+ requestBody: {
498
+ content: {
499
+ "application/json": {
500
+ email: string;
501
+ code: string;
502
+ };
503
+ };
504
+ };
505
+ responses: {
506
+ 200: {
507
+ headers: {
508
+ [name: string]: unknown;
509
+ };
510
+ content: {
511
+ "application/json": {
512
+ data: {
513
+ access_token: string;
514
+ token_type: string;
515
+ expires_in: number;
516
+ refresh_token: string;
517
+ user: {
518
+ id: string;
519
+ email: string;
520
+ email_verified: boolean;
521
+ };
522
+ };
523
+ };
524
+ };
525
+ };
526
+ 403: {
527
+ headers: {
528
+ [name: string]: unknown;
529
+ };
530
+ content: {
531
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
532
+ };
533
+ };
534
+ 422: {
535
+ headers: {
536
+ [name: string]: unknown;
537
+ };
538
+ content: {
539
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
540
+ };
541
+ };
542
+ };
543
+ }>;
544
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
545
+ parameters: {
546
+ query?: never;
547
+ header?: never;
548
+ path?: never;
549
+ cookie?: never;
550
+ };
551
+ requestBody: {
552
+ content: {
553
+ "application/json": {
554
+ email: string;
555
+ code: string;
556
+ };
557
+ };
558
+ };
559
+ responses: {
560
+ 200: {
561
+ headers: {
562
+ [name: string]: unknown;
563
+ };
564
+ content: {
565
+ "application/json": {
566
+ data: {
567
+ access_token: string;
568
+ token_type: string;
569
+ expires_in: number;
570
+ refresh_token: string;
571
+ user: {
572
+ id: string;
573
+ email: string;
574
+ email_verified: boolean;
575
+ };
576
+ };
577
+ };
578
+ };
579
+ };
580
+ 403: {
581
+ headers: {
582
+ [name: string]: unknown;
583
+ };
584
+ content: {
585
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
586
+ };
587
+ };
588
+ 422: {
589
+ headers: {
590
+ [name: string]: unknown;
591
+ };
592
+ content: {
593
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
594
+ };
595
+ };
596
+ };
597
+ }>;
598
+ pathSerializer?: import("openapi-fetch").PathSerializer;
599
+ parseAs?: import("openapi-fetch").ParseAs;
600
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
601
+ headers?: import("openapi-fetch").HeadersOptions;
602
+ middleware?: import("openapi-fetch").Middleware[];
603
+ } & Omit<RequestInit, "body" | "headers"> & {
604
+ [key: string]: unknown;
605
+ }) => Promise<import("openapi-fetch").FetchResponse<{
606
+ parameters: {
607
+ query?: never;
608
+ header?: never;
609
+ path?: never;
610
+ cookie?: never;
611
+ };
612
+ requestBody: {
613
+ content: {
614
+ "application/json": {
615
+ email: string;
616
+ code: string;
617
+ };
618
+ };
619
+ };
620
+ responses: {
621
+ 200: {
622
+ headers: {
623
+ [name: string]: unknown;
624
+ };
625
+ content: {
626
+ "application/json": {
627
+ data: {
628
+ access_token: string;
629
+ token_type: string;
630
+ expires_in: number;
631
+ refresh_token: string;
632
+ user: {
633
+ id: string;
634
+ email: string;
635
+ email_verified: boolean;
636
+ };
637
+ };
638
+ };
639
+ };
640
+ };
641
+ 403: {
642
+ headers: {
643
+ [name: string]: unknown;
644
+ };
645
+ content: {
646
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
647
+ };
648
+ };
649
+ 422: {
650
+ headers: {
651
+ [name: string]: unknown;
652
+ };
653
+ content: {
654
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
655
+ };
656
+ };
657
+ };
658
+ }, {
659
+ params?: {
660
+ query?: never;
661
+ header?: never;
662
+ path?: never;
663
+ cookie?: never;
664
+ };
665
+ } & {
666
+ body: {
667
+ email: string;
668
+ code: string;
669
+ } & {};
670
+ } & {
671
+ baseUrl?: string;
672
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
673
+ parameters: {
674
+ query?: never;
675
+ header?: never;
676
+ path?: never;
677
+ cookie?: never;
678
+ };
679
+ requestBody: {
680
+ content: {
681
+ "application/json": {
682
+ email: string;
683
+ code: string;
684
+ };
685
+ };
686
+ };
687
+ responses: {
688
+ 200: {
689
+ headers: {
690
+ [name: string]: unknown;
691
+ };
692
+ content: {
693
+ "application/json": {
694
+ data: {
695
+ access_token: string;
696
+ token_type: string;
697
+ expires_in: number;
698
+ refresh_token: string;
699
+ user: {
700
+ id: string;
701
+ email: string;
702
+ email_verified: boolean;
703
+ };
704
+ };
705
+ };
706
+ };
707
+ };
708
+ 403: {
709
+ headers: {
710
+ [name: string]: unknown;
711
+ };
712
+ content: {
713
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
714
+ };
715
+ };
716
+ 422: {
717
+ headers: {
718
+ [name: string]: unknown;
719
+ };
720
+ content: {
721
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
722
+ };
723
+ };
724
+ };
725
+ }>;
726
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
727
+ parameters: {
728
+ query?: never;
729
+ header?: never;
730
+ path?: never;
731
+ cookie?: never;
732
+ };
733
+ requestBody: {
734
+ content: {
735
+ "application/json": {
736
+ email: string;
737
+ code: string;
738
+ };
739
+ };
740
+ };
741
+ responses: {
742
+ 200: {
743
+ headers: {
744
+ [name: string]: unknown;
745
+ };
746
+ content: {
747
+ "application/json": {
748
+ data: {
749
+ access_token: string;
750
+ token_type: string;
751
+ expires_in: number;
752
+ refresh_token: string;
753
+ user: {
754
+ id: string;
755
+ email: string;
756
+ email_verified: boolean;
757
+ };
758
+ };
759
+ };
760
+ };
761
+ };
762
+ 403: {
763
+ headers: {
764
+ [name: string]: unknown;
765
+ };
766
+ content: {
767
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
768
+ };
769
+ };
770
+ 422: {
771
+ headers: {
772
+ [name: string]: unknown;
773
+ };
774
+ content: {
775
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
776
+ };
777
+ };
778
+ };
779
+ }>;
780
+ pathSerializer?: import("openapi-fetch").PathSerializer;
781
+ parseAs?: import("openapi-fetch").ParseAs;
782
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
783
+ headers?: import("openapi-fetch").HeadersOptions;
784
+ middleware?: import("openapi-fetch").Middleware[];
785
+ } & Omit<RequestInit, "body" | "headers">, `${string}/${string}`>>;
786
+ /** POST /email-otp/verify-email: Verify the email with a code */
787
+ emailOtpVerifyEmail: (init_0: {
788
+ params?: {
789
+ query?: never;
790
+ header?: never;
791
+ path?: never;
792
+ cookie?: never;
793
+ };
794
+ } & {
795
+ body: {
796
+ email: string;
797
+ code: string;
798
+ } & {};
799
+ } & {
800
+ baseUrl?: string;
801
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
802
+ parameters: {
803
+ query?: never;
804
+ header?: never;
805
+ path?: never;
806
+ cookie?: never;
807
+ };
808
+ requestBody: {
809
+ content: {
810
+ "application/json": {
811
+ email: string;
812
+ code: string;
813
+ };
814
+ };
815
+ };
816
+ responses: {
817
+ 200: {
818
+ headers: {
819
+ [name: string]: unknown;
820
+ };
821
+ content: {
822
+ "application/json": {
823
+ data: {
824
+ status: string;
825
+ };
826
+ };
827
+ };
828
+ };
829
+ 422: {
830
+ headers: {
831
+ [name: string]: unknown;
832
+ };
833
+ content: {
834
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
835
+ };
836
+ };
837
+ };
838
+ }>;
839
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
840
+ parameters: {
841
+ query?: never;
842
+ header?: never;
843
+ path?: never;
844
+ cookie?: never;
845
+ };
846
+ requestBody: {
847
+ content: {
848
+ "application/json": {
849
+ email: string;
850
+ code: string;
851
+ };
852
+ };
853
+ };
854
+ responses: {
855
+ 200: {
856
+ headers: {
857
+ [name: string]: unknown;
858
+ };
859
+ content: {
860
+ "application/json": {
861
+ data: {
862
+ status: string;
863
+ };
864
+ };
865
+ };
866
+ };
867
+ 422: {
868
+ headers: {
869
+ [name: string]: unknown;
870
+ };
871
+ content: {
872
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
873
+ };
874
+ };
875
+ };
876
+ }>;
877
+ pathSerializer?: import("openapi-fetch").PathSerializer;
878
+ parseAs?: import("openapi-fetch").ParseAs;
879
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
880
+ headers?: import("openapi-fetch").HeadersOptions;
881
+ middleware?: import("openapi-fetch").Middleware[];
882
+ } & Omit<RequestInit, "body" | "headers"> & {
883
+ [key: string]: unknown;
884
+ }) => Promise<import("openapi-fetch").FetchResponse<{
885
+ parameters: {
886
+ query?: never;
887
+ header?: never;
888
+ path?: never;
889
+ cookie?: never;
890
+ };
891
+ requestBody: {
892
+ content: {
893
+ "application/json": {
894
+ email: string;
895
+ code: string;
896
+ };
897
+ };
898
+ };
899
+ responses: {
900
+ 200: {
901
+ headers: {
902
+ [name: string]: unknown;
903
+ };
904
+ content: {
905
+ "application/json": {
906
+ data: {
907
+ status: string;
908
+ };
909
+ };
910
+ };
911
+ };
912
+ 422: {
913
+ headers: {
914
+ [name: string]: unknown;
915
+ };
916
+ content: {
917
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
918
+ };
919
+ };
920
+ };
921
+ }, {
922
+ params?: {
923
+ query?: never;
924
+ header?: never;
925
+ path?: never;
926
+ cookie?: never;
927
+ };
928
+ } & {
929
+ body: {
930
+ email: string;
931
+ code: string;
932
+ } & {};
933
+ } & {
934
+ baseUrl?: string;
935
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
936
+ parameters: {
937
+ query?: never;
938
+ header?: never;
939
+ path?: never;
940
+ cookie?: never;
941
+ };
942
+ requestBody: {
943
+ content: {
944
+ "application/json": {
945
+ email: string;
946
+ code: string;
947
+ };
948
+ };
949
+ };
950
+ responses: {
951
+ 200: {
952
+ headers: {
953
+ [name: string]: unknown;
954
+ };
955
+ content: {
956
+ "application/json": {
957
+ data: {
958
+ status: string;
959
+ };
960
+ };
961
+ };
962
+ };
963
+ 422: {
964
+ headers: {
965
+ [name: string]: unknown;
966
+ };
967
+ content: {
968
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
969
+ };
970
+ };
971
+ };
972
+ }>;
973
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
974
+ parameters: {
975
+ query?: never;
976
+ header?: never;
977
+ path?: never;
978
+ cookie?: never;
979
+ };
980
+ requestBody: {
981
+ content: {
982
+ "application/json": {
983
+ email: string;
984
+ code: string;
985
+ };
986
+ };
987
+ };
988
+ responses: {
989
+ 200: {
990
+ headers: {
991
+ [name: string]: unknown;
992
+ };
993
+ content: {
994
+ "application/json": {
995
+ data: {
996
+ status: string;
997
+ };
998
+ };
999
+ };
1000
+ };
1001
+ 422: {
1002
+ headers: {
1003
+ [name: string]: unknown;
1004
+ };
1005
+ content: {
1006
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1007
+ };
1008
+ };
1009
+ };
1010
+ }>;
1011
+ pathSerializer?: import("openapi-fetch").PathSerializer;
1012
+ parseAs?: import("openapi-fetch").ParseAs;
1013
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
1014
+ headers?: import("openapi-fetch").HeadersOptions;
1015
+ middleware?: import("openapi-fetch").Middleware[];
1016
+ } & Omit<RequestInit, "body" | "headers">, `${string}/${string}`>>;
1017
+ /** POST /magic-link/exchange: Exchange the magic link's code for the session */
1018
+ magicLinkExchange: (init_0: {
1019
+ params?: {
1020
+ query?: never;
1021
+ header?: never;
1022
+ path?: never;
1023
+ cookie?: never;
1024
+ };
1025
+ } & {
1026
+ body: {
1027
+ code: string;
1028
+ } & {};
1029
+ } & {
1030
+ baseUrl?: string;
1031
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
1032
+ parameters: {
1033
+ query?: never;
1034
+ header?: never;
1035
+ path?: never;
1036
+ cookie?: never;
1037
+ };
1038
+ requestBody: {
1039
+ content: {
1040
+ "application/json": {
1041
+ code: string;
1042
+ };
1043
+ };
1044
+ };
1045
+ responses: {
1046
+ 200: {
1047
+ headers: {
1048
+ [name: string]: unknown;
1049
+ };
1050
+ content: {
1051
+ "application/json": {
1052
+ data: {
1053
+ access_token: string;
1054
+ token_type: string;
1055
+ expires_in: number;
1056
+ refresh_token: string;
1057
+ user: {
1058
+ id: string;
1059
+ email: string;
1060
+ email_verified: boolean;
1061
+ };
1062
+ };
1063
+ };
1064
+ };
1065
+ };
1066
+ 422: {
1067
+ headers: {
1068
+ [name: string]: unknown;
1069
+ };
1070
+ content: {
1071
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1072
+ };
1073
+ };
1074
+ };
1075
+ }>;
1076
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
1077
+ parameters: {
1078
+ query?: never;
1079
+ header?: never;
1080
+ path?: never;
1081
+ cookie?: never;
1082
+ };
1083
+ requestBody: {
1084
+ content: {
1085
+ "application/json": {
1086
+ code: string;
1087
+ };
1088
+ };
1089
+ };
1090
+ responses: {
1091
+ 200: {
1092
+ headers: {
1093
+ [name: string]: unknown;
1094
+ };
1095
+ content: {
1096
+ "application/json": {
1097
+ data: {
1098
+ access_token: string;
1099
+ token_type: string;
1100
+ expires_in: number;
1101
+ refresh_token: string;
1102
+ user: {
1103
+ id: string;
1104
+ email: string;
1105
+ email_verified: boolean;
1106
+ };
1107
+ };
1108
+ };
1109
+ };
1110
+ };
1111
+ 422: {
1112
+ headers: {
1113
+ [name: string]: unknown;
1114
+ };
1115
+ content: {
1116
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1117
+ };
1118
+ };
1119
+ };
1120
+ }>;
1121
+ pathSerializer?: import("openapi-fetch").PathSerializer;
1122
+ parseAs?: import("openapi-fetch").ParseAs;
1123
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
1124
+ headers?: import("openapi-fetch").HeadersOptions;
1125
+ middleware?: import("openapi-fetch").Middleware[];
1126
+ } & Omit<RequestInit, "body" | "headers"> & {
1127
+ [key: string]: unknown;
1128
+ }) => Promise<import("openapi-fetch").FetchResponse<{
1129
+ parameters: {
1130
+ query?: never;
1131
+ header?: never;
1132
+ path?: never;
1133
+ cookie?: never;
1134
+ };
1135
+ requestBody: {
1136
+ content: {
1137
+ "application/json": {
1138
+ code: string;
1139
+ };
1140
+ };
1141
+ };
1142
+ responses: {
1143
+ 200: {
1144
+ headers: {
1145
+ [name: string]: unknown;
1146
+ };
1147
+ content: {
1148
+ "application/json": {
1149
+ data: {
1150
+ access_token: string;
1151
+ token_type: string;
1152
+ expires_in: number;
1153
+ refresh_token: string;
1154
+ user: {
1155
+ id: string;
1156
+ email: string;
1157
+ email_verified: boolean;
1158
+ };
1159
+ };
1160
+ };
1161
+ };
1162
+ };
1163
+ 422: {
1164
+ headers: {
1165
+ [name: string]: unknown;
1166
+ };
1167
+ content: {
1168
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1169
+ };
1170
+ };
1171
+ };
1172
+ }, {
1173
+ params?: {
1174
+ query?: never;
1175
+ header?: never;
1176
+ path?: never;
1177
+ cookie?: never;
1178
+ };
1179
+ } & {
1180
+ body: {
1181
+ code: string;
1182
+ } & {};
1183
+ } & {
1184
+ baseUrl?: string;
1185
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
1186
+ parameters: {
1187
+ query?: never;
1188
+ header?: never;
1189
+ path?: never;
1190
+ cookie?: never;
1191
+ };
1192
+ requestBody: {
1193
+ content: {
1194
+ "application/json": {
1195
+ code: string;
1196
+ };
1197
+ };
1198
+ };
1199
+ responses: {
1200
+ 200: {
1201
+ headers: {
1202
+ [name: string]: unknown;
1203
+ };
1204
+ content: {
1205
+ "application/json": {
1206
+ data: {
1207
+ access_token: string;
1208
+ token_type: string;
1209
+ expires_in: number;
1210
+ refresh_token: string;
1211
+ user: {
1212
+ id: string;
1213
+ email: string;
1214
+ email_verified: boolean;
1215
+ };
1216
+ };
1217
+ };
1218
+ };
1219
+ };
1220
+ 422: {
1221
+ headers: {
1222
+ [name: string]: unknown;
1223
+ };
1224
+ content: {
1225
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1226
+ };
1227
+ };
1228
+ };
1229
+ }>;
1230
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
1231
+ parameters: {
1232
+ query?: never;
1233
+ header?: never;
1234
+ path?: never;
1235
+ cookie?: never;
1236
+ };
1237
+ requestBody: {
1238
+ content: {
1239
+ "application/json": {
1240
+ code: string;
1241
+ };
1242
+ };
1243
+ };
1244
+ responses: {
1245
+ 200: {
1246
+ headers: {
1247
+ [name: string]: unknown;
1248
+ };
1249
+ content: {
1250
+ "application/json": {
1251
+ data: {
1252
+ access_token: string;
1253
+ token_type: string;
1254
+ expires_in: number;
1255
+ refresh_token: string;
1256
+ user: {
1257
+ id: string;
1258
+ email: string;
1259
+ email_verified: boolean;
1260
+ };
1261
+ };
1262
+ };
1263
+ };
1264
+ };
1265
+ 422: {
1266
+ headers: {
1267
+ [name: string]: unknown;
1268
+ };
1269
+ content: {
1270
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1271
+ };
1272
+ };
1273
+ };
1274
+ }>;
1275
+ pathSerializer?: import("openapi-fetch").PathSerializer;
1276
+ parseAs?: import("openapi-fetch").ParseAs;
1277
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
1278
+ headers?: import("openapi-fetch").HeadersOptions;
1279
+ middleware?: import("openapi-fetch").Middleware[];
1280
+ } & Omit<RequestInit, "body" | "headers">, `${string}/${string}`>>;
1281
+ /** POST /magic-link/send: Send a magic link */
1282
+ magicLinkSend: (init_0: {
1283
+ params?: {
1284
+ query?: never;
1285
+ header?: never;
1286
+ path?: never;
1287
+ cookie?: never;
1288
+ };
1289
+ } & {
1290
+ body: {
1291
+ email: string;
1292
+ redirect_uri?: string;
1293
+ } & {};
1294
+ } & {
1295
+ baseUrl?: string;
1296
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
1297
+ parameters: {
1298
+ query?: never;
1299
+ header?: never;
1300
+ path?: never;
1301
+ cookie?: never;
1302
+ };
1303
+ requestBody: {
1304
+ content: {
1305
+ "application/json": {
1306
+ email: string;
1307
+ redirect_uri?: string;
1308
+ };
1309
+ };
1310
+ };
1311
+ responses: {
1312
+ 202: {
1313
+ headers: {
1314
+ [name: string]: unknown;
1315
+ };
1316
+ content: {
1317
+ "application/json": {
1318
+ data: {
1319
+ status: string;
1320
+ };
1321
+ };
1322
+ };
1323
+ };
1324
+ 422: {
1325
+ headers: {
1326
+ [name: string]: unknown;
1327
+ };
1328
+ content: {
1329
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1330
+ };
1331
+ };
1332
+ };
1333
+ }>;
1334
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
1335
+ parameters: {
1336
+ query?: never;
1337
+ header?: never;
1338
+ path?: never;
1339
+ cookie?: never;
1340
+ };
1341
+ requestBody: {
1342
+ content: {
1343
+ "application/json": {
1344
+ email: string;
1345
+ redirect_uri?: string;
1346
+ };
1347
+ };
1348
+ };
1349
+ responses: {
1350
+ 202: {
1351
+ headers: {
1352
+ [name: string]: unknown;
1353
+ };
1354
+ content: {
1355
+ "application/json": {
1356
+ data: {
1357
+ status: string;
1358
+ };
1359
+ };
1360
+ };
1361
+ };
1362
+ 422: {
1363
+ headers: {
1364
+ [name: string]: unknown;
1365
+ };
1366
+ content: {
1367
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1368
+ };
1369
+ };
1370
+ };
1371
+ }>;
1372
+ pathSerializer?: import("openapi-fetch").PathSerializer;
1373
+ parseAs?: import("openapi-fetch").ParseAs;
1374
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
1375
+ headers?: import("openapi-fetch").HeadersOptions;
1376
+ middleware?: import("openapi-fetch").Middleware[];
1377
+ } & Omit<RequestInit, "body" | "headers"> & {
1378
+ [key: string]: unknown;
1379
+ }) => Promise<import("openapi-fetch").FetchResponse<{
1380
+ parameters: {
1381
+ query?: never;
1382
+ header?: never;
1383
+ path?: never;
1384
+ cookie?: never;
1385
+ };
1386
+ requestBody: {
1387
+ content: {
1388
+ "application/json": {
1389
+ email: string;
1390
+ redirect_uri?: string;
1391
+ };
1392
+ };
1393
+ };
1394
+ responses: {
1395
+ 202: {
1396
+ headers: {
1397
+ [name: string]: unknown;
1398
+ };
1399
+ content: {
1400
+ "application/json": {
1401
+ data: {
1402
+ status: string;
1403
+ };
1404
+ };
1405
+ };
1406
+ };
1407
+ 422: {
1408
+ headers: {
1409
+ [name: string]: unknown;
1410
+ };
1411
+ content: {
1412
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1413
+ };
1414
+ };
1415
+ };
1416
+ }, {
1417
+ params?: {
1418
+ query?: never;
1419
+ header?: never;
1420
+ path?: never;
1421
+ cookie?: never;
1422
+ };
1423
+ } & {
1424
+ body: {
1425
+ email: string;
1426
+ redirect_uri?: string;
1427
+ } & {};
1428
+ } & {
1429
+ baseUrl?: string;
1430
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
1431
+ parameters: {
1432
+ query?: never;
1433
+ header?: never;
1434
+ path?: never;
1435
+ cookie?: never;
1436
+ };
1437
+ requestBody: {
1438
+ content: {
1439
+ "application/json": {
1440
+ email: string;
1441
+ redirect_uri?: string;
1442
+ };
1443
+ };
1444
+ };
1445
+ responses: {
1446
+ 202: {
1447
+ headers: {
1448
+ [name: string]: unknown;
1449
+ };
1450
+ content: {
1451
+ "application/json": {
1452
+ data: {
1453
+ status: string;
1454
+ };
1455
+ };
1456
+ };
1457
+ };
1458
+ 422: {
1459
+ headers: {
1460
+ [name: string]: unknown;
1461
+ };
1462
+ content: {
1463
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1464
+ };
1465
+ };
1466
+ };
1467
+ }>;
1468
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
1469
+ parameters: {
1470
+ query?: never;
1471
+ header?: never;
1472
+ path?: never;
1473
+ cookie?: never;
1474
+ };
1475
+ requestBody: {
1476
+ content: {
1477
+ "application/json": {
1478
+ email: string;
1479
+ redirect_uri?: string;
1480
+ };
1481
+ };
1482
+ };
1483
+ responses: {
1484
+ 202: {
1485
+ headers: {
1486
+ [name: string]: unknown;
1487
+ };
1488
+ content: {
1489
+ "application/json": {
1490
+ data: {
1491
+ status: string;
1492
+ };
1493
+ };
1494
+ };
1495
+ };
1496
+ 422: {
1497
+ headers: {
1498
+ [name: string]: unknown;
1499
+ };
1500
+ content: {
1501
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1502
+ };
1503
+ };
1504
+ };
1505
+ }>;
1506
+ pathSerializer?: import("openapi-fetch").PathSerializer;
1507
+ parseAs?: import("openapi-fetch").ParseAs;
1508
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
1509
+ headers?: import("openapi-fetch").HeadersOptions;
1510
+ middleware?: import("openapi-fetch").Middleware[];
1511
+ } & Omit<RequestInit, "body" | "headers">, `${string}/${string}`>>;
1512
+ /** GET /magic-link/verify: Open a magic link */
1513
+ magicLinkVerify: (init_0: {
1514
+ params: {
1515
+ query: {
1516
+ token: string;
1517
+ };
1518
+ header?: never;
1519
+ path?: never;
1520
+ cookie?: never;
1521
+ };
1522
+ } & {
1523
+ body?: undefined;
1524
+ } & {
1525
+ baseUrl?: string;
1526
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
1527
+ parameters: {
1528
+ query: {
1529
+ token: string;
1530
+ };
1531
+ header?: never;
1532
+ path?: never;
1533
+ cookie?: never;
1534
+ };
1535
+ requestBody?: never;
1536
+ responses: {
1537
+ 302: {
1538
+ headers: {
1539
+ [name: string]: unknown;
1540
+ };
1541
+ content: {
1542
+ "application/json": [];
1543
+ };
1544
+ };
1545
+ 403: {
1546
+ headers: {
1547
+ [name: string]: unknown;
1548
+ };
1549
+ content: {
1550
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1551
+ };
1552
+ };
1553
+ 422: {
1554
+ headers: {
1555
+ [name: string]: unknown;
1556
+ };
1557
+ content: {
1558
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1559
+ };
1560
+ };
1561
+ };
1562
+ }>;
1563
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
1564
+ parameters: {
1565
+ query: {
1566
+ token: string;
1567
+ };
1568
+ header?: never;
1569
+ path?: never;
1570
+ cookie?: never;
1571
+ };
1572
+ requestBody?: never;
1573
+ responses: {
1574
+ 302: {
1575
+ headers: {
1576
+ [name: string]: unknown;
1577
+ };
1578
+ content: {
1579
+ "application/json": [];
1580
+ };
1581
+ };
1582
+ 403: {
1583
+ headers: {
1584
+ [name: string]: unknown;
1585
+ };
1586
+ content: {
1587
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1588
+ };
1589
+ };
1590
+ 422: {
1591
+ headers: {
1592
+ [name: string]: unknown;
1593
+ };
1594
+ content: {
1595
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1596
+ };
1597
+ };
1598
+ };
1599
+ }>;
1600
+ pathSerializer?: import("openapi-fetch").PathSerializer;
1601
+ parseAs?: import("openapi-fetch").ParseAs;
1602
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
1603
+ headers?: import("openapi-fetch").HeadersOptions;
1604
+ middleware?: import("openapi-fetch").Middleware[];
1605
+ } & Omit<RequestInit, "body" | "headers"> & {
1606
+ [key: string]: unknown;
1607
+ }) => Promise<import("openapi-fetch").FetchResponse<{
1608
+ parameters: {
1609
+ query: {
1610
+ token: string;
1611
+ };
1612
+ header?: never;
1613
+ path?: never;
1614
+ cookie?: never;
1615
+ };
1616
+ requestBody?: never;
1617
+ responses: {
1618
+ 302: {
1619
+ headers: {
1620
+ [name: string]: unknown;
1621
+ };
1622
+ content: {
1623
+ "application/json": [];
1624
+ };
1625
+ };
1626
+ 403: {
1627
+ headers: {
1628
+ [name: string]: unknown;
1629
+ };
1630
+ content: {
1631
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1632
+ };
1633
+ };
1634
+ 422: {
1635
+ headers: {
1636
+ [name: string]: unknown;
1637
+ };
1638
+ content: {
1639
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1640
+ };
1641
+ };
1642
+ };
1643
+ }, {
1644
+ params: {
1645
+ query: {
1646
+ token: string;
1647
+ };
1648
+ header?: never;
1649
+ path?: never;
1650
+ cookie?: never;
1651
+ };
1652
+ } & {
1653
+ body?: undefined;
1654
+ } & {
1655
+ baseUrl?: string;
1656
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
1657
+ parameters: {
1658
+ query: {
1659
+ token: string;
1660
+ };
1661
+ header?: never;
1662
+ path?: never;
1663
+ cookie?: never;
1664
+ };
1665
+ requestBody?: never;
1666
+ responses: {
1667
+ 302: {
1668
+ headers: {
1669
+ [name: string]: unknown;
1670
+ };
1671
+ content: {
1672
+ "application/json": [];
1673
+ };
1674
+ };
1675
+ 403: {
1676
+ headers: {
1677
+ [name: string]: unknown;
1678
+ };
1679
+ content: {
1680
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1681
+ };
1682
+ };
1683
+ 422: {
1684
+ headers: {
1685
+ [name: string]: unknown;
1686
+ };
1687
+ content: {
1688
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1689
+ };
1690
+ };
1691
+ };
1692
+ }>;
1693
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
1694
+ parameters: {
1695
+ query: {
1696
+ token: string;
1697
+ };
1698
+ header?: never;
1699
+ path?: never;
1700
+ cookie?: never;
1701
+ };
1702
+ requestBody?: never;
1703
+ responses: {
1704
+ 302: {
1705
+ headers: {
1706
+ [name: string]: unknown;
1707
+ };
1708
+ content: {
1709
+ "application/json": [];
1710
+ };
1711
+ };
1712
+ 403: {
1713
+ headers: {
1714
+ [name: string]: unknown;
1715
+ };
1716
+ content: {
1717
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1718
+ };
1719
+ };
1720
+ 422: {
1721
+ headers: {
1722
+ [name: string]: unknown;
1723
+ };
1724
+ content: {
1725
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1726
+ };
1727
+ };
1728
+ };
1729
+ }>;
1730
+ pathSerializer?: import("openapi-fetch").PathSerializer;
1731
+ parseAs?: import("openapi-fetch").ParseAs;
1732
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
1733
+ headers?: import("openapi-fetch").HeadersOptions;
1734
+ middleware?: import("openapi-fetch").Middleware[];
1735
+ } & Omit<RequestInit, "body" | "headers">, `${string}/${string}`>>;
1736
+ /** POST /one-time-token/generate: Generate a one-time token */
1737
+ oneTimeTokenGenerate: (init_0?: ({
1738
+ params?: {
1739
+ query?: never;
1740
+ header?: never;
1741
+ path?: never;
1742
+ cookie?: never;
1743
+ };
1744
+ } & {
1745
+ body?: undefined;
1746
+ } & {
1747
+ baseUrl?: string;
1748
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
1749
+ parameters: {
1750
+ query?: never;
1751
+ header?: never;
1752
+ path?: never;
1753
+ cookie?: never;
1754
+ };
1755
+ requestBody?: never;
1756
+ responses: {
1757
+ 201: {
1758
+ headers: {
1759
+ [name: string]: unknown;
1760
+ };
1761
+ content: {
1762
+ "application/json": {
1763
+ data: {
1764
+ token: string;
1765
+ expires_in: number;
1766
+ };
1767
+ };
1768
+ };
1769
+ };
1770
+ 401: {
1771
+ headers: {
1772
+ [name: string]: unknown;
1773
+ };
1774
+ content: {
1775
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1776
+ };
1777
+ };
1778
+ 403: {
1779
+ headers: {
1780
+ [name: string]: unknown;
1781
+ };
1782
+ content: {
1783
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1784
+ };
1785
+ };
1786
+ };
1787
+ }>;
1788
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
1789
+ parameters: {
1790
+ query?: never;
1791
+ header?: never;
1792
+ path?: never;
1793
+ cookie?: never;
1794
+ };
1795
+ requestBody?: never;
1796
+ responses: {
1797
+ 201: {
1798
+ headers: {
1799
+ [name: string]: unknown;
1800
+ };
1801
+ content: {
1802
+ "application/json": {
1803
+ data: {
1804
+ token: string;
1805
+ expires_in: number;
1806
+ };
1807
+ };
1808
+ };
1809
+ };
1810
+ 401: {
1811
+ headers: {
1812
+ [name: string]: unknown;
1813
+ };
1814
+ content: {
1815
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1816
+ };
1817
+ };
1818
+ 403: {
1819
+ headers: {
1820
+ [name: string]: unknown;
1821
+ };
1822
+ content: {
1823
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1824
+ };
1825
+ };
1826
+ };
1827
+ }>;
1828
+ pathSerializer?: import("openapi-fetch").PathSerializer;
1829
+ parseAs?: import("openapi-fetch").ParseAs;
1830
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
1831
+ headers?: import("openapi-fetch").HeadersOptions;
1832
+ middleware?: import("openapi-fetch").Middleware[];
1833
+ } & Omit<RequestInit, "body" | "headers"> & {
1834
+ [key: string]: unknown;
1835
+ }) | undefined) => Promise<import("openapi-fetch").FetchResponse<{
1836
+ parameters: {
1837
+ query?: never;
1838
+ header?: never;
1839
+ path?: never;
1840
+ cookie?: never;
1841
+ };
1842
+ requestBody?: never;
1843
+ responses: {
1844
+ 201: {
1845
+ headers: {
1846
+ [name: string]: unknown;
1847
+ };
1848
+ content: {
1849
+ "application/json": {
1850
+ data: {
1851
+ token: string;
1852
+ expires_in: number;
1853
+ };
1854
+ };
1855
+ };
1856
+ };
1857
+ 401: {
1858
+ headers: {
1859
+ [name: string]: unknown;
1860
+ };
1861
+ content: {
1862
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1863
+ };
1864
+ };
1865
+ 403: {
1866
+ headers: {
1867
+ [name: string]: unknown;
1868
+ };
1869
+ content: {
1870
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1871
+ };
1872
+ };
1873
+ };
1874
+ }, ({
1875
+ params?: {
1876
+ query?: never;
1877
+ header?: never;
1878
+ path?: never;
1879
+ cookie?: never;
1880
+ };
1881
+ } & {
1882
+ body?: undefined;
1883
+ } & {
1884
+ baseUrl?: string;
1885
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
1886
+ parameters: {
1887
+ query?: never;
1888
+ header?: never;
1889
+ path?: never;
1890
+ cookie?: never;
1891
+ };
1892
+ requestBody?: never;
1893
+ responses: {
1894
+ 201: {
1895
+ headers: {
1896
+ [name: string]: unknown;
1897
+ };
1898
+ content: {
1899
+ "application/json": {
1900
+ data: {
1901
+ token: string;
1902
+ expires_in: number;
1903
+ };
1904
+ };
1905
+ };
1906
+ };
1907
+ 401: {
1908
+ headers: {
1909
+ [name: string]: unknown;
1910
+ };
1911
+ content: {
1912
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1913
+ };
1914
+ };
1915
+ 403: {
1916
+ headers: {
1917
+ [name: string]: unknown;
1918
+ };
1919
+ content: {
1920
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1921
+ };
1922
+ };
1923
+ };
1924
+ }>;
1925
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
1926
+ parameters: {
1927
+ query?: never;
1928
+ header?: never;
1929
+ path?: never;
1930
+ cookie?: never;
1931
+ };
1932
+ requestBody?: never;
1933
+ responses: {
1934
+ 201: {
1935
+ headers: {
1936
+ [name: string]: unknown;
1937
+ };
1938
+ content: {
1939
+ "application/json": {
1940
+ data: {
1941
+ token: string;
1942
+ expires_in: number;
1943
+ };
1944
+ };
1945
+ };
1946
+ };
1947
+ 401: {
1948
+ headers: {
1949
+ [name: string]: unknown;
1950
+ };
1951
+ content: {
1952
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1953
+ };
1954
+ };
1955
+ 403: {
1956
+ headers: {
1957
+ [name: string]: unknown;
1958
+ };
1959
+ content: {
1960
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1961
+ };
1962
+ };
1963
+ };
1964
+ }>;
1965
+ pathSerializer?: import("openapi-fetch").PathSerializer;
1966
+ parseAs?: import("openapi-fetch").ParseAs;
1967
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
1968
+ headers?: import("openapi-fetch").HeadersOptions;
1969
+ middleware?: import("openapi-fetch").Middleware[];
1970
+ } & Omit<RequestInit, "body" | "headers"> & {
1971
+ [key: string]: unknown;
1972
+ }) | undefined, `${string}/${string}`>>;
1973
+ /** POST /one-time-token/verify: Sign in with a one-time token */
1974
+ oneTimeTokenVerify: (init_0: {
1975
+ params?: {
1976
+ query?: never;
1977
+ header?: never;
1978
+ path?: never;
1979
+ cookie?: never;
1980
+ };
1981
+ } & {
1982
+ body: {
1983
+ token: string;
1984
+ } & {};
1985
+ } & {
1986
+ baseUrl?: string;
1987
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
1988
+ parameters: {
1989
+ query?: never;
1990
+ header?: never;
1991
+ path?: never;
1992
+ cookie?: never;
1993
+ };
1994
+ requestBody: {
1995
+ content: {
1996
+ "application/json": {
1997
+ token: string;
1998
+ };
1999
+ };
2000
+ };
2001
+ responses: {
2002
+ 200: {
2003
+ headers: {
2004
+ [name: string]: unknown;
2005
+ };
2006
+ content: {
2007
+ "application/json": {
2008
+ data: {
2009
+ access_token: string;
2010
+ token_type: string;
2011
+ expires_in: number;
2012
+ refresh_token: string;
2013
+ user: {
2014
+ id: string;
2015
+ email: string;
2016
+ email_verified: boolean;
2017
+ };
2018
+ };
2019
+ };
2020
+ };
2021
+ };
2022
+ 422: {
2023
+ headers: {
2024
+ [name: string]: unknown;
2025
+ };
2026
+ content: {
2027
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2028
+ };
2029
+ };
2030
+ };
2031
+ }>;
2032
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
2033
+ parameters: {
2034
+ query?: never;
2035
+ header?: never;
2036
+ path?: never;
2037
+ cookie?: never;
2038
+ };
2039
+ requestBody: {
2040
+ content: {
2041
+ "application/json": {
2042
+ token: string;
2043
+ };
2044
+ };
2045
+ };
2046
+ responses: {
2047
+ 200: {
2048
+ headers: {
2049
+ [name: string]: unknown;
2050
+ };
2051
+ content: {
2052
+ "application/json": {
2053
+ data: {
2054
+ access_token: string;
2055
+ token_type: string;
2056
+ expires_in: number;
2057
+ refresh_token: string;
2058
+ user: {
2059
+ id: string;
2060
+ email: string;
2061
+ email_verified: boolean;
2062
+ };
2063
+ };
2064
+ };
2065
+ };
2066
+ };
2067
+ 422: {
2068
+ headers: {
2069
+ [name: string]: unknown;
2070
+ };
2071
+ content: {
2072
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2073
+ };
2074
+ };
2075
+ };
2076
+ }>;
2077
+ pathSerializer?: import("openapi-fetch").PathSerializer;
2078
+ parseAs?: import("openapi-fetch").ParseAs;
2079
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
2080
+ headers?: import("openapi-fetch").HeadersOptions;
2081
+ middleware?: import("openapi-fetch").Middleware[];
2082
+ } & Omit<RequestInit, "body" | "headers"> & {
2083
+ [key: string]: unknown;
2084
+ }) => Promise<import("openapi-fetch").FetchResponse<{
2085
+ parameters: {
2086
+ query?: never;
2087
+ header?: never;
2088
+ path?: never;
2089
+ cookie?: never;
2090
+ };
2091
+ requestBody: {
2092
+ content: {
2093
+ "application/json": {
2094
+ token: string;
2095
+ };
2096
+ };
2097
+ };
2098
+ responses: {
2099
+ 200: {
2100
+ headers: {
2101
+ [name: string]: unknown;
2102
+ };
2103
+ content: {
2104
+ "application/json": {
2105
+ data: {
2106
+ access_token: string;
2107
+ token_type: string;
2108
+ expires_in: number;
2109
+ refresh_token: string;
2110
+ user: {
2111
+ id: string;
2112
+ email: string;
2113
+ email_verified: boolean;
2114
+ };
2115
+ };
2116
+ };
2117
+ };
2118
+ };
2119
+ 422: {
2120
+ headers: {
2121
+ [name: string]: unknown;
2122
+ };
2123
+ content: {
2124
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2125
+ };
2126
+ };
2127
+ };
2128
+ }, {
2129
+ params?: {
2130
+ query?: never;
2131
+ header?: never;
2132
+ path?: never;
2133
+ cookie?: never;
2134
+ };
2135
+ } & {
2136
+ body: {
2137
+ token: string;
2138
+ } & {};
2139
+ } & {
2140
+ baseUrl?: string;
2141
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
2142
+ parameters: {
2143
+ query?: never;
2144
+ header?: never;
2145
+ path?: never;
2146
+ cookie?: never;
2147
+ };
2148
+ requestBody: {
2149
+ content: {
2150
+ "application/json": {
2151
+ token: string;
2152
+ };
2153
+ };
2154
+ };
2155
+ responses: {
2156
+ 200: {
2157
+ headers: {
2158
+ [name: string]: unknown;
2159
+ };
2160
+ content: {
2161
+ "application/json": {
2162
+ data: {
2163
+ access_token: string;
2164
+ token_type: string;
2165
+ expires_in: number;
2166
+ refresh_token: string;
2167
+ user: {
2168
+ id: string;
2169
+ email: string;
2170
+ email_verified: boolean;
2171
+ };
2172
+ };
2173
+ };
2174
+ };
2175
+ };
2176
+ 422: {
2177
+ headers: {
2178
+ [name: string]: unknown;
2179
+ };
2180
+ content: {
2181
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2182
+ };
2183
+ };
2184
+ };
2185
+ }>;
2186
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
2187
+ parameters: {
2188
+ query?: never;
2189
+ header?: never;
2190
+ path?: never;
2191
+ cookie?: never;
2192
+ };
2193
+ requestBody: {
2194
+ content: {
2195
+ "application/json": {
2196
+ token: string;
2197
+ };
2198
+ };
2199
+ };
2200
+ responses: {
2201
+ 200: {
2202
+ headers: {
2203
+ [name: string]: unknown;
2204
+ };
2205
+ content: {
2206
+ "application/json": {
2207
+ data: {
2208
+ access_token: string;
2209
+ token_type: string;
2210
+ expires_in: number;
2211
+ refresh_token: string;
2212
+ user: {
2213
+ id: string;
2214
+ email: string;
2215
+ email_verified: boolean;
2216
+ };
2217
+ };
2218
+ };
2219
+ };
2220
+ };
2221
+ 422: {
2222
+ headers: {
2223
+ [name: string]: unknown;
2224
+ };
2225
+ content: {
2226
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2227
+ };
2228
+ };
2229
+ };
2230
+ }>;
2231
+ pathSerializer?: import("openapi-fetch").PathSerializer;
2232
+ parseAs?: import("openapi-fetch").ParseAs;
2233
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
2234
+ headers?: import("openapi-fetch").HeadersOptions;
2235
+ middleware?: import("openapi-fetch").Middleware[];
2236
+ } & Omit<RequestInit, "body" | "headers">, `${string}/${string}`>>;
2237
+ /** POST /phone/add: Add a phone number */
2238
+ phoneAdd: (init_0: {
2239
+ params?: {
2240
+ query?: never;
2241
+ header?: never;
2242
+ path?: never;
2243
+ cookie?: never;
2244
+ };
2245
+ } & {
2246
+ body: {
2247
+ phone: string;
2248
+ } & {};
2249
+ } & {
2250
+ baseUrl?: string;
2251
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
2252
+ parameters: {
2253
+ query?: never;
2254
+ header?: never;
2255
+ path?: never;
2256
+ cookie?: never;
2257
+ };
2258
+ requestBody: {
2259
+ content: {
2260
+ "application/json": {
2261
+ phone: string;
2262
+ };
2263
+ };
2264
+ };
2265
+ responses: {
2266
+ 202: {
2267
+ headers: {
2268
+ [name: string]: unknown;
2269
+ };
2270
+ content: {
2271
+ "application/json": {
2272
+ data: {
2273
+ status: string;
2274
+ };
2275
+ };
2276
+ };
2277
+ };
2278
+ 401: {
2279
+ headers: {
2280
+ [name: string]: unknown;
2281
+ };
2282
+ content: {
2283
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2284
+ };
2285
+ };
2286
+ 422: {
2287
+ headers: {
2288
+ [name: string]: unknown;
2289
+ };
2290
+ content: {
2291
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2292
+ };
2293
+ };
2294
+ };
2295
+ }>;
2296
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
2297
+ parameters: {
2298
+ query?: never;
2299
+ header?: never;
2300
+ path?: never;
2301
+ cookie?: never;
2302
+ };
2303
+ requestBody: {
2304
+ content: {
2305
+ "application/json": {
2306
+ phone: string;
2307
+ };
2308
+ };
2309
+ };
2310
+ responses: {
2311
+ 202: {
2312
+ headers: {
2313
+ [name: string]: unknown;
2314
+ };
2315
+ content: {
2316
+ "application/json": {
2317
+ data: {
2318
+ status: string;
2319
+ };
2320
+ };
2321
+ };
2322
+ };
2323
+ 401: {
2324
+ headers: {
2325
+ [name: string]: unknown;
2326
+ };
2327
+ content: {
2328
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2329
+ };
2330
+ };
2331
+ 422: {
2332
+ headers: {
2333
+ [name: string]: unknown;
2334
+ };
2335
+ content: {
2336
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2337
+ };
2338
+ };
2339
+ };
2340
+ }>;
2341
+ pathSerializer?: import("openapi-fetch").PathSerializer;
2342
+ parseAs?: import("openapi-fetch").ParseAs;
2343
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
2344
+ headers?: import("openapi-fetch").HeadersOptions;
2345
+ middleware?: import("openapi-fetch").Middleware[];
2346
+ } & Omit<RequestInit, "body" | "headers"> & {
2347
+ [key: string]: unknown;
2348
+ }) => Promise<import("openapi-fetch").FetchResponse<{
2349
+ parameters: {
2350
+ query?: never;
2351
+ header?: never;
2352
+ path?: never;
2353
+ cookie?: never;
2354
+ };
2355
+ requestBody: {
2356
+ content: {
2357
+ "application/json": {
2358
+ phone: string;
2359
+ };
2360
+ };
2361
+ };
2362
+ responses: {
2363
+ 202: {
2364
+ headers: {
2365
+ [name: string]: unknown;
2366
+ };
2367
+ content: {
2368
+ "application/json": {
2369
+ data: {
2370
+ status: string;
2371
+ };
2372
+ };
2373
+ };
2374
+ };
2375
+ 401: {
2376
+ headers: {
2377
+ [name: string]: unknown;
2378
+ };
2379
+ content: {
2380
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2381
+ };
2382
+ };
2383
+ 422: {
2384
+ headers: {
2385
+ [name: string]: unknown;
2386
+ };
2387
+ content: {
2388
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2389
+ };
2390
+ };
2391
+ };
2392
+ }, {
2393
+ params?: {
2394
+ query?: never;
2395
+ header?: never;
2396
+ path?: never;
2397
+ cookie?: never;
2398
+ };
2399
+ } & {
2400
+ body: {
2401
+ phone: string;
2402
+ } & {};
2403
+ } & {
2404
+ baseUrl?: string;
2405
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
2406
+ parameters: {
2407
+ query?: never;
2408
+ header?: never;
2409
+ path?: never;
2410
+ cookie?: never;
2411
+ };
2412
+ requestBody: {
2413
+ content: {
2414
+ "application/json": {
2415
+ phone: string;
2416
+ };
2417
+ };
2418
+ };
2419
+ responses: {
2420
+ 202: {
2421
+ headers: {
2422
+ [name: string]: unknown;
2423
+ };
2424
+ content: {
2425
+ "application/json": {
2426
+ data: {
2427
+ status: string;
2428
+ };
2429
+ };
2430
+ };
2431
+ };
2432
+ 401: {
2433
+ headers: {
2434
+ [name: string]: unknown;
2435
+ };
2436
+ content: {
2437
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2438
+ };
2439
+ };
2440
+ 422: {
2441
+ headers: {
2442
+ [name: string]: unknown;
2443
+ };
2444
+ content: {
2445
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2446
+ };
2447
+ };
2448
+ };
2449
+ }>;
2450
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
2451
+ parameters: {
2452
+ query?: never;
2453
+ header?: never;
2454
+ path?: never;
2455
+ cookie?: never;
2456
+ };
2457
+ requestBody: {
2458
+ content: {
2459
+ "application/json": {
2460
+ phone: string;
2461
+ };
2462
+ };
2463
+ };
2464
+ responses: {
2465
+ 202: {
2466
+ headers: {
2467
+ [name: string]: unknown;
2468
+ };
2469
+ content: {
2470
+ "application/json": {
2471
+ data: {
2472
+ status: string;
2473
+ };
2474
+ };
2475
+ };
2476
+ };
2477
+ 401: {
2478
+ headers: {
2479
+ [name: string]: unknown;
2480
+ };
2481
+ content: {
2482
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2483
+ };
2484
+ };
2485
+ 422: {
2486
+ headers: {
2487
+ [name: string]: unknown;
2488
+ };
2489
+ content: {
2490
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2491
+ };
2492
+ };
2493
+ };
2494
+ }>;
2495
+ pathSerializer?: import("openapi-fetch").PathSerializer;
2496
+ parseAs?: import("openapi-fetch").ParseAs;
2497
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
2498
+ headers?: import("openapi-fetch").HeadersOptions;
2499
+ middleware?: import("openapi-fetch").Middleware[];
2500
+ } & Omit<RequestInit, "body" | "headers">, `${string}/${string}`>>;
2501
+ /** POST /phone/confirm: Confirm a phone number */
2502
+ phoneConfirm: (init_0: {
2503
+ params?: {
2504
+ query?: never;
2505
+ header?: never;
2506
+ path?: never;
2507
+ cookie?: never;
2508
+ };
2509
+ } & {
2510
+ body: {
2511
+ phone: string;
2512
+ code: string;
2513
+ } & {};
2514
+ } & {
2515
+ baseUrl?: string;
2516
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
2517
+ parameters: {
2518
+ query?: never;
2519
+ header?: never;
2520
+ path?: never;
2521
+ cookie?: never;
2522
+ };
2523
+ requestBody: {
2524
+ content: {
2525
+ "application/json": {
2526
+ phone: string;
2527
+ code: string;
2528
+ };
2529
+ };
2530
+ };
2531
+ responses: {
2532
+ 200: {
2533
+ headers: {
2534
+ [name: string]: unknown;
2535
+ };
2536
+ content: {
2537
+ "application/json": {
2538
+ data: {
2539
+ phone: string;
2540
+ verified: boolean;
2541
+ };
2542
+ };
2543
+ };
2544
+ };
2545
+ 401: {
2546
+ headers: {
2547
+ [name: string]: unknown;
2548
+ };
2549
+ content: {
2550
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2551
+ };
2552
+ };
2553
+ 409: {
2554
+ headers: {
2555
+ [name: string]: unknown;
2556
+ };
2557
+ content: {
2558
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2559
+ };
2560
+ };
2561
+ 422: {
2562
+ headers: {
2563
+ [name: string]: unknown;
2564
+ };
2565
+ content: {
2566
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2567
+ };
2568
+ };
2569
+ };
2570
+ }>;
2571
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
2572
+ parameters: {
2573
+ query?: never;
2574
+ header?: never;
2575
+ path?: never;
2576
+ cookie?: never;
2577
+ };
2578
+ requestBody: {
2579
+ content: {
2580
+ "application/json": {
2581
+ phone: string;
2582
+ code: string;
2583
+ };
2584
+ };
2585
+ };
2586
+ responses: {
2587
+ 200: {
2588
+ headers: {
2589
+ [name: string]: unknown;
2590
+ };
2591
+ content: {
2592
+ "application/json": {
2593
+ data: {
2594
+ phone: string;
2595
+ verified: boolean;
2596
+ };
2597
+ };
2598
+ };
2599
+ };
2600
+ 401: {
2601
+ headers: {
2602
+ [name: string]: unknown;
2603
+ };
2604
+ content: {
2605
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2606
+ };
2607
+ };
2608
+ 409: {
2609
+ headers: {
2610
+ [name: string]: unknown;
2611
+ };
2612
+ content: {
2613
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2614
+ };
2615
+ };
2616
+ 422: {
2617
+ headers: {
2618
+ [name: string]: unknown;
2619
+ };
2620
+ content: {
2621
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2622
+ };
2623
+ };
2624
+ };
2625
+ }>;
2626
+ pathSerializer?: import("openapi-fetch").PathSerializer;
2627
+ parseAs?: import("openapi-fetch").ParseAs;
2628
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
2629
+ headers?: import("openapi-fetch").HeadersOptions;
2630
+ middleware?: import("openapi-fetch").Middleware[];
2631
+ } & Omit<RequestInit, "body" | "headers"> & {
2632
+ [key: string]: unknown;
2633
+ }) => Promise<import("openapi-fetch").FetchResponse<{
2634
+ parameters: {
2635
+ query?: never;
2636
+ header?: never;
2637
+ path?: never;
2638
+ cookie?: never;
2639
+ };
2640
+ requestBody: {
2641
+ content: {
2642
+ "application/json": {
2643
+ phone: string;
2644
+ code: string;
2645
+ };
2646
+ };
2647
+ };
2648
+ responses: {
2649
+ 200: {
2650
+ headers: {
2651
+ [name: string]: unknown;
2652
+ };
2653
+ content: {
2654
+ "application/json": {
2655
+ data: {
2656
+ phone: string;
2657
+ verified: boolean;
2658
+ };
2659
+ };
2660
+ };
2661
+ };
2662
+ 401: {
2663
+ headers: {
2664
+ [name: string]: unknown;
2665
+ };
2666
+ content: {
2667
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2668
+ };
2669
+ };
2670
+ 409: {
2671
+ headers: {
2672
+ [name: string]: unknown;
2673
+ };
2674
+ content: {
2675
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2676
+ };
2677
+ };
2678
+ 422: {
2679
+ headers: {
2680
+ [name: string]: unknown;
2681
+ };
2682
+ content: {
2683
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2684
+ };
2685
+ };
2686
+ };
2687
+ }, {
2688
+ params?: {
2689
+ query?: never;
2690
+ header?: never;
2691
+ path?: never;
2692
+ cookie?: never;
2693
+ };
2694
+ } & {
2695
+ body: {
2696
+ phone: string;
2697
+ code: string;
2698
+ } & {};
2699
+ } & {
2700
+ baseUrl?: string;
2701
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
2702
+ parameters: {
2703
+ query?: never;
2704
+ header?: never;
2705
+ path?: never;
2706
+ cookie?: never;
2707
+ };
2708
+ requestBody: {
2709
+ content: {
2710
+ "application/json": {
2711
+ phone: string;
2712
+ code: string;
2713
+ };
2714
+ };
2715
+ };
2716
+ responses: {
2717
+ 200: {
2718
+ headers: {
2719
+ [name: string]: unknown;
2720
+ };
2721
+ content: {
2722
+ "application/json": {
2723
+ data: {
2724
+ phone: string;
2725
+ verified: boolean;
2726
+ };
2727
+ };
2728
+ };
2729
+ };
2730
+ 401: {
2731
+ headers: {
2732
+ [name: string]: unknown;
2733
+ };
2734
+ content: {
2735
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2736
+ };
2737
+ };
2738
+ 409: {
2739
+ headers: {
2740
+ [name: string]: unknown;
2741
+ };
2742
+ content: {
2743
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2744
+ };
2745
+ };
2746
+ 422: {
2747
+ headers: {
2748
+ [name: string]: unknown;
2749
+ };
2750
+ content: {
2751
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2752
+ };
2753
+ };
2754
+ };
2755
+ }>;
2756
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
2757
+ parameters: {
2758
+ query?: never;
2759
+ header?: never;
2760
+ path?: never;
2761
+ cookie?: never;
2762
+ };
2763
+ requestBody: {
2764
+ content: {
2765
+ "application/json": {
2766
+ phone: string;
2767
+ code: string;
2768
+ };
2769
+ };
2770
+ };
2771
+ responses: {
2772
+ 200: {
2773
+ headers: {
2774
+ [name: string]: unknown;
2775
+ };
2776
+ content: {
2777
+ "application/json": {
2778
+ data: {
2779
+ phone: string;
2780
+ verified: boolean;
2781
+ };
2782
+ };
2783
+ };
2784
+ };
2785
+ 401: {
2786
+ headers: {
2787
+ [name: string]: unknown;
2788
+ };
2789
+ content: {
2790
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2791
+ };
2792
+ };
2793
+ 409: {
2794
+ headers: {
2795
+ [name: string]: unknown;
2796
+ };
2797
+ content: {
2798
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2799
+ };
2800
+ };
2801
+ 422: {
2802
+ headers: {
2803
+ [name: string]: unknown;
2804
+ };
2805
+ content: {
2806
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2807
+ };
2808
+ };
2809
+ };
2810
+ }>;
2811
+ pathSerializer?: import("openapi-fetch").PathSerializer;
2812
+ parseAs?: import("openapi-fetch").ParseAs;
2813
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
2814
+ headers?: import("openapi-fetch").HeadersOptions;
2815
+ middleware?: import("openapi-fetch").Middleware[];
2816
+ } & Omit<RequestInit, "body" | "headers">, `${string}/${string}`>>;
2817
+ /** POST /phone/send: Send a phone sign-in code */
2818
+ phoneSend: (init_0: {
2819
+ params?: {
2820
+ query?: never;
2821
+ header?: never;
2822
+ path?: never;
2823
+ cookie?: never;
2824
+ };
2825
+ } & {
2826
+ body: {
2827
+ phone: string;
2828
+ } & {};
2829
+ } & {
2830
+ baseUrl?: string;
2831
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
2832
+ parameters: {
2833
+ query?: never;
2834
+ header?: never;
2835
+ path?: never;
2836
+ cookie?: never;
2837
+ };
2838
+ requestBody: {
2839
+ content: {
2840
+ "application/json": {
2841
+ phone: string;
2842
+ };
2843
+ };
2844
+ };
2845
+ responses: {
2846
+ 202: {
2847
+ headers: {
2848
+ [name: string]: unknown;
2849
+ };
2850
+ content: {
2851
+ "application/json": {
2852
+ data: {
2853
+ status: string;
2854
+ };
2855
+ };
2856
+ };
2857
+ };
2858
+ 422: {
2859
+ headers: {
2860
+ [name: string]: unknown;
2861
+ };
2862
+ content: {
2863
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2864
+ };
2865
+ };
2866
+ };
2867
+ }>;
2868
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
2869
+ parameters: {
2870
+ query?: never;
2871
+ header?: never;
2872
+ path?: never;
2873
+ cookie?: never;
2874
+ };
2875
+ requestBody: {
2876
+ content: {
2877
+ "application/json": {
2878
+ phone: string;
2879
+ };
2880
+ };
2881
+ };
2882
+ responses: {
2883
+ 202: {
2884
+ headers: {
2885
+ [name: string]: unknown;
2886
+ };
2887
+ content: {
2888
+ "application/json": {
2889
+ data: {
2890
+ status: string;
2891
+ };
2892
+ };
2893
+ };
2894
+ };
2895
+ 422: {
2896
+ headers: {
2897
+ [name: string]: unknown;
2898
+ };
2899
+ content: {
2900
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2901
+ };
2902
+ };
2903
+ };
2904
+ }>;
2905
+ pathSerializer?: import("openapi-fetch").PathSerializer;
2906
+ parseAs?: import("openapi-fetch").ParseAs;
2907
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
2908
+ headers?: import("openapi-fetch").HeadersOptions;
2909
+ middleware?: import("openapi-fetch").Middleware[];
2910
+ } & Omit<RequestInit, "body" | "headers"> & {
2911
+ [key: string]: unknown;
2912
+ }) => Promise<import("openapi-fetch").FetchResponse<{
2913
+ parameters: {
2914
+ query?: never;
2915
+ header?: never;
2916
+ path?: never;
2917
+ cookie?: never;
2918
+ };
2919
+ requestBody: {
2920
+ content: {
2921
+ "application/json": {
2922
+ phone: string;
2923
+ };
2924
+ };
2925
+ };
2926
+ responses: {
2927
+ 202: {
2928
+ headers: {
2929
+ [name: string]: unknown;
2930
+ };
2931
+ content: {
2932
+ "application/json": {
2933
+ data: {
2934
+ status: string;
2935
+ };
2936
+ };
2937
+ };
2938
+ };
2939
+ 422: {
2940
+ headers: {
2941
+ [name: string]: unknown;
2942
+ };
2943
+ content: {
2944
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2945
+ };
2946
+ };
2947
+ };
2948
+ }, {
2949
+ params?: {
2950
+ query?: never;
2951
+ header?: never;
2952
+ path?: never;
2953
+ cookie?: never;
2954
+ };
2955
+ } & {
2956
+ body: {
2957
+ phone: string;
2958
+ } & {};
2959
+ } & {
2960
+ baseUrl?: string;
2961
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
2962
+ parameters: {
2963
+ query?: never;
2964
+ header?: never;
2965
+ path?: never;
2966
+ cookie?: never;
2967
+ };
2968
+ requestBody: {
2969
+ content: {
2970
+ "application/json": {
2971
+ phone: string;
2972
+ };
2973
+ };
2974
+ };
2975
+ responses: {
2976
+ 202: {
2977
+ headers: {
2978
+ [name: string]: unknown;
2979
+ };
2980
+ content: {
2981
+ "application/json": {
2982
+ data: {
2983
+ status: string;
2984
+ };
2985
+ };
2986
+ };
2987
+ };
2988
+ 422: {
2989
+ headers: {
2990
+ [name: string]: unknown;
2991
+ };
2992
+ content: {
2993
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2994
+ };
2995
+ };
2996
+ };
2997
+ }>;
2998
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
2999
+ parameters: {
3000
+ query?: never;
3001
+ header?: never;
3002
+ path?: never;
3003
+ cookie?: never;
3004
+ };
3005
+ requestBody: {
3006
+ content: {
3007
+ "application/json": {
3008
+ phone: string;
3009
+ };
3010
+ };
3011
+ };
3012
+ responses: {
3013
+ 202: {
3014
+ headers: {
3015
+ [name: string]: unknown;
3016
+ };
3017
+ content: {
3018
+ "application/json": {
3019
+ data: {
3020
+ status: string;
3021
+ };
3022
+ };
3023
+ };
3024
+ };
3025
+ 422: {
3026
+ headers: {
3027
+ [name: string]: unknown;
3028
+ };
3029
+ content: {
3030
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
3031
+ };
3032
+ };
3033
+ };
3034
+ }>;
3035
+ pathSerializer?: import("openapi-fetch").PathSerializer;
3036
+ parseAs?: import("openapi-fetch").ParseAs;
3037
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
3038
+ headers?: import("openapi-fetch").HeadersOptions;
3039
+ middleware?: import("openapi-fetch").Middleware[];
3040
+ } & Omit<RequestInit, "body" | "headers">, `${string}/${string}`>>;
3041
+ /** POST /phone/verify: Sign in with a phone code */
3042
+ phoneVerify: (init_0: {
3043
+ params?: {
3044
+ query?: never;
3045
+ header?: never;
3046
+ path?: never;
3047
+ cookie?: never;
3048
+ };
3049
+ } & {
3050
+ body: {
3051
+ phone: string;
3052
+ code: string;
3053
+ } & {};
3054
+ } & {
3055
+ baseUrl?: string;
3056
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
3057
+ parameters: {
3058
+ query?: never;
3059
+ header?: never;
3060
+ path?: never;
3061
+ cookie?: never;
3062
+ };
3063
+ requestBody: {
3064
+ content: {
3065
+ "application/json": {
3066
+ phone: string;
3067
+ code: string;
3068
+ };
3069
+ };
3070
+ };
3071
+ responses: {
3072
+ 200: {
3073
+ headers: {
3074
+ [name: string]: unknown;
3075
+ };
3076
+ content: {
3077
+ "application/json": {
3078
+ data: {
3079
+ access_token: string;
3080
+ token_type: string;
3081
+ expires_in: number;
3082
+ refresh_token: string;
3083
+ user: {
3084
+ id: string;
3085
+ email: string;
3086
+ email_verified: boolean;
3087
+ };
3088
+ };
3089
+ };
3090
+ };
3091
+ };
3092
+ 403: {
3093
+ headers: {
3094
+ [name: string]: unknown;
3095
+ };
3096
+ content: {
3097
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
3098
+ };
3099
+ };
3100
+ 422: {
3101
+ headers: {
3102
+ [name: string]: unknown;
3103
+ };
3104
+ content: {
3105
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
3106
+ };
3107
+ };
3108
+ };
3109
+ }>;
3110
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
3111
+ parameters: {
3112
+ query?: never;
3113
+ header?: never;
3114
+ path?: never;
3115
+ cookie?: never;
3116
+ };
3117
+ requestBody: {
3118
+ content: {
3119
+ "application/json": {
3120
+ phone: string;
3121
+ code: string;
3122
+ };
3123
+ };
3124
+ };
3125
+ responses: {
3126
+ 200: {
3127
+ headers: {
3128
+ [name: string]: unknown;
3129
+ };
3130
+ content: {
3131
+ "application/json": {
3132
+ data: {
3133
+ access_token: string;
3134
+ token_type: string;
3135
+ expires_in: number;
3136
+ refresh_token: string;
3137
+ user: {
3138
+ id: string;
3139
+ email: string;
3140
+ email_verified: boolean;
3141
+ };
3142
+ };
3143
+ };
3144
+ };
3145
+ };
3146
+ 403: {
3147
+ headers: {
3148
+ [name: string]: unknown;
3149
+ };
3150
+ content: {
3151
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
3152
+ };
3153
+ };
3154
+ 422: {
3155
+ headers: {
3156
+ [name: string]: unknown;
3157
+ };
3158
+ content: {
3159
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
3160
+ };
3161
+ };
3162
+ };
3163
+ }>;
3164
+ pathSerializer?: import("openapi-fetch").PathSerializer;
3165
+ parseAs?: import("openapi-fetch").ParseAs;
3166
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
3167
+ headers?: import("openapi-fetch").HeadersOptions;
3168
+ middleware?: import("openapi-fetch").Middleware[];
3169
+ } & Omit<RequestInit, "body" | "headers"> & {
3170
+ [key: string]: unknown;
3171
+ }) => Promise<import("openapi-fetch").FetchResponse<{
3172
+ parameters: {
3173
+ query?: never;
3174
+ header?: never;
3175
+ path?: never;
3176
+ cookie?: never;
3177
+ };
3178
+ requestBody: {
3179
+ content: {
3180
+ "application/json": {
3181
+ phone: string;
3182
+ code: string;
3183
+ };
3184
+ };
3185
+ };
3186
+ responses: {
3187
+ 200: {
3188
+ headers: {
3189
+ [name: string]: unknown;
3190
+ };
3191
+ content: {
3192
+ "application/json": {
3193
+ data: {
3194
+ access_token: string;
3195
+ token_type: string;
3196
+ expires_in: number;
3197
+ refresh_token: string;
3198
+ user: {
3199
+ id: string;
3200
+ email: string;
3201
+ email_verified: boolean;
3202
+ };
3203
+ };
3204
+ };
3205
+ };
3206
+ };
3207
+ 403: {
3208
+ headers: {
3209
+ [name: string]: unknown;
3210
+ };
3211
+ content: {
3212
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
3213
+ };
3214
+ };
3215
+ 422: {
3216
+ headers: {
3217
+ [name: string]: unknown;
3218
+ };
3219
+ content: {
3220
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
3221
+ };
3222
+ };
3223
+ };
3224
+ }, {
3225
+ params?: {
3226
+ query?: never;
3227
+ header?: never;
3228
+ path?: never;
3229
+ cookie?: never;
3230
+ };
3231
+ } & {
3232
+ body: {
3233
+ phone: string;
3234
+ code: string;
3235
+ } & {};
3236
+ } & {
3237
+ baseUrl?: string;
3238
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
3239
+ parameters: {
3240
+ query?: never;
3241
+ header?: never;
3242
+ path?: never;
3243
+ cookie?: never;
3244
+ };
3245
+ requestBody: {
3246
+ content: {
3247
+ "application/json": {
3248
+ phone: string;
3249
+ code: string;
3250
+ };
3251
+ };
3252
+ };
3253
+ responses: {
3254
+ 200: {
3255
+ headers: {
3256
+ [name: string]: unknown;
3257
+ };
3258
+ content: {
3259
+ "application/json": {
3260
+ data: {
3261
+ access_token: string;
3262
+ token_type: string;
3263
+ expires_in: number;
3264
+ refresh_token: string;
3265
+ user: {
3266
+ id: string;
3267
+ email: string;
3268
+ email_verified: boolean;
3269
+ };
3270
+ };
3271
+ };
3272
+ };
3273
+ };
3274
+ 403: {
3275
+ headers: {
3276
+ [name: string]: unknown;
3277
+ };
3278
+ content: {
3279
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
3280
+ };
3281
+ };
3282
+ 422: {
3283
+ headers: {
3284
+ [name: string]: unknown;
3285
+ };
3286
+ content: {
3287
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
3288
+ };
3289
+ };
3290
+ };
3291
+ }>;
3292
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
3293
+ parameters: {
3294
+ query?: never;
3295
+ header?: never;
3296
+ path?: never;
3297
+ cookie?: never;
3298
+ };
3299
+ requestBody: {
3300
+ content: {
3301
+ "application/json": {
3302
+ phone: string;
3303
+ code: string;
3304
+ };
3305
+ };
3306
+ };
3307
+ responses: {
3308
+ 200: {
3309
+ headers: {
3310
+ [name: string]: unknown;
3311
+ };
3312
+ content: {
3313
+ "application/json": {
3314
+ data: {
3315
+ access_token: string;
3316
+ token_type: string;
3317
+ expires_in: number;
3318
+ refresh_token: string;
3319
+ user: {
3320
+ id: string;
3321
+ email: string;
3322
+ email_verified: boolean;
3323
+ };
3324
+ };
3325
+ };
3326
+ };
3327
+ };
3328
+ 403: {
3329
+ headers: {
3330
+ [name: string]: unknown;
3331
+ };
3332
+ content: {
3333
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
3334
+ };
3335
+ };
3336
+ 422: {
3337
+ headers: {
3338
+ [name: string]: unknown;
3339
+ };
3340
+ content: {
3341
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
3342
+ };
3343
+ };
3344
+ };
3345
+ }>;
3346
+ pathSerializer?: import("openapi-fetch").PathSerializer;
3347
+ parseAs?: import("openapi-fetch").ParseAs;
3348
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
3349
+ headers?: import("openapi-fetch").HeadersOptions;
3350
+ middleware?: import("openapi-fetch").Middleware[];
3351
+ } & Omit<RequestInit, "body" | "headers">, `${string}/${string}`>>;
3352
+ };
3353
+ export type PasswordlessApi = ReturnType<typeof passwordless>;