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