@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,2028 @@
1
+ import type { Client } from "openapi-fetch";
2
+ import type { paths } from "./schema.js";
3
+ import type { Init } from "./namespace.js";
4
+ /** The `passkey` plugin's routes as methods of `client.passkey`. */
5
+ export declare function passkey(client: Client<paths>): {
6
+ /** POST /passkey/authenticate/options: Start a passkey sign-in */
7
+ authenticateOptions: (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
+ challenge: string;
35
+ rpId: string;
36
+ allowCredentials: [];
37
+ userVerification: string;
38
+ timeout: number;
39
+ };
40
+ };
41
+ };
42
+ };
43
+ };
44
+ }>;
45
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
46
+ parameters: {
47
+ query?: never;
48
+ header?: never;
49
+ path?: never;
50
+ cookie?: never;
51
+ };
52
+ requestBody?: never;
53
+ responses: {
54
+ 200: {
55
+ headers: {
56
+ [name: string]: unknown;
57
+ };
58
+ content: {
59
+ "application/json": {
60
+ data: {
61
+ challenge: string;
62
+ rpId: string;
63
+ allowCredentials: [];
64
+ userVerification: string;
65
+ timeout: number;
66
+ };
67
+ };
68
+ };
69
+ };
70
+ };
71
+ }>;
72
+ pathSerializer?: import("openapi-fetch").PathSerializer;
73
+ parseAs?: import("openapi-fetch").ParseAs;
74
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
75
+ headers?: import("openapi-fetch").HeadersOptions;
76
+ middleware?: import("openapi-fetch").Middleware[];
77
+ } & Omit<RequestInit, "body" | "headers"> & {
78
+ [key: string]: unknown;
79
+ }) | undefined) => Promise<import("openapi-fetch").FetchResponse<{
80
+ parameters: {
81
+ query?: never;
82
+ header?: never;
83
+ path?: never;
84
+ cookie?: never;
85
+ };
86
+ requestBody?: never;
87
+ responses: {
88
+ 200: {
89
+ headers: {
90
+ [name: string]: unknown;
91
+ };
92
+ content: {
93
+ "application/json": {
94
+ data: {
95
+ challenge: string;
96
+ rpId: string;
97
+ allowCredentials: [];
98
+ userVerification: string;
99
+ timeout: number;
100
+ };
101
+ };
102
+ };
103
+ };
104
+ };
105
+ }, ({
106
+ params?: {
107
+ query?: never;
108
+ header?: never;
109
+ path?: never;
110
+ cookie?: never;
111
+ };
112
+ } & {
113
+ body?: undefined;
114
+ } & {
115
+ baseUrl?: string;
116
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
117
+ parameters: {
118
+ query?: never;
119
+ header?: never;
120
+ path?: never;
121
+ cookie?: never;
122
+ };
123
+ requestBody?: never;
124
+ responses: {
125
+ 200: {
126
+ headers: {
127
+ [name: string]: unknown;
128
+ };
129
+ content: {
130
+ "application/json": {
131
+ data: {
132
+ challenge: string;
133
+ rpId: string;
134
+ allowCredentials: [];
135
+ userVerification: string;
136
+ timeout: number;
137
+ };
138
+ };
139
+ };
140
+ };
141
+ };
142
+ }>;
143
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
144
+ parameters: {
145
+ query?: never;
146
+ header?: never;
147
+ path?: never;
148
+ cookie?: never;
149
+ };
150
+ requestBody?: never;
151
+ responses: {
152
+ 200: {
153
+ headers: {
154
+ [name: string]: unknown;
155
+ };
156
+ content: {
157
+ "application/json": {
158
+ data: {
159
+ challenge: string;
160
+ rpId: string;
161
+ allowCredentials: [];
162
+ userVerification: string;
163
+ timeout: number;
164
+ };
165
+ };
166
+ };
167
+ };
168
+ };
169
+ }>;
170
+ pathSerializer?: import("openapi-fetch").PathSerializer;
171
+ parseAs?: import("openapi-fetch").ParseAs;
172
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
173
+ headers?: import("openapi-fetch").HeadersOptions;
174
+ middleware?: import("openapi-fetch").Middleware[];
175
+ } & Omit<RequestInit, "body" | "headers"> & {
176
+ [key: string]: unknown;
177
+ }) | undefined, `${string}/${string}`>>;
178
+ /** POST /passkey/authenticate/verify: Sign in with a passkey */
179
+ authenticateVerify: (init_0: {
180
+ params?: {
181
+ query?: never;
182
+ header?: never;
183
+ path?: never;
184
+ cookie?: never;
185
+ };
186
+ } & {
187
+ body: {
188
+ credential: {
189
+ [x: string]: unknown;
190
+ } & {};
191
+ } & {};
192
+ } & {
193
+ baseUrl?: string;
194
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
195
+ parameters: {
196
+ query?: never;
197
+ header?: never;
198
+ path?: never;
199
+ cookie?: never;
200
+ };
201
+ requestBody: {
202
+ content: {
203
+ "application/json": {
204
+ credential: {
205
+ [key: string]: unknown;
206
+ };
207
+ };
208
+ };
209
+ };
210
+ responses: {
211
+ 200: {
212
+ headers: {
213
+ [name: string]: unknown;
214
+ };
215
+ content: {
216
+ "application/json": {
217
+ data: {
218
+ access_token: string;
219
+ token_type: string;
220
+ expires_in: number;
221
+ refresh_token: string;
222
+ user: {
223
+ id: string;
224
+ email: string;
225
+ email_verified: boolean;
226
+ };
227
+ };
228
+ };
229
+ };
230
+ };
231
+ 403: {
232
+ headers: {
233
+ [name: string]: unknown;
234
+ };
235
+ content: {
236
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
237
+ };
238
+ };
239
+ 422: {
240
+ headers: {
241
+ [name: string]: unknown;
242
+ };
243
+ content: {
244
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
245
+ };
246
+ };
247
+ };
248
+ }>;
249
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
250
+ parameters: {
251
+ query?: never;
252
+ header?: never;
253
+ path?: never;
254
+ cookie?: never;
255
+ };
256
+ requestBody: {
257
+ content: {
258
+ "application/json": {
259
+ credential: {
260
+ [key: string]: unknown;
261
+ };
262
+ };
263
+ };
264
+ };
265
+ responses: {
266
+ 200: {
267
+ headers: {
268
+ [name: string]: unknown;
269
+ };
270
+ content: {
271
+ "application/json": {
272
+ data: {
273
+ access_token: string;
274
+ token_type: string;
275
+ expires_in: number;
276
+ refresh_token: string;
277
+ user: {
278
+ id: string;
279
+ email: string;
280
+ email_verified: boolean;
281
+ };
282
+ };
283
+ };
284
+ };
285
+ };
286
+ 403: {
287
+ headers: {
288
+ [name: string]: unknown;
289
+ };
290
+ content: {
291
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
292
+ };
293
+ };
294
+ 422: {
295
+ headers: {
296
+ [name: string]: unknown;
297
+ };
298
+ content: {
299
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
300
+ };
301
+ };
302
+ };
303
+ }>;
304
+ pathSerializer?: import("openapi-fetch").PathSerializer;
305
+ parseAs?: import("openapi-fetch").ParseAs;
306
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
307
+ headers?: import("openapi-fetch").HeadersOptions;
308
+ middleware?: import("openapi-fetch").Middleware[];
309
+ } & Omit<RequestInit, "body" | "headers"> & {
310
+ [key: string]: unknown;
311
+ }) => Promise<import("openapi-fetch").FetchResponse<{
312
+ parameters: {
313
+ query?: never;
314
+ header?: never;
315
+ path?: never;
316
+ cookie?: never;
317
+ };
318
+ requestBody: {
319
+ content: {
320
+ "application/json": {
321
+ credential: {
322
+ [key: string]: unknown;
323
+ };
324
+ };
325
+ };
326
+ };
327
+ responses: {
328
+ 200: {
329
+ headers: {
330
+ [name: string]: unknown;
331
+ };
332
+ content: {
333
+ "application/json": {
334
+ data: {
335
+ access_token: string;
336
+ token_type: string;
337
+ expires_in: number;
338
+ refresh_token: string;
339
+ user: {
340
+ id: string;
341
+ email: string;
342
+ email_verified: boolean;
343
+ };
344
+ };
345
+ };
346
+ };
347
+ };
348
+ 403: {
349
+ headers: {
350
+ [name: string]: unknown;
351
+ };
352
+ content: {
353
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
354
+ };
355
+ };
356
+ 422: {
357
+ headers: {
358
+ [name: string]: unknown;
359
+ };
360
+ content: {
361
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
362
+ };
363
+ };
364
+ };
365
+ }, {
366
+ params?: {
367
+ query?: never;
368
+ header?: never;
369
+ path?: never;
370
+ cookie?: never;
371
+ };
372
+ } & {
373
+ body: {
374
+ credential: {
375
+ [x: string]: unknown;
376
+ } & {};
377
+ } & {};
378
+ } & {
379
+ baseUrl?: string;
380
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
381
+ parameters: {
382
+ query?: never;
383
+ header?: never;
384
+ path?: never;
385
+ cookie?: never;
386
+ };
387
+ requestBody: {
388
+ content: {
389
+ "application/json": {
390
+ credential: {
391
+ [key: string]: unknown;
392
+ };
393
+ };
394
+ };
395
+ };
396
+ responses: {
397
+ 200: {
398
+ headers: {
399
+ [name: string]: unknown;
400
+ };
401
+ content: {
402
+ "application/json": {
403
+ data: {
404
+ access_token: string;
405
+ token_type: string;
406
+ expires_in: number;
407
+ refresh_token: string;
408
+ user: {
409
+ id: string;
410
+ email: string;
411
+ email_verified: boolean;
412
+ };
413
+ };
414
+ };
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
+ 422: {
426
+ headers: {
427
+ [name: string]: unknown;
428
+ };
429
+ content: {
430
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
431
+ };
432
+ };
433
+ };
434
+ }>;
435
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
436
+ parameters: {
437
+ query?: never;
438
+ header?: never;
439
+ path?: never;
440
+ cookie?: never;
441
+ };
442
+ requestBody: {
443
+ content: {
444
+ "application/json": {
445
+ credential: {
446
+ [key: string]: unknown;
447
+ };
448
+ };
449
+ };
450
+ };
451
+ responses: {
452
+ 200: {
453
+ headers: {
454
+ [name: string]: unknown;
455
+ };
456
+ content: {
457
+ "application/json": {
458
+ data: {
459
+ access_token: string;
460
+ token_type: string;
461
+ expires_in: number;
462
+ refresh_token: string;
463
+ user: {
464
+ id: string;
465
+ email: string;
466
+ email_verified: boolean;
467
+ };
468
+ };
469
+ };
470
+ };
471
+ };
472
+ 403: {
473
+ headers: {
474
+ [name: string]: unknown;
475
+ };
476
+ content: {
477
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
478
+ };
479
+ };
480
+ 422: {
481
+ headers: {
482
+ [name: string]: unknown;
483
+ };
484
+ content: {
485
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
486
+ };
487
+ };
488
+ };
489
+ }>;
490
+ pathSerializer?: import("openapi-fetch").PathSerializer;
491
+ parseAs?: import("openapi-fetch").ParseAs;
492
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
493
+ headers?: import("openapi-fetch").HeadersOptions;
494
+ middleware?: import("openapi-fetch").Middleware[];
495
+ } & Omit<RequestInit, "body" | "headers">, `${string}/${string}`>>;
496
+ /** DELETE /passkey/{id}: Remove a passkey */
497
+ delete: (init_0: {
498
+ params: {
499
+ query?: never;
500
+ header?: never;
501
+ path: {
502
+ id: string;
503
+ };
504
+ cookie?: never;
505
+ };
506
+ } & {
507
+ body?: undefined;
508
+ } & {
509
+ baseUrl?: string;
510
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
511
+ parameters: {
512
+ query?: never;
513
+ header?: never;
514
+ path: {
515
+ id: string;
516
+ };
517
+ cookie?: never;
518
+ };
519
+ requestBody?: never;
520
+ responses: {
521
+ 200: {
522
+ headers: {
523
+ [name: string]: unknown;
524
+ };
525
+ content: {
526
+ "application/json": {
527
+ data: {
528
+ status: string;
529
+ };
530
+ };
531
+ };
532
+ };
533
+ 401: {
534
+ headers: {
535
+ [name: string]: unknown;
536
+ };
537
+ content: {
538
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
539
+ };
540
+ };
541
+ 404: {
542
+ headers: {
543
+ [name: string]: unknown;
544
+ };
545
+ content: {
546
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
547
+ };
548
+ };
549
+ 409: {
550
+ headers: {
551
+ [name: string]: unknown;
552
+ };
553
+ content: {
554
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
555
+ };
556
+ };
557
+ };
558
+ }>;
559
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
560
+ parameters: {
561
+ query?: never;
562
+ header?: never;
563
+ path: {
564
+ id: string;
565
+ };
566
+ cookie?: never;
567
+ };
568
+ requestBody?: never;
569
+ responses: {
570
+ 200: {
571
+ headers: {
572
+ [name: string]: unknown;
573
+ };
574
+ content: {
575
+ "application/json": {
576
+ data: {
577
+ status: string;
578
+ };
579
+ };
580
+ };
581
+ };
582
+ 401: {
583
+ headers: {
584
+ [name: string]: unknown;
585
+ };
586
+ content: {
587
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
588
+ };
589
+ };
590
+ 404: {
591
+ headers: {
592
+ [name: string]: unknown;
593
+ };
594
+ content: {
595
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
596
+ };
597
+ };
598
+ 409: {
599
+ headers: {
600
+ [name: string]: unknown;
601
+ };
602
+ content: {
603
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
604
+ };
605
+ };
606
+ };
607
+ }>;
608
+ pathSerializer?: import("openapi-fetch").PathSerializer;
609
+ parseAs?: import("openapi-fetch").ParseAs;
610
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
611
+ headers?: import("openapi-fetch").HeadersOptions;
612
+ middleware?: import("openapi-fetch").Middleware[];
613
+ } & Omit<RequestInit, "body" | "headers"> & {
614
+ [key: string]: unknown;
615
+ }) => Promise<import("openapi-fetch").FetchResponse<{
616
+ parameters: {
617
+ query?: never;
618
+ header?: never;
619
+ path: {
620
+ id: 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
+ 404: {
647
+ headers: {
648
+ [name: string]: unknown;
649
+ };
650
+ content: {
651
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
652
+ };
653
+ };
654
+ 409: {
655
+ headers: {
656
+ [name: string]: unknown;
657
+ };
658
+ content: {
659
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
660
+ };
661
+ };
662
+ };
663
+ }, {
664
+ params: {
665
+ query?: never;
666
+ header?: never;
667
+ path: {
668
+ id: string;
669
+ };
670
+ cookie?: never;
671
+ };
672
+ } & {
673
+ body?: undefined;
674
+ } & {
675
+ baseUrl?: string;
676
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
677
+ parameters: {
678
+ query?: never;
679
+ header?: never;
680
+ path: {
681
+ id: string;
682
+ };
683
+ cookie?: never;
684
+ };
685
+ requestBody?: never;
686
+ responses: {
687
+ 200: {
688
+ headers: {
689
+ [name: string]: unknown;
690
+ };
691
+ content: {
692
+ "application/json": {
693
+ data: {
694
+ status: string;
695
+ };
696
+ };
697
+ };
698
+ };
699
+ 401: {
700
+ headers: {
701
+ [name: string]: unknown;
702
+ };
703
+ content: {
704
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
705
+ };
706
+ };
707
+ 404: {
708
+ headers: {
709
+ [name: string]: unknown;
710
+ };
711
+ content: {
712
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
713
+ };
714
+ };
715
+ 409: {
716
+ headers: {
717
+ [name: string]: unknown;
718
+ };
719
+ content: {
720
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
721
+ };
722
+ };
723
+ };
724
+ }>;
725
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
726
+ parameters: {
727
+ query?: never;
728
+ header?: never;
729
+ path: {
730
+ id: string;
731
+ };
732
+ cookie?: never;
733
+ };
734
+ requestBody?: never;
735
+ responses: {
736
+ 200: {
737
+ headers: {
738
+ [name: string]: unknown;
739
+ };
740
+ content: {
741
+ "application/json": {
742
+ data: {
743
+ status: string;
744
+ };
745
+ };
746
+ };
747
+ };
748
+ 401: {
749
+ headers: {
750
+ [name: string]: unknown;
751
+ };
752
+ content: {
753
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
754
+ };
755
+ };
756
+ 404: {
757
+ headers: {
758
+ [name: string]: unknown;
759
+ };
760
+ content: {
761
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
762
+ };
763
+ };
764
+ 409: {
765
+ headers: {
766
+ [name: string]: unknown;
767
+ };
768
+ content: {
769
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
770
+ };
771
+ };
772
+ };
773
+ }>;
774
+ pathSerializer?: import("openapi-fetch").PathSerializer;
775
+ parseAs?: import("openapi-fetch").ParseAs;
776
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
777
+ headers?: import("openapi-fetch").HeadersOptions;
778
+ middleware?: import("openapi-fetch").Middleware[];
779
+ } & Omit<RequestInit, "body" | "headers">, `${string}/${string}`>>;
780
+ /** GET /passkey/list: List your passkeys */
781
+ list: (init_0?: ({
782
+ params?: {
783
+ query?: never;
784
+ header?: never;
785
+ path?: never;
786
+ cookie?: never;
787
+ };
788
+ } & {
789
+ body?: undefined;
790
+ } & {
791
+ baseUrl?: string;
792
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
793
+ parameters: {
794
+ query?: never;
795
+ header?: never;
796
+ path?: never;
797
+ cookie?: never;
798
+ };
799
+ requestBody?: never;
800
+ responses: {
801
+ 200: {
802
+ headers: {
803
+ [name: string]: unknown;
804
+ };
805
+ content: {
806
+ "application/json": {
807
+ data: {
808
+ id: string;
809
+ name: string;
810
+ aaguid: string;
811
+ transports: string[];
812
+ backed_up: boolean;
813
+ factor_id: string;
814
+ last_used_at: string;
815
+ created_at: string;
816
+ }[];
817
+ };
818
+ };
819
+ };
820
+ 401: {
821
+ headers: {
822
+ [name: string]: unknown;
823
+ };
824
+ content: {
825
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
826
+ };
827
+ };
828
+ };
829
+ }>;
830
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
831
+ parameters: {
832
+ query?: never;
833
+ header?: never;
834
+ path?: never;
835
+ cookie?: never;
836
+ };
837
+ requestBody?: never;
838
+ responses: {
839
+ 200: {
840
+ headers: {
841
+ [name: string]: unknown;
842
+ };
843
+ content: {
844
+ "application/json": {
845
+ data: {
846
+ id: string;
847
+ name: string;
848
+ aaguid: string;
849
+ transports: string[];
850
+ backed_up: boolean;
851
+ factor_id: string;
852
+ last_used_at: string;
853
+ created_at: string;
854
+ }[];
855
+ };
856
+ };
857
+ };
858
+ 401: {
859
+ headers: {
860
+ [name: string]: unknown;
861
+ };
862
+ content: {
863
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
864
+ };
865
+ };
866
+ };
867
+ }>;
868
+ pathSerializer?: import("openapi-fetch").PathSerializer;
869
+ parseAs?: import("openapi-fetch").ParseAs;
870
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
871
+ headers?: import("openapi-fetch").HeadersOptions;
872
+ middleware?: import("openapi-fetch").Middleware[];
873
+ } & Omit<RequestInit, "body" | "headers"> & {
874
+ [key: string]: unknown;
875
+ }) | undefined) => Promise<import("openapi-fetch").FetchResponse<{
876
+ parameters: {
877
+ query?: never;
878
+ header?: never;
879
+ path?: never;
880
+ cookie?: never;
881
+ };
882
+ requestBody?: never;
883
+ responses: {
884
+ 200: {
885
+ headers: {
886
+ [name: string]: unknown;
887
+ };
888
+ content: {
889
+ "application/json": {
890
+ data: {
891
+ id: string;
892
+ name: string;
893
+ aaguid: string;
894
+ transports: string[];
895
+ backed_up: boolean;
896
+ factor_id: string;
897
+ last_used_at: string;
898
+ created_at: string;
899
+ }[];
900
+ };
901
+ };
902
+ };
903
+ 401: {
904
+ headers: {
905
+ [name: string]: unknown;
906
+ };
907
+ content: {
908
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
909
+ };
910
+ };
911
+ };
912
+ }, ({
913
+ params?: {
914
+ query?: never;
915
+ header?: never;
916
+ path?: never;
917
+ cookie?: never;
918
+ };
919
+ } & {
920
+ body?: undefined;
921
+ } & {
922
+ baseUrl?: string;
923
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
924
+ parameters: {
925
+ query?: never;
926
+ header?: never;
927
+ path?: never;
928
+ cookie?: never;
929
+ };
930
+ requestBody?: never;
931
+ responses: {
932
+ 200: {
933
+ headers: {
934
+ [name: string]: unknown;
935
+ };
936
+ content: {
937
+ "application/json": {
938
+ data: {
939
+ id: string;
940
+ name: string;
941
+ aaguid: string;
942
+ transports: string[];
943
+ backed_up: boolean;
944
+ factor_id: string;
945
+ last_used_at: string;
946
+ created_at: string;
947
+ }[];
948
+ };
949
+ };
950
+ };
951
+ 401: {
952
+ headers: {
953
+ [name: string]: unknown;
954
+ };
955
+ content: {
956
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
957
+ };
958
+ };
959
+ };
960
+ }>;
961
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
962
+ parameters: {
963
+ query?: never;
964
+ header?: never;
965
+ path?: never;
966
+ cookie?: never;
967
+ };
968
+ requestBody?: never;
969
+ responses: {
970
+ 200: {
971
+ headers: {
972
+ [name: string]: unknown;
973
+ };
974
+ content: {
975
+ "application/json": {
976
+ data: {
977
+ id: string;
978
+ name: string;
979
+ aaguid: string;
980
+ transports: string[];
981
+ backed_up: boolean;
982
+ factor_id: string;
983
+ last_used_at: string;
984
+ created_at: string;
985
+ }[];
986
+ };
987
+ };
988
+ };
989
+ 401: {
990
+ headers: {
991
+ [name: string]: unknown;
992
+ };
993
+ content: {
994
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
995
+ };
996
+ };
997
+ };
998
+ }>;
999
+ pathSerializer?: import("openapi-fetch").PathSerializer;
1000
+ parseAs?: import("openapi-fetch").ParseAs;
1001
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
1002
+ headers?: import("openapi-fetch").HeadersOptions;
1003
+ middleware?: import("openapi-fetch").Middleware[];
1004
+ } & Omit<RequestInit, "body" | "headers"> & {
1005
+ [key: string]: unknown;
1006
+ }) | undefined, `${string}/${string}`>>;
1007
+ /** POST /passkey/register/options: Start registering a passkey */
1008
+ registerOptions: (init_0?: ({
1009
+ params?: {
1010
+ query?: never;
1011
+ header?: never;
1012
+ path?: never;
1013
+ cookie?: never;
1014
+ };
1015
+ } & {
1016
+ body?: undefined;
1017
+ } & {
1018
+ baseUrl?: string;
1019
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
1020
+ parameters: {
1021
+ query?: never;
1022
+ header?: never;
1023
+ path?: never;
1024
+ cookie?: never;
1025
+ };
1026
+ requestBody?: never;
1027
+ responses: {
1028
+ 200: {
1029
+ headers: {
1030
+ [name: string]: unknown;
1031
+ };
1032
+ content: {
1033
+ "application/json": {
1034
+ data: {
1035
+ rp: {
1036
+ id: string;
1037
+ name: string;
1038
+ };
1039
+ user: {
1040
+ id: string;
1041
+ name: string;
1042
+ displayName: string;
1043
+ };
1044
+ challenge: string;
1045
+ pubKeyCredParams: {
1046
+ type: string;
1047
+ alg: number;
1048
+ }[];
1049
+ authenticatorSelection: {
1050
+ residentKey: string;
1051
+ userVerification: string;
1052
+ };
1053
+ attestation: string;
1054
+ excludeCredentials: [];
1055
+ timeout: number;
1056
+ };
1057
+ };
1058
+ };
1059
+ };
1060
+ 401: {
1061
+ headers: {
1062
+ [name: string]: unknown;
1063
+ };
1064
+ content: {
1065
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1066
+ };
1067
+ };
1068
+ };
1069
+ }>;
1070
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
1071
+ parameters: {
1072
+ query?: never;
1073
+ header?: never;
1074
+ path?: never;
1075
+ cookie?: never;
1076
+ };
1077
+ requestBody?: never;
1078
+ responses: {
1079
+ 200: {
1080
+ headers: {
1081
+ [name: string]: unknown;
1082
+ };
1083
+ content: {
1084
+ "application/json": {
1085
+ data: {
1086
+ rp: {
1087
+ id: string;
1088
+ name: string;
1089
+ };
1090
+ user: {
1091
+ id: string;
1092
+ name: string;
1093
+ displayName: string;
1094
+ };
1095
+ challenge: string;
1096
+ pubKeyCredParams: {
1097
+ type: string;
1098
+ alg: number;
1099
+ }[];
1100
+ authenticatorSelection: {
1101
+ residentKey: string;
1102
+ userVerification: string;
1103
+ };
1104
+ attestation: string;
1105
+ excludeCredentials: [];
1106
+ timeout: number;
1107
+ };
1108
+ };
1109
+ };
1110
+ };
1111
+ 401: {
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
+ }) | undefined) => Promise<import("openapi-fetch").FetchResponse<{
1129
+ parameters: {
1130
+ query?: never;
1131
+ header?: never;
1132
+ path?: never;
1133
+ cookie?: never;
1134
+ };
1135
+ requestBody?: never;
1136
+ responses: {
1137
+ 200: {
1138
+ headers: {
1139
+ [name: string]: unknown;
1140
+ };
1141
+ content: {
1142
+ "application/json": {
1143
+ data: {
1144
+ rp: {
1145
+ id: string;
1146
+ name: string;
1147
+ };
1148
+ user: {
1149
+ id: string;
1150
+ name: string;
1151
+ displayName: string;
1152
+ };
1153
+ challenge: string;
1154
+ pubKeyCredParams: {
1155
+ type: string;
1156
+ alg: number;
1157
+ }[];
1158
+ authenticatorSelection: {
1159
+ residentKey: string;
1160
+ userVerification: string;
1161
+ };
1162
+ attestation: string;
1163
+ excludeCredentials: [];
1164
+ timeout: number;
1165
+ };
1166
+ };
1167
+ };
1168
+ };
1169
+ 401: {
1170
+ headers: {
1171
+ [name: string]: unknown;
1172
+ };
1173
+ content: {
1174
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1175
+ };
1176
+ };
1177
+ };
1178
+ }, ({
1179
+ params?: {
1180
+ query?: never;
1181
+ header?: never;
1182
+ path?: never;
1183
+ cookie?: never;
1184
+ };
1185
+ } & {
1186
+ body?: undefined;
1187
+ } & {
1188
+ baseUrl?: string;
1189
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
1190
+ parameters: {
1191
+ query?: never;
1192
+ header?: never;
1193
+ path?: never;
1194
+ cookie?: never;
1195
+ };
1196
+ requestBody?: never;
1197
+ responses: {
1198
+ 200: {
1199
+ headers: {
1200
+ [name: string]: unknown;
1201
+ };
1202
+ content: {
1203
+ "application/json": {
1204
+ data: {
1205
+ rp: {
1206
+ id: string;
1207
+ name: string;
1208
+ };
1209
+ user: {
1210
+ id: string;
1211
+ name: string;
1212
+ displayName: string;
1213
+ };
1214
+ challenge: string;
1215
+ pubKeyCredParams: {
1216
+ type: string;
1217
+ alg: number;
1218
+ }[];
1219
+ authenticatorSelection: {
1220
+ residentKey: string;
1221
+ userVerification: string;
1222
+ };
1223
+ attestation: string;
1224
+ excludeCredentials: [];
1225
+ timeout: number;
1226
+ };
1227
+ };
1228
+ };
1229
+ };
1230
+ 401: {
1231
+ headers: {
1232
+ [name: string]: unknown;
1233
+ };
1234
+ content: {
1235
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1236
+ };
1237
+ };
1238
+ };
1239
+ }>;
1240
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
1241
+ parameters: {
1242
+ query?: never;
1243
+ header?: never;
1244
+ path?: never;
1245
+ cookie?: never;
1246
+ };
1247
+ requestBody?: never;
1248
+ responses: {
1249
+ 200: {
1250
+ headers: {
1251
+ [name: string]: unknown;
1252
+ };
1253
+ content: {
1254
+ "application/json": {
1255
+ data: {
1256
+ rp: {
1257
+ id: string;
1258
+ name: string;
1259
+ };
1260
+ user: {
1261
+ id: string;
1262
+ name: string;
1263
+ displayName: string;
1264
+ };
1265
+ challenge: string;
1266
+ pubKeyCredParams: {
1267
+ type: string;
1268
+ alg: number;
1269
+ }[];
1270
+ authenticatorSelection: {
1271
+ residentKey: string;
1272
+ userVerification: string;
1273
+ };
1274
+ attestation: string;
1275
+ excludeCredentials: [];
1276
+ timeout: number;
1277
+ };
1278
+ };
1279
+ };
1280
+ };
1281
+ 401: {
1282
+ headers: {
1283
+ [name: string]: unknown;
1284
+ };
1285
+ content: {
1286
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1287
+ };
1288
+ };
1289
+ };
1290
+ }>;
1291
+ pathSerializer?: import("openapi-fetch").PathSerializer;
1292
+ parseAs?: import("openapi-fetch").ParseAs;
1293
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
1294
+ headers?: import("openapi-fetch").HeadersOptions;
1295
+ middleware?: import("openapi-fetch").Middleware[];
1296
+ } & Omit<RequestInit, "body" | "headers"> & {
1297
+ [key: string]: unknown;
1298
+ }) | undefined, `${string}/${string}`>>;
1299
+ /** POST /passkey/register/verify: Finish registering a passkey */
1300
+ registerVerify: (init_0: {
1301
+ params?: {
1302
+ query?: never;
1303
+ header?: never;
1304
+ path?: never;
1305
+ cookie?: never;
1306
+ };
1307
+ } & {
1308
+ body: {
1309
+ credential: {
1310
+ [x: string]: unknown;
1311
+ } & {};
1312
+ name?: string;
1313
+ } & {};
1314
+ } & {
1315
+ baseUrl?: string;
1316
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
1317
+ parameters: {
1318
+ query?: never;
1319
+ header?: never;
1320
+ path?: never;
1321
+ cookie?: never;
1322
+ };
1323
+ requestBody: {
1324
+ content: {
1325
+ "application/json": {
1326
+ credential: {
1327
+ [key: string]: unknown;
1328
+ };
1329
+ name?: string;
1330
+ };
1331
+ };
1332
+ };
1333
+ responses: {
1334
+ 201: {
1335
+ headers: {
1336
+ [name: string]: unknown;
1337
+ };
1338
+ content: {
1339
+ "application/json": {
1340
+ data: {
1341
+ passkey: {
1342
+ id: string;
1343
+ name: string;
1344
+ aaguid: string;
1345
+ transports: string[];
1346
+ backed_up: boolean;
1347
+ factor_id: string;
1348
+ last_used_at: string | null;
1349
+ created_at: string;
1350
+ };
1351
+ recovery_codes: string[];
1352
+ };
1353
+ };
1354
+ };
1355
+ };
1356
+ 401: {
1357
+ headers: {
1358
+ [name: string]: unknown;
1359
+ };
1360
+ content: {
1361
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1362
+ };
1363
+ };
1364
+ 403: {
1365
+ headers: {
1366
+ [name: string]: unknown;
1367
+ };
1368
+ content: {
1369
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1370
+ };
1371
+ };
1372
+ 422: {
1373
+ headers: {
1374
+ [name: string]: unknown;
1375
+ };
1376
+ content: {
1377
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1378
+ };
1379
+ };
1380
+ };
1381
+ }>;
1382
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
1383
+ parameters: {
1384
+ query?: never;
1385
+ header?: never;
1386
+ path?: never;
1387
+ cookie?: never;
1388
+ };
1389
+ requestBody: {
1390
+ content: {
1391
+ "application/json": {
1392
+ credential: {
1393
+ [key: string]: unknown;
1394
+ };
1395
+ name?: string;
1396
+ };
1397
+ };
1398
+ };
1399
+ responses: {
1400
+ 201: {
1401
+ headers: {
1402
+ [name: string]: unknown;
1403
+ };
1404
+ content: {
1405
+ "application/json": {
1406
+ data: {
1407
+ passkey: {
1408
+ id: string;
1409
+ name: string;
1410
+ aaguid: string;
1411
+ transports: string[];
1412
+ backed_up: boolean;
1413
+ factor_id: string;
1414
+ last_used_at: string | null;
1415
+ created_at: string;
1416
+ };
1417
+ recovery_codes: string[];
1418
+ };
1419
+ };
1420
+ };
1421
+ };
1422
+ 401: {
1423
+ headers: {
1424
+ [name: string]: unknown;
1425
+ };
1426
+ content: {
1427
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1428
+ };
1429
+ };
1430
+ 403: {
1431
+ headers: {
1432
+ [name: string]: unknown;
1433
+ };
1434
+ content: {
1435
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1436
+ };
1437
+ };
1438
+ 422: {
1439
+ headers: {
1440
+ [name: string]: unknown;
1441
+ };
1442
+ content: {
1443
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1444
+ };
1445
+ };
1446
+ };
1447
+ }>;
1448
+ pathSerializer?: import("openapi-fetch").PathSerializer;
1449
+ parseAs?: import("openapi-fetch").ParseAs;
1450
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
1451
+ headers?: import("openapi-fetch").HeadersOptions;
1452
+ middleware?: import("openapi-fetch").Middleware[];
1453
+ } & Omit<RequestInit, "body" | "headers"> & {
1454
+ [key: string]: unknown;
1455
+ }) => Promise<import("openapi-fetch").FetchResponse<{
1456
+ parameters: {
1457
+ query?: never;
1458
+ header?: never;
1459
+ path?: never;
1460
+ cookie?: never;
1461
+ };
1462
+ requestBody: {
1463
+ content: {
1464
+ "application/json": {
1465
+ credential: {
1466
+ [key: string]: unknown;
1467
+ };
1468
+ name?: string;
1469
+ };
1470
+ };
1471
+ };
1472
+ responses: {
1473
+ 201: {
1474
+ headers: {
1475
+ [name: string]: unknown;
1476
+ };
1477
+ content: {
1478
+ "application/json": {
1479
+ data: {
1480
+ passkey: {
1481
+ id: string;
1482
+ name: string;
1483
+ aaguid: string;
1484
+ transports: string[];
1485
+ backed_up: boolean;
1486
+ factor_id: string;
1487
+ last_used_at: string | null;
1488
+ created_at: string;
1489
+ };
1490
+ recovery_codes: string[];
1491
+ };
1492
+ };
1493
+ };
1494
+ };
1495
+ 401: {
1496
+ headers: {
1497
+ [name: string]: unknown;
1498
+ };
1499
+ content: {
1500
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1501
+ };
1502
+ };
1503
+ 403: {
1504
+ headers: {
1505
+ [name: string]: unknown;
1506
+ };
1507
+ content: {
1508
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1509
+ };
1510
+ };
1511
+ 422: {
1512
+ headers: {
1513
+ [name: string]: unknown;
1514
+ };
1515
+ content: {
1516
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1517
+ };
1518
+ };
1519
+ };
1520
+ }, {
1521
+ params?: {
1522
+ query?: never;
1523
+ header?: never;
1524
+ path?: never;
1525
+ cookie?: never;
1526
+ };
1527
+ } & {
1528
+ body: {
1529
+ credential: {
1530
+ [x: string]: unknown;
1531
+ } & {};
1532
+ name?: string;
1533
+ } & {};
1534
+ } & {
1535
+ baseUrl?: string;
1536
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
1537
+ parameters: {
1538
+ query?: never;
1539
+ header?: never;
1540
+ path?: never;
1541
+ cookie?: never;
1542
+ };
1543
+ requestBody: {
1544
+ content: {
1545
+ "application/json": {
1546
+ credential: {
1547
+ [key: string]: unknown;
1548
+ };
1549
+ name?: string;
1550
+ };
1551
+ };
1552
+ };
1553
+ responses: {
1554
+ 201: {
1555
+ headers: {
1556
+ [name: string]: unknown;
1557
+ };
1558
+ content: {
1559
+ "application/json": {
1560
+ data: {
1561
+ passkey: {
1562
+ id: string;
1563
+ name: string;
1564
+ aaguid: string;
1565
+ transports: string[];
1566
+ backed_up: boolean;
1567
+ factor_id: string;
1568
+ last_used_at: string | null;
1569
+ created_at: string;
1570
+ };
1571
+ recovery_codes: string[];
1572
+ };
1573
+ };
1574
+ };
1575
+ };
1576
+ 401: {
1577
+ headers: {
1578
+ [name: string]: unknown;
1579
+ };
1580
+ content: {
1581
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1582
+ };
1583
+ };
1584
+ 403: {
1585
+ headers: {
1586
+ [name: string]: unknown;
1587
+ };
1588
+ content: {
1589
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1590
+ };
1591
+ };
1592
+ 422: {
1593
+ headers: {
1594
+ [name: string]: unknown;
1595
+ };
1596
+ content: {
1597
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1598
+ };
1599
+ };
1600
+ };
1601
+ }>;
1602
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
1603
+ parameters: {
1604
+ query?: never;
1605
+ header?: never;
1606
+ path?: never;
1607
+ cookie?: never;
1608
+ };
1609
+ requestBody: {
1610
+ content: {
1611
+ "application/json": {
1612
+ credential: {
1613
+ [key: string]: unknown;
1614
+ };
1615
+ name?: string;
1616
+ };
1617
+ };
1618
+ };
1619
+ responses: {
1620
+ 201: {
1621
+ headers: {
1622
+ [name: string]: unknown;
1623
+ };
1624
+ content: {
1625
+ "application/json": {
1626
+ data: {
1627
+ passkey: {
1628
+ id: string;
1629
+ name: string;
1630
+ aaguid: string;
1631
+ transports: string[];
1632
+ backed_up: boolean;
1633
+ factor_id: string;
1634
+ last_used_at: string | null;
1635
+ created_at: string;
1636
+ };
1637
+ recovery_codes: string[];
1638
+ };
1639
+ };
1640
+ };
1641
+ };
1642
+ 401: {
1643
+ headers: {
1644
+ [name: string]: unknown;
1645
+ };
1646
+ content: {
1647
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1648
+ };
1649
+ };
1650
+ 403: {
1651
+ headers: {
1652
+ [name: string]: unknown;
1653
+ };
1654
+ content: {
1655
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1656
+ };
1657
+ };
1658
+ 422: {
1659
+ headers: {
1660
+ [name: string]: unknown;
1661
+ };
1662
+ content: {
1663
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1664
+ };
1665
+ };
1666
+ };
1667
+ }>;
1668
+ pathSerializer?: import("openapi-fetch").PathSerializer;
1669
+ parseAs?: import("openapi-fetch").ParseAs;
1670
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
1671
+ headers?: import("openapi-fetch").HeadersOptions;
1672
+ middleware?: import("openapi-fetch").Middleware[];
1673
+ } & Omit<RequestInit, "body" | "headers">, `${string}/${string}`>>;
1674
+ /** PATCH /passkey/{id}: Rename a passkey */
1675
+ rename: (init_0: {
1676
+ params: {
1677
+ query?: never;
1678
+ header?: never;
1679
+ path: {
1680
+ id: string;
1681
+ };
1682
+ cookie?: never;
1683
+ };
1684
+ } & {
1685
+ body: {
1686
+ name: string;
1687
+ } & {};
1688
+ } & {
1689
+ baseUrl?: string;
1690
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
1691
+ parameters: {
1692
+ query?: never;
1693
+ header?: never;
1694
+ path: {
1695
+ id: string;
1696
+ };
1697
+ cookie?: never;
1698
+ };
1699
+ requestBody: {
1700
+ content: {
1701
+ "application/json": {
1702
+ name: string;
1703
+ };
1704
+ };
1705
+ };
1706
+ responses: {
1707
+ 200: {
1708
+ headers: {
1709
+ [name: string]: unknown;
1710
+ };
1711
+ content: {
1712
+ "application/json": {
1713
+ data: {
1714
+ id: string;
1715
+ name: string;
1716
+ aaguid: string;
1717
+ transports: string[];
1718
+ backed_up: boolean;
1719
+ factor_id: string;
1720
+ last_used_at: string | null;
1721
+ created_at: string;
1722
+ };
1723
+ };
1724
+ };
1725
+ };
1726
+ 401: {
1727
+ headers: {
1728
+ [name: string]: unknown;
1729
+ };
1730
+ content: {
1731
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1732
+ };
1733
+ };
1734
+ 404: {
1735
+ headers: {
1736
+ [name: string]: unknown;
1737
+ };
1738
+ content: {
1739
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1740
+ };
1741
+ };
1742
+ 422: {
1743
+ headers: {
1744
+ [name: string]: unknown;
1745
+ };
1746
+ content: {
1747
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1748
+ };
1749
+ };
1750
+ };
1751
+ }>;
1752
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
1753
+ parameters: {
1754
+ query?: never;
1755
+ header?: never;
1756
+ path: {
1757
+ id: string;
1758
+ };
1759
+ cookie?: never;
1760
+ };
1761
+ requestBody: {
1762
+ content: {
1763
+ "application/json": {
1764
+ name: string;
1765
+ };
1766
+ };
1767
+ };
1768
+ responses: {
1769
+ 200: {
1770
+ headers: {
1771
+ [name: string]: unknown;
1772
+ };
1773
+ content: {
1774
+ "application/json": {
1775
+ data: {
1776
+ id: string;
1777
+ name: string;
1778
+ aaguid: string;
1779
+ transports: string[];
1780
+ backed_up: boolean;
1781
+ factor_id: string;
1782
+ last_used_at: string | null;
1783
+ created_at: string;
1784
+ };
1785
+ };
1786
+ };
1787
+ };
1788
+ 401: {
1789
+ headers: {
1790
+ [name: string]: unknown;
1791
+ };
1792
+ content: {
1793
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1794
+ };
1795
+ };
1796
+ 404: {
1797
+ headers: {
1798
+ [name: string]: unknown;
1799
+ };
1800
+ content: {
1801
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1802
+ };
1803
+ };
1804
+ 422: {
1805
+ headers: {
1806
+ [name: string]: unknown;
1807
+ };
1808
+ content: {
1809
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1810
+ };
1811
+ };
1812
+ };
1813
+ }>;
1814
+ pathSerializer?: import("openapi-fetch").PathSerializer;
1815
+ parseAs?: import("openapi-fetch").ParseAs;
1816
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
1817
+ headers?: import("openapi-fetch").HeadersOptions;
1818
+ middleware?: import("openapi-fetch").Middleware[];
1819
+ } & Omit<RequestInit, "body" | "headers"> & {
1820
+ [key: string]: unknown;
1821
+ }) => Promise<import("openapi-fetch").FetchResponse<{
1822
+ parameters: {
1823
+ query?: never;
1824
+ header?: never;
1825
+ path: {
1826
+ id: string;
1827
+ };
1828
+ cookie?: never;
1829
+ };
1830
+ requestBody: {
1831
+ content: {
1832
+ "application/json": {
1833
+ name: string;
1834
+ };
1835
+ };
1836
+ };
1837
+ responses: {
1838
+ 200: {
1839
+ headers: {
1840
+ [name: string]: unknown;
1841
+ };
1842
+ content: {
1843
+ "application/json": {
1844
+ data: {
1845
+ id: string;
1846
+ name: string;
1847
+ aaguid: string;
1848
+ transports: string[];
1849
+ backed_up: boolean;
1850
+ factor_id: string;
1851
+ last_used_at: string | null;
1852
+ created_at: string;
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
+ 404: {
1866
+ headers: {
1867
+ [name: string]: unknown;
1868
+ };
1869
+ content: {
1870
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1871
+ };
1872
+ };
1873
+ 422: {
1874
+ headers: {
1875
+ [name: string]: unknown;
1876
+ };
1877
+ content: {
1878
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1879
+ };
1880
+ };
1881
+ };
1882
+ }, {
1883
+ params: {
1884
+ query?: never;
1885
+ header?: never;
1886
+ path: {
1887
+ id: string;
1888
+ };
1889
+ cookie?: never;
1890
+ };
1891
+ } & {
1892
+ body: {
1893
+ name: string;
1894
+ } & {};
1895
+ } & {
1896
+ baseUrl?: string;
1897
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
1898
+ parameters: {
1899
+ query?: never;
1900
+ header?: never;
1901
+ path: {
1902
+ id: string;
1903
+ };
1904
+ cookie?: never;
1905
+ };
1906
+ requestBody: {
1907
+ content: {
1908
+ "application/json": {
1909
+ name: string;
1910
+ };
1911
+ };
1912
+ };
1913
+ responses: {
1914
+ 200: {
1915
+ headers: {
1916
+ [name: string]: unknown;
1917
+ };
1918
+ content: {
1919
+ "application/json": {
1920
+ data: {
1921
+ id: string;
1922
+ name: string;
1923
+ aaguid: string;
1924
+ transports: string[];
1925
+ backed_up: boolean;
1926
+ factor_id: string;
1927
+ last_used_at: string | null;
1928
+ created_at: string;
1929
+ };
1930
+ };
1931
+ };
1932
+ };
1933
+ 401: {
1934
+ headers: {
1935
+ [name: string]: unknown;
1936
+ };
1937
+ content: {
1938
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1939
+ };
1940
+ };
1941
+ 404: {
1942
+ headers: {
1943
+ [name: string]: unknown;
1944
+ };
1945
+ content: {
1946
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1947
+ };
1948
+ };
1949
+ 422: {
1950
+ headers: {
1951
+ [name: string]: unknown;
1952
+ };
1953
+ content: {
1954
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1955
+ };
1956
+ };
1957
+ };
1958
+ }>;
1959
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
1960
+ parameters: {
1961
+ query?: never;
1962
+ header?: never;
1963
+ path: {
1964
+ id: string;
1965
+ };
1966
+ cookie?: never;
1967
+ };
1968
+ requestBody: {
1969
+ content: {
1970
+ "application/json": {
1971
+ name: string;
1972
+ };
1973
+ };
1974
+ };
1975
+ responses: {
1976
+ 200: {
1977
+ headers: {
1978
+ [name: string]: unknown;
1979
+ };
1980
+ content: {
1981
+ "application/json": {
1982
+ data: {
1983
+ id: string;
1984
+ name: string;
1985
+ aaguid: string;
1986
+ transports: string[];
1987
+ backed_up: boolean;
1988
+ factor_id: string;
1989
+ last_used_at: string | null;
1990
+ created_at: string;
1991
+ };
1992
+ };
1993
+ };
1994
+ };
1995
+ 401: {
1996
+ headers: {
1997
+ [name: string]: unknown;
1998
+ };
1999
+ content: {
2000
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2001
+ };
2002
+ };
2003
+ 404: {
2004
+ headers: {
2005
+ [name: string]: unknown;
2006
+ };
2007
+ content: {
2008
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2009
+ };
2010
+ };
2011
+ 422: {
2012
+ headers: {
2013
+ [name: string]: unknown;
2014
+ };
2015
+ content: {
2016
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
2017
+ };
2018
+ };
2019
+ };
2020
+ }>;
2021
+ pathSerializer?: import("openapi-fetch").PathSerializer;
2022
+ parseAs?: import("openapi-fetch").ParseAs;
2023
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
2024
+ headers?: import("openapi-fetch").HeadersOptions;
2025
+ middleware?: import("openapi-fetch").Middleware[];
2026
+ } & Omit<RequestInit, "body" | "headers">, `${string}/${string}`>>;
2027
+ };
2028
+ export type PasskeyApi = ReturnType<typeof passkey>;