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