@polaris-auth/client 0.0.0-stage → 0.7.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,1104 @@
1
+ import type { Client } from "openapi-fetch";
2
+ import type { paths } from "./schema.js";
3
+ import type { Init } from "./namespace.js";
4
+ /** The `multi-session` plugin's routes as methods of `client.multiSession`. */
5
+ export declare function multiSession(client: Client<paths>): {
6
+ /** GET /multi-session/last-method: Read the device's last sign-in method */
7
+ lastMethod: (init_0?: ({
8
+ params?: {
9
+ query?: never;
10
+ header?: never;
11
+ path?: never;
12
+ cookie?: never;
13
+ };
14
+ } & {
15
+ body?: undefined;
16
+ } & {
17
+ baseUrl?: string;
18
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
19
+ parameters: {
20
+ query?: never;
21
+ header?: never;
22
+ path?: never;
23
+ cookie?: never;
24
+ };
25
+ requestBody?: never;
26
+ responses: {
27
+ 200: {
28
+ headers: {
29
+ [name: string]: unknown;
30
+ };
31
+ content: {
32
+ "application/json": {
33
+ data: {
34
+ last_method: string;
35
+ };
36
+ };
37
+ };
38
+ };
39
+ };
40
+ }>;
41
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
42
+ parameters: {
43
+ query?: never;
44
+ header?: never;
45
+ path?: never;
46
+ cookie?: never;
47
+ };
48
+ requestBody?: never;
49
+ responses: {
50
+ 200: {
51
+ headers: {
52
+ [name: string]: unknown;
53
+ };
54
+ content: {
55
+ "application/json": {
56
+ data: {
57
+ last_method: string;
58
+ };
59
+ };
60
+ };
61
+ };
62
+ };
63
+ }>;
64
+ pathSerializer?: import("openapi-fetch").PathSerializer;
65
+ parseAs?: import("openapi-fetch").ParseAs;
66
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
67
+ headers?: import("openapi-fetch").HeadersOptions;
68
+ middleware?: import("openapi-fetch").Middleware[];
69
+ } & Omit<RequestInit, "body" | "headers"> & {
70
+ [key: string]: unknown;
71
+ }) | undefined) => Promise<import("openapi-fetch").FetchResponse<{
72
+ parameters: {
73
+ query?: never;
74
+ header?: never;
75
+ path?: never;
76
+ cookie?: never;
77
+ };
78
+ requestBody?: never;
79
+ responses: {
80
+ 200: {
81
+ headers: {
82
+ [name: string]: unknown;
83
+ };
84
+ content: {
85
+ "application/json": {
86
+ data: {
87
+ last_method: string;
88
+ };
89
+ };
90
+ };
91
+ };
92
+ };
93
+ }, ({
94
+ params?: {
95
+ query?: never;
96
+ header?: never;
97
+ path?: never;
98
+ cookie?: never;
99
+ };
100
+ } & {
101
+ body?: undefined;
102
+ } & {
103
+ baseUrl?: string;
104
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
105
+ parameters: {
106
+ query?: never;
107
+ header?: never;
108
+ path?: never;
109
+ cookie?: never;
110
+ };
111
+ requestBody?: never;
112
+ responses: {
113
+ 200: {
114
+ headers: {
115
+ [name: string]: unknown;
116
+ };
117
+ content: {
118
+ "application/json": {
119
+ data: {
120
+ last_method: string;
121
+ };
122
+ };
123
+ };
124
+ };
125
+ };
126
+ }>;
127
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
128
+ parameters: {
129
+ query?: never;
130
+ header?: never;
131
+ path?: never;
132
+ cookie?: never;
133
+ };
134
+ requestBody?: never;
135
+ responses: {
136
+ 200: {
137
+ headers: {
138
+ [name: string]: unknown;
139
+ };
140
+ content: {
141
+ "application/json": {
142
+ data: {
143
+ last_method: string;
144
+ };
145
+ };
146
+ };
147
+ };
148
+ };
149
+ }>;
150
+ pathSerializer?: import("openapi-fetch").PathSerializer;
151
+ parseAs?: import("openapi-fetch").ParseAs;
152
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
153
+ headers?: import("openapi-fetch").HeadersOptions;
154
+ middleware?: import("openapi-fetch").Middleware[];
155
+ } & Omit<RequestInit, "body" | "headers"> & {
156
+ [key: string]: unknown;
157
+ }) | undefined, `${string}/${string}`>>;
158
+ /** GET /multi-session/list: List the accounts signed in on this device */
159
+ list: (init_0?: ({
160
+ params?: {
161
+ query?: never;
162
+ header?: never;
163
+ path?: never;
164
+ cookie?: never;
165
+ };
166
+ } & {
167
+ body?: undefined;
168
+ } & {
169
+ baseUrl?: string;
170
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
171
+ parameters: {
172
+ query?: never;
173
+ header?: never;
174
+ path?: never;
175
+ cookie?: never;
176
+ };
177
+ requestBody?: never;
178
+ responses: {
179
+ 200: {
180
+ headers: {
181
+ [name: string]: unknown;
182
+ };
183
+ content: {
184
+ "application/json": {
185
+ data: {
186
+ session_id: string;
187
+ user: {
188
+ id: string;
189
+ email: string;
190
+ display_name: string;
191
+ };
192
+ last_method: string;
193
+ signed_in_at: string;
194
+ last_seen: string;
195
+ current: boolean;
196
+ }[];
197
+ };
198
+ };
199
+ };
200
+ 401: {
201
+ headers: {
202
+ [name: string]: unknown;
203
+ };
204
+ content: {
205
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
206
+ };
207
+ };
208
+ 403: {
209
+ headers: {
210
+ [name: string]: unknown;
211
+ };
212
+ content: {
213
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
214
+ };
215
+ };
216
+ };
217
+ }>;
218
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
219
+ parameters: {
220
+ query?: never;
221
+ header?: never;
222
+ path?: never;
223
+ cookie?: never;
224
+ };
225
+ requestBody?: never;
226
+ responses: {
227
+ 200: {
228
+ headers: {
229
+ [name: string]: unknown;
230
+ };
231
+ content: {
232
+ "application/json": {
233
+ data: {
234
+ session_id: string;
235
+ user: {
236
+ id: string;
237
+ email: string;
238
+ display_name: string;
239
+ };
240
+ last_method: string;
241
+ signed_in_at: string;
242
+ last_seen: string;
243
+ current: boolean;
244
+ }[];
245
+ };
246
+ };
247
+ };
248
+ 401: {
249
+ headers: {
250
+ [name: string]: unknown;
251
+ };
252
+ content: {
253
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
254
+ };
255
+ };
256
+ 403: {
257
+ headers: {
258
+ [name: string]: unknown;
259
+ };
260
+ content: {
261
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
262
+ };
263
+ };
264
+ };
265
+ }>;
266
+ pathSerializer?: import("openapi-fetch").PathSerializer;
267
+ parseAs?: import("openapi-fetch").ParseAs;
268
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
269
+ headers?: import("openapi-fetch").HeadersOptions;
270
+ middleware?: import("openapi-fetch").Middleware[];
271
+ } & Omit<RequestInit, "body" | "headers"> & {
272
+ [key: string]: unknown;
273
+ }) | undefined) => Promise<import("openapi-fetch").FetchResponse<{
274
+ parameters: {
275
+ query?: never;
276
+ header?: never;
277
+ path?: never;
278
+ cookie?: never;
279
+ };
280
+ requestBody?: never;
281
+ responses: {
282
+ 200: {
283
+ headers: {
284
+ [name: string]: unknown;
285
+ };
286
+ content: {
287
+ "application/json": {
288
+ data: {
289
+ session_id: string;
290
+ user: {
291
+ id: string;
292
+ email: string;
293
+ display_name: string;
294
+ };
295
+ last_method: string;
296
+ signed_in_at: string;
297
+ last_seen: string;
298
+ current: boolean;
299
+ }[];
300
+ };
301
+ };
302
+ };
303
+ 401: {
304
+ headers: {
305
+ [name: string]: unknown;
306
+ };
307
+ content: {
308
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
309
+ };
310
+ };
311
+ 403: {
312
+ headers: {
313
+ [name: string]: unknown;
314
+ };
315
+ content: {
316
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
317
+ };
318
+ };
319
+ };
320
+ }, ({
321
+ params?: {
322
+ query?: never;
323
+ header?: never;
324
+ path?: never;
325
+ cookie?: never;
326
+ };
327
+ } & {
328
+ body?: undefined;
329
+ } & {
330
+ baseUrl?: string;
331
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
332
+ parameters: {
333
+ query?: never;
334
+ header?: never;
335
+ path?: never;
336
+ cookie?: never;
337
+ };
338
+ requestBody?: never;
339
+ responses: {
340
+ 200: {
341
+ headers: {
342
+ [name: string]: unknown;
343
+ };
344
+ content: {
345
+ "application/json": {
346
+ data: {
347
+ session_id: string;
348
+ user: {
349
+ id: string;
350
+ email: string;
351
+ display_name: string;
352
+ };
353
+ last_method: string;
354
+ signed_in_at: string;
355
+ last_seen: string;
356
+ current: boolean;
357
+ }[];
358
+ };
359
+ };
360
+ };
361
+ 401: {
362
+ headers: {
363
+ [name: string]: unknown;
364
+ };
365
+ content: {
366
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
367
+ };
368
+ };
369
+ 403: {
370
+ headers: {
371
+ [name: string]: unknown;
372
+ };
373
+ content: {
374
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
375
+ };
376
+ };
377
+ };
378
+ }>;
379
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
380
+ parameters: {
381
+ query?: never;
382
+ header?: never;
383
+ path?: never;
384
+ cookie?: never;
385
+ };
386
+ requestBody?: never;
387
+ responses: {
388
+ 200: {
389
+ headers: {
390
+ [name: string]: unknown;
391
+ };
392
+ content: {
393
+ "application/json": {
394
+ data: {
395
+ session_id: string;
396
+ user: {
397
+ id: string;
398
+ email: string;
399
+ display_name: string;
400
+ };
401
+ last_method: string;
402
+ signed_in_at: string;
403
+ last_seen: string;
404
+ current: boolean;
405
+ }[];
406
+ };
407
+ };
408
+ };
409
+ 401: {
410
+ headers: {
411
+ [name: string]: unknown;
412
+ };
413
+ content: {
414
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
415
+ };
416
+ };
417
+ 403: {
418
+ headers: {
419
+ [name: string]: unknown;
420
+ };
421
+ content: {
422
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
423
+ };
424
+ };
425
+ };
426
+ }>;
427
+ pathSerializer?: import("openapi-fetch").PathSerializer;
428
+ parseAs?: import("openapi-fetch").ParseAs;
429
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
430
+ headers?: import("openapi-fetch").HeadersOptions;
431
+ middleware?: import("openapi-fetch").Middleware[];
432
+ } & Omit<RequestInit, "body" | "headers"> & {
433
+ [key: string]: unknown;
434
+ }) | undefined, `${string}/${string}`>>;
435
+ /** DELETE /multi-session/{sessionId}: Sign one account out of this device */
436
+ revoke: (init_0: {
437
+ params: {
438
+ query?: never;
439
+ header?: never;
440
+ path: {
441
+ sessionId: string;
442
+ };
443
+ cookie?: never;
444
+ };
445
+ } & {
446
+ body?: undefined;
447
+ } & {
448
+ baseUrl?: string;
449
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
450
+ parameters: {
451
+ query?: never;
452
+ header?: never;
453
+ path: {
454
+ sessionId: string;
455
+ };
456
+ cookie?: never;
457
+ };
458
+ requestBody?: never;
459
+ responses: {
460
+ 200: {
461
+ headers: {
462
+ [name: string]: unknown;
463
+ };
464
+ content: {
465
+ "application/json": {
466
+ data: {
467
+ status: string;
468
+ };
469
+ };
470
+ };
471
+ };
472
+ 401: {
473
+ headers: {
474
+ [name: string]: unknown;
475
+ };
476
+ content: {
477
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
478
+ };
479
+ };
480
+ 403: {
481
+ headers: {
482
+ [name: string]: unknown;
483
+ };
484
+ content: {
485
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
486
+ };
487
+ };
488
+ 404: {
489
+ headers: {
490
+ [name: string]: unknown;
491
+ };
492
+ content: {
493
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
494
+ };
495
+ };
496
+ };
497
+ }>;
498
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
499
+ parameters: {
500
+ query?: never;
501
+ header?: never;
502
+ path: {
503
+ sessionId: string;
504
+ };
505
+ cookie?: never;
506
+ };
507
+ requestBody?: never;
508
+ responses: {
509
+ 200: {
510
+ headers: {
511
+ [name: string]: unknown;
512
+ };
513
+ content: {
514
+ "application/json": {
515
+ data: {
516
+ status: string;
517
+ };
518
+ };
519
+ };
520
+ };
521
+ 401: {
522
+ headers: {
523
+ [name: string]: unknown;
524
+ };
525
+ content: {
526
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
527
+ };
528
+ };
529
+ 403: {
530
+ headers: {
531
+ [name: string]: unknown;
532
+ };
533
+ content: {
534
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
535
+ };
536
+ };
537
+ 404: {
538
+ headers: {
539
+ [name: string]: unknown;
540
+ };
541
+ content: {
542
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
543
+ };
544
+ };
545
+ };
546
+ }>;
547
+ pathSerializer?: import("openapi-fetch").PathSerializer;
548
+ parseAs?: import("openapi-fetch").ParseAs;
549
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
550
+ headers?: import("openapi-fetch").HeadersOptions;
551
+ middleware?: import("openapi-fetch").Middleware[];
552
+ } & Omit<RequestInit, "body" | "headers"> & {
553
+ [key: string]: unknown;
554
+ }) => Promise<import("openapi-fetch").FetchResponse<{
555
+ parameters: {
556
+ query?: never;
557
+ header?: never;
558
+ path: {
559
+ sessionId: string;
560
+ };
561
+ cookie?: never;
562
+ };
563
+ requestBody?: never;
564
+ responses: {
565
+ 200: {
566
+ headers: {
567
+ [name: string]: unknown;
568
+ };
569
+ content: {
570
+ "application/json": {
571
+ data: {
572
+ status: string;
573
+ };
574
+ };
575
+ };
576
+ };
577
+ 401: {
578
+ headers: {
579
+ [name: string]: unknown;
580
+ };
581
+ content: {
582
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
583
+ };
584
+ };
585
+ 403: {
586
+ headers: {
587
+ [name: string]: unknown;
588
+ };
589
+ content: {
590
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
591
+ };
592
+ };
593
+ 404: {
594
+ headers: {
595
+ [name: string]: unknown;
596
+ };
597
+ content: {
598
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
599
+ };
600
+ };
601
+ };
602
+ }, {
603
+ params: {
604
+ query?: never;
605
+ header?: never;
606
+ path: {
607
+ sessionId: string;
608
+ };
609
+ cookie?: never;
610
+ };
611
+ } & {
612
+ body?: undefined;
613
+ } & {
614
+ baseUrl?: string;
615
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
616
+ parameters: {
617
+ query?: never;
618
+ header?: never;
619
+ path: {
620
+ sessionId: string;
621
+ };
622
+ cookie?: never;
623
+ };
624
+ requestBody?: never;
625
+ responses: {
626
+ 200: {
627
+ headers: {
628
+ [name: string]: unknown;
629
+ };
630
+ content: {
631
+ "application/json": {
632
+ data: {
633
+ status: string;
634
+ };
635
+ };
636
+ };
637
+ };
638
+ 401: {
639
+ headers: {
640
+ [name: string]: unknown;
641
+ };
642
+ content: {
643
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
644
+ };
645
+ };
646
+ 403: {
647
+ headers: {
648
+ [name: string]: unknown;
649
+ };
650
+ content: {
651
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
652
+ };
653
+ };
654
+ 404: {
655
+ headers: {
656
+ [name: string]: unknown;
657
+ };
658
+ content: {
659
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
660
+ };
661
+ };
662
+ };
663
+ }>;
664
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
665
+ parameters: {
666
+ query?: never;
667
+ header?: never;
668
+ path: {
669
+ sessionId: string;
670
+ };
671
+ cookie?: never;
672
+ };
673
+ requestBody?: never;
674
+ responses: {
675
+ 200: {
676
+ headers: {
677
+ [name: string]: unknown;
678
+ };
679
+ content: {
680
+ "application/json": {
681
+ data: {
682
+ status: string;
683
+ };
684
+ };
685
+ };
686
+ };
687
+ 401: {
688
+ headers: {
689
+ [name: string]: unknown;
690
+ };
691
+ content: {
692
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
693
+ };
694
+ };
695
+ 403: {
696
+ headers: {
697
+ [name: string]: unknown;
698
+ };
699
+ content: {
700
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
701
+ };
702
+ };
703
+ 404: {
704
+ headers: {
705
+ [name: string]: unknown;
706
+ };
707
+ content: {
708
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
709
+ };
710
+ };
711
+ };
712
+ }>;
713
+ pathSerializer?: import("openapi-fetch").PathSerializer;
714
+ parseAs?: import("openapi-fetch").ParseAs;
715
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
716
+ headers?: import("openapi-fetch").HeadersOptions;
717
+ middleware?: import("openapi-fetch").Middleware[];
718
+ } & Omit<RequestInit, "body" | "headers">, `${string}/${string}`>>;
719
+ /** POST /multi-session/switch: Switch to another account signed in on this device */
720
+ switch: (init_0: {
721
+ params?: {
722
+ query?: never;
723
+ header?: never;
724
+ path?: never;
725
+ cookie?: never;
726
+ };
727
+ } & {
728
+ body: {
729
+ session_id: string;
730
+ } & {};
731
+ } & {
732
+ baseUrl?: string;
733
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
734
+ parameters: {
735
+ query?: never;
736
+ header?: never;
737
+ path?: never;
738
+ cookie?: never;
739
+ };
740
+ requestBody: {
741
+ content: {
742
+ "application/json": {
743
+ session_id: string;
744
+ };
745
+ };
746
+ };
747
+ responses: {
748
+ 200: {
749
+ headers: {
750
+ [name: string]: unknown;
751
+ };
752
+ content: {
753
+ "application/json": {
754
+ data: {
755
+ access_token: string;
756
+ token_type: string;
757
+ expires_in: number;
758
+ refresh_token: string;
759
+ user: {
760
+ id: string;
761
+ email: string;
762
+ email_verified: boolean;
763
+ };
764
+ };
765
+ };
766
+ };
767
+ };
768
+ 401: {
769
+ headers: {
770
+ [name: string]: unknown;
771
+ };
772
+ content: {
773
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
774
+ };
775
+ };
776
+ 403: {
777
+ headers: {
778
+ [name: string]: unknown;
779
+ };
780
+ content: {
781
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
782
+ };
783
+ };
784
+ 404: {
785
+ headers: {
786
+ [name: string]: unknown;
787
+ };
788
+ content: {
789
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
790
+ };
791
+ };
792
+ 422: {
793
+ headers: {
794
+ [name: string]: unknown;
795
+ };
796
+ content: {
797
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
798
+ };
799
+ };
800
+ };
801
+ }>;
802
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
803
+ parameters: {
804
+ query?: never;
805
+ header?: never;
806
+ path?: never;
807
+ cookie?: never;
808
+ };
809
+ requestBody: {
810
+ content: {
811
+ "application/json": {
812
+ session_id: string;
813
+ };
814
+ };
815
+ };
816
+ responses: {
817
+ 200: {
818
+ headers: {
819
+ [name: string]: unknown;
820
+ };
821
+ content: {
822
+ "application/json": {
823
+ data: {
824
+ access_token: string;
825
+ token_type: string;
826
+ expires_in: number;
827
+ refresh_token: string;
828
+ user: {
829
+ id: string;
830
+ email: string;
831
+ email_verified: boolean;
832
+ };
833
+ };
834
+ };
835
+ };
836
+ };
837
+ 401: {
838
+ headers: {
839
+ [name: string]: unknown;
840
+ };
841
+ content: {
842
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
843
+ };
844
+ };
845
+ 403: {
846
+ headers: {
847
+ [name: string]: unknown;
848
+ };
849
+ content: {
850
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
851
+ };
852
+ };
853
+ 404: {
854
+ headers: {
855
+ [name: string]: unknown;
856
+ };
857
+ content: {
858
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
859
+ };
860
+ };
861
+ 422: {
862
+ headers: {
863
+ [name: string]: unknown;
864
+ };
865
+ content: {
866
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
867
+ };
868
+ };
869
+ };
870
+ }>;
871
+ pathSerializer?: import("openapi-fetch").PathSerializer;
872
+ parseAs?: import("openapi-fetch").ParseAs;
873
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
874
+ headers?: import("openapi-fetch").HeadersOptions;
875
+ middleware?: import("openapi-fetch").Middleware[];
876
+ } & Omit<RequestInit, "body" | "headers"> & {
877
+ [key: string]: unknown;
878
+ }) => Promise<import("openapi-fetch").FetchResponse<{
879
+ parameters: {
880
+ query?: never;
881
+ header?: never;
882
+ path?: never;
883
+ cookie?: never;
884
+ };
885
+ requestBody: {
886
+ content: {
887
+ "application/json": {
888
+ session_id: string;
889
+ };
890
+ };
891
+ };
892
+ responses: {
893
+ 200: {
894
+ headers: {
895
+ [name: string]: unknown;
896
+ };
897
+ content: {
898
+ "application/json": {
899
+ data: {
900
+ access_token: string;
901
+ token_type: string;
902
+ expires_in: number;
903
+ refresh_token: string;
904
+ user: {
905
+ id: string;
906
+ email: string;
907
+ email_verified: boolean;
908
+ };
909
+ };
910
+ };
911
+ };
912
+ };
913
+ 401: {
914
+ headers: {
915
+ [name: string]: unknown;
916
+ };
917
+ content: {
918
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
919
+ };
920
+ };
921
+ 403: {
922
+ headers: {
923
+ [name: string]: unknown;
924
+ };
925
+ content: {
926
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
927
+ };
928
+ };
929
+ 404: {
930
+ headers: {
931
+ [name: string]: unknown;
932
+ };
933
+ content: {
934
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
935
+ };
936
+ };
937
+ 422: {
938
+ headers: {
939
+ [name: string]: unknown;
940
+ };
941
+ content: {
942
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
943
+ };
944
+ };
945
+ };
946
+ }, {
947
+ params?: {
948
+ query?: never;
949
+ header?: never;
950
+ path?: never;
951
+ cookie?: never;
952
+ };
953
+ } & {
954
+ body: {
955
+ session_id: string;
956
+ } & {};
957
+ } & {
958
+ baseUrl?: string;
959
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
960
+ parameters: {
961
+ query?: never;
962
+ header?: never;
963
+ path?: never;
964
+ cookie?: never;
965
+ };
966
+ requestBody: {
967
+ content: {
968
+ "application/json": {
969
+ session_id: string;
970
+ };
971
+ };
972
+ };
973
+ responses: {
974
+ 200: {
975
+ headers: {
976
+ [name: string]: unknown;
977
+ };
978
+ content: {
979
+ "application/json": {
980
+ data: {
981
+ access_token: string;
982
+ token_type: string;
983
+ expires_in: number;
984
+ refresh_token: string;
985
+ user: {
986
+ id: string;
987
+ email: string;
988
+ email_verified: boolean;
989
+ };
990
+ };
991
+ };
992
+ };
993
+ };
994
+ 401: {
995
+ headers: {
996
+ [name: string]: unknown;
997
+ };
998
+ content: {
999
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1000
+ };
1001
+ };
1002
+ 403: {
1003
+ headers: {
1004
+ [name: string]: unknown;
1005
+ };
1006
+ content: {
1007
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1008
+ };
1009
+ };
1010
+ 404: {
1011
+ headers: {
1012
+ [name: string]: unknown;
1013
+ };
1014
+ content: {
1015
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1016
+ };
1017
+ };
1018
+ 422: {
1019
+ headers: {
1020
+ [name: string]: unknown;
1021
+ };
1022
+ content: {
1023
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1024
+ };
1025
+ };
1026
+ };
1027
+ }>;
1028
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
1029
+ parameters: {
1030
+ query?: never;
1031
+ header?: never;
1032
+ path?: never;
1033
+ cookie?: never;
1034
+ };
1035
+ requestBody: {
1036
+ content: {
1037
+ "application/json": {
1038
+ session_id: string;
1039
+ };
1040
+ };
1041
+ };
1042
+ responses: {
1043
+ 200: {
1044
+ headers: {
1045
+ [name: string]: unknown;
1046
+ };
1047
+ content: {
1048
+ "application/json": {
1049
+ data: {
1050
+ access_token: string;
1051
+ token_type: string;
1052
+ expires_in: number;
1053
+ refresh_token: string;
1054
+ user: {
1055
+ id: string;
1056
+ email: string;
1057
+ email_verified: boolean;
1058
+ };
1059
+ };
1060
+ };
1061
+ };
1062
+ };
1063
+ 401: {
1064
+ headers: {
1065
+ [name: string]: unknown;
1066
+ };
1067
+ content: {
1068
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1069
+ };
1070
+ };
1071
+ 403: {
1072
+ headers: {
1073
+ [name: string]: unknown;
1074
+ };
1075
+ content: {
1076
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1077
+ };
1078
+ };
1079
+ 404: {
1080
+ headers: {
1081
+ [name: string]: unknown;
1082
+ };
1083
+ content: {
1084
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1085
+ };
1086
+ };
1087
+ 422: {
1088
+ headers: {
1089
+ [name: string]: unknown;
1090
+ };
1091
+ content: {
1092
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1093
+ };
1094
+ };
1095
+ };
1096
+ }>;
1097
+ pathSerializer?: import("openapi-fetch").PathSerializer;
1098
+ parseAs?: import("openapi-fetch").ParseAs;
1099
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
1100
+ headers?: import("openapi-fetch").HeadersOptions;
1101
+ middleware?: import("openapi-fetch").Middleware[];
1102
+ } & Omit<RequestInit, "body" | "headers">, `${string}/${string}`>>;
1103
+ };
1104
+ export type MultiSessionApi = ReturnType<typeof multiSession>;