@polaris-auth/client 0.0.0-stage → 0.6.1

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,1564 @@
1
+ import type { Client } from "openapi-fetch";
2
+ import type { paths } from "./schema.js";
3
+ import type { Init } from "./namespace.js";
4
+ /** The `sentinel` plugin's routes as methods of `client.sentinel`. */
5
+ export declare function sentinel(client: Client<paths>): {
6
+ /** POST /admin/sentinel/ip-rules: Add an IP rule */
7
+ createIpRule: (init_0: {
8
+ params?: {
9
+ query?: never;
10
+ header?: never;
11
+ path?: never;
12
+ cookie?: never;
13
+ };
14
+ } & {
15
+ body: {
16
+ cidr: string;
17
+ action: string;
18
+ note?: string;
19
+ } & {};
20
+ } & {
21
+ baseUrl?: string;
22
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
23
+ parameters: {
24
+ query?: never;
25
+ header?: never;
26
+ path?: never;
27
+ cookie?: never;
28
+ };
29
+ requestBody: {
30
+ content: {
31
+ "application/json": {
32
+ cidr: string;
33
+ action: string;
34
+ note?: string;
35
+ };
36
+ };
37
+ };
38
+ responses: {
39
+ 201: {
40
+ headers: {
41
+ [name: string]: unknown;
42
+ };
43
+ content: {
44
+ "application/json": {
45
+ data: {
46
+ id: string;
47
+ cidr: string;
48
+ action: string;
49
+ note: string;
50
+ created_by: string;
51
+ created_at: string;
52
+ };
53
+ };
54
+ };
55
+ };
56
+ 401: {
57
+ headers: {
58
+ [name: string]: unknown;
59
+ };
60
+ content: {
61
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
62
+ };
63
+ };
64
+ 403: {
65
+ headers: {
66
+ [name: string]: unknown;
67
+ };
68
+ content: {
69
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
70
+ };
71
+ };
72
+ 422: {
73
+ headers: {
74
+ [name: string]: unknown;
75
+ };
76
+ content: {
77
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
78
+ };
79
+ };
80
+ };
81
+ }>;
82
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
83
+ parameters: {
84
+ query?: never;
85
+ header?: never;
86
+ path?: never;
87
+ cookie?: never;
88
+ };
89
+ requestBody: {
90
+ content: {
91
+ "application/json": {
92
+ cidr: string;
93
+ action: string;
94
+ note?: string;
95
+ };
96
+ };
97
+ };
98
+ responses: {
99
+ 201: {
100
+ headers: {
101
+ [name: string]: unknown;
102
+ };
103
+ content: {
104
+ "application/json": {
105
+ data: {
106
+ id: string;
107
+ cidr: string;
108
+ action: string;
109
+ note: string;
110
+ created_by: string;
111
+ created_at: string;
112
+ };
113
+ };
114
+ };
115
+ };
116
+ 401: {
117
+ headers: {
118
+ [name: string]: unknown;
119
+ };
120
+ content: {
121
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
122
+ };
123
+ };
124
+ 403: {
125
+ headers: {
126
+ [name: string]: unknown;
127
+ };
128
+ content: {
129
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
130
+ };
131
+ };
132
+ 422: {
133
+ headers: {
134
+ [name: string]: unknown;
135
+ };
136
+ content: {
137
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
138
+ };
139
+ };
140
+ };
141
+ }>;
142
+ pathSerializer?: import("openapi-fetch").PathSerializer;
143
+ parseAs?: import("openapi-fetch").ParseAs;
144
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
145
+ headers?: import("openapi-fetch").HeadersOptions;
146
+ middleware?: import("openapi-fetch").Middleware[];
147
+ } & Omit<RequestInit, "body" | "headers"> & {
148
+ [key: string]: unknown;
149
+ }) => Promise<import("openapi-fetch").FetchResponse<{
150
+ parameters: {
151
+ query?: never;
152
+ header?: never;
153
+ path?: never;
154
+ cookie?: never;
155
+ };
156
+ requestBody: {
157
+ content: {
158
+ "application/json": {
159
+ cidr: string;
160
+ action: string;
161
+ note?: string;
162
+ };
163
+ };
164
+ };
165
+ responses: {
166
+ 201: {
167
+ headers: {
168
+ [name: string]: unknown;
169
+ };
170
+ content: {
171
+ "application/json": {
172
+ data: {
173
+ id: string;
174
+ cidr: string;
175
+ action: string;
176
+ note: string;
177
+ created_by: string;
178
+ created_at: string;
179
+ };
180
+ };
181
+ };
182
+ };
183
+ 401: {
184
+ headers: {
185
+ [name: string]: unknown;
186
+ };
187
+ content: {
188
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
189
+ };
190
+ };
191
+ 403: {
192
+ headers: {
193
+ [name: string]: unknown;
194
+ };
195
+ content: {
196
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
197
+ };
198
+ };
199
+ 422: {
200
+ headers: {
201
+ [name: string]: unknown;
202
+ };
203
+ content: {
204
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
205
+ };
206
+ };
207
+ };
208
+ }, {
209
+ params?: {
210
+ query?: never;
211
+ header?: never;
212
+ path?: never;
213
+ cookie?: never;
214
+ };
215
+ } & {
216
+ body: {
217
+ cidr: string;
218
+ action: string;
219
+ note?: string;
220
+ } & {};
221
+ } & {
222
+ baseUrl?: string;
223
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
224
+ parameters: {
225
+ query?: never;
226
+ header?: never;
227
+ path?: never;
228
+ cookie?: never;
229
+ };
230
+ requestBody: {
231
+ content: {
232
+ "application/json": {
233
+ cidr: string;
234
+ action: string;
235
+ note?: string;
236
+ };
237
+ };
238
+ };
239
+ responses: {
240
+ 201: {
241
+ headers: {
242
+ [name: string]: unknown;
243
+ };
244
+ content: {
245
+ "application/json": {
246
+ data: {
247
+ id: string;
248
+ cidr: string;
249
+ action: string;
250
+ note: string;
251
+ created_by: string;
252
+ created_at: string;
253
+ };
254
+ };
255
+ };
256
+ };
257
+ 401: {
258
+ headers: {
259
+ [name: string]: unknown;
260
+ };
261
+ content: {
262
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
263
+ };
264
+ };
265
+ 403: {
266
+ headers: {
267
+ [name: string]: unknown;
268
+ };
269
+ content: {
270
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
271
+ };
272
+ };
273
+ 422: {
274
+ headers: {
275
+ [name: string]: unknown;
276
+ };
277
+ content: {
278
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
279
+ };
280
+ };
281
+ };
282
+ }>;
283
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
284
+ parameters: {
285
+ query?: never;
286
+ header?: never;
287
+ path?: never;
288
+ cookie?: never;
289
+ };
290
+ requestBody: {
291
+ content: {
292
+ "application/json": {
293
+ cidr: string;
294
+ action: string;
295
+ note?: string;
296
+ };
297
+ };
298
+ };
299
+ responses: {
300
+ 201: {
301
+ headers: {
302
+ [name: string]: unknown;
303
+ };
304
+ content: {
305
+ "application/json": {
306
+ data: {
307
+ id: string;
308
+ cidr: string;
309
+ action: string;
310
+ note: string;
311
+ created_by: string;
312
+ created_at: string;
313
+ };
314
+ };
315
+ };
316
+ };
317
+ 401: {
318
+ headers: {
319
+ [name: string]: unknown;
320
+ };
321
+ content: {
322
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
323
+ };
324
+ };
325
+ 403: {
326
+ headers: {
327
+ [name: string]: unknown;
328
+ };
329
+ content: {
330
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
331
+ };
332
+ };
333
+ 422: {
334
+ headers: {
335
+ [name: string]: unknown;
336
+ };
337
+ content: {
338
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
339
+ };
340
+ };
341
+ };
342
+ }>;
343
+ pathSerializer?: import("openapi-fetch").PathSerializer;
344
+ parseAs?: import("openapi-fetch").ParseAs;
345
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
346
+ headers?: import("openapi-fetch").HeadersOptions;
347
+ middleware?: import("openapi-fetch").Middleware[];
348
+ } & Omit<RequestInit, "body" | "headers">, `${string}/${string}`>>;
349
+ /** DELETE /admin/sentinel/ip-rules/{id}: Remove an IP rule */
350
+ deleteIpRule: (init_0: {
351
+ params: {
352
+ query?: never;
353
+ header?: never;
354
+ path: {
355
+ id: string;
356
+ };
357
+ cookie?: never;
358
+ };
359
+ } & {
360
+ body?: undefined;
361
+ } & {
362
+ baseUrl?: string;
363
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
364
+ parameters: {
365
+ query?: never;
366
+ header?: never;
367
+ path: {
368
+ id: string;
369
+ };
370
+ cookie?: never;
371
+ };
372
+ requestBody?: never;
373
+ responses: {
374
+ 200: {
375
+ headers: {
376
+ [name: string]: unknown;
377
+ };
378
+ content: {
379
+ "application/json": {
380
+ data: {
381
+ status: string;
382
+ };
383
+ };
384
+ };
385
+ };
386
+ 401: {
387
+ headers: {
388
+ [name: string]: unknown;
389
+ };
390
+ content: {
391
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
392
+ };
393
+ };
394
+ 403: {
395
+ headers: {
396
+ [name: string]: unknown;
397
+ };
398
+ content: {
399
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
400
+ };
401
+ };
402
+ 404: {
403
+ headers: {
404
+ [name: string]: unknown;
405
+ };
406
+ content: {
407
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
408
+ };
409
+ };
410
+ };
411
+ }>;
412
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
413
+ parameters: {
414
+ query?: never;
415
+ header?: never;
416
+ path: {
417
+ id: string;
418
+ };
419
+ cookie?: never;
420
+ };
421
+ requestBody?: never;
422
+ responses: {
423
+ 200: {
424
+ headers: {
425
+ [name: string]: unknown;
426
+ };
427
+ content: {
428
+ "application/json": {
429
+ data: {
430
+ status: string;
431
+ };
432
+ };
433
+ };
434
+ };
435
+ 401: {
436
+ headers: {
437
+ [name: string]: unknown;
438
+ };
439
+ content: {
440
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
441
+ };
442
+ };
443
+ 403: {
444
+ headers: {
445
+ [name: string]: unknown;
446
+ };
447
+ content: {
448
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
449
+ };
450
+ };
451
+ 404: {
452
+ headers: {
453
+ [name: string]: unknown;
454
+ };
455
+ content: {
456
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
457
+ };
458
+ };
459
+ };
460
+ }>;
461
+ pathSerializer?: import("openapi-fetch").PathSerializer;
462
+ parseAs?: import("openapi-fetch").ParseAs;
463
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
464
+ headers?: import("openapi-fetch").HeadersOptions;
465
+ middleware?: import("openapi-fetch").Middleware[];
466
+ } & Omit<RequestInit, "body" | "headers"> & {
467
+ [key: string]: unknown;
468
+ }) => Promise<import("openapi-fetch").FetchResponse<{
469
+ parameters: {
470
+ query?: never;
471
+ header?: never;
472
+ path: {
473
+ id: string;
474
+ };
475
+ cookie?: never;
476
+ };
477
+ requestBody?: never;
478
+ responses: {
479
+ 200: {
480
+ headers: {
481
+ [name: string]: unknown;
482
+ };
483
+ content: {
484
+ "application/json": {
485
+ data: {
486
+ status: string;
487
+ };
488
+ };
489
+ };
490
+ };
491
+ 401: {
492
+ headers: {
493
+ [name: string]: unknown;
494
+ };
495
+ content: {
496
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
497
+ };
498
+ };
499
+ 403: {
500
+ headers: {
501
+ [name: string]: unknown;
502
+ };
503
+ content: {
504
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
505
+ };
506
+ };
507
+ 404: {
508
+ headers: {
509
+ [name: string]: unknown;
510
+ };
511
+ content: {
512
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
513
+ };
514
+ };
515
+ };
516
+ }, {
517
+ params: {
518
+ query?: never;
519
+ header?: never;
520
+ path: {
521
+ id: string;
522
+ };
523
+ cookie?: never;
524
+ };
525
+ } & {
526
+ body?: undefined;
527
+ } & {
528
+ baseUrl?: string;
529
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
530
+ parameters: {
531
+ query?: never;
532
+ header?: never;
533
+ path: {
534
+ id: string;
535
+ };
536
+ cookie?: never;
537
+ };
538
+ requestBody?: never;
539
+ responses: {
540
+ 200: {
541
+ headers: {
542
+ [name: string]: unknown;
543
+ };
544
+ content: {
545
+ "application/json": {
546
+ data: {
547
+ status: string;
548
+ };
549
+ };
550
+ };
551
+ };
552
+ 401: {
553
+ headers: {
554
+ [name: string]: unknown;
555
+ };
556
+ content: {
557
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
558
+ };
559
+ };
560
+ 403: {
561
+ headers: {
562
+ [name: string]: unknown;
563
+ };
564
+ content: {
565
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
566
+ };
567
+ };
568
+ 404: {
569
+ headers: {
570
+ [name: string]: unknown;
571
+ };
572
+ content: {
573
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
574
+ };
575
+ };
576
+ };
577
+ }>;
578
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
579
+ parameters: {
580
+ query?: never;
581
+ header?: never;
582
+ path: {
583
+ id: string;
584
+ };
585
+ cookie?: never;
586
+ };
587
+ requestBody?: never;
588
+ responses: {
589
+ 200: {
590
+ headers: {
591
+ [name: string]: unknown;
592
+ };
593
+ content: {
594
+ "application/json": {
595
+ data: {
596
+ status: string;
597
+ };
598
+ };
599
+ };
600
+ };
601
+ 401: {
602
+ headers: {
603
+ [name: string]: unknown;
604
+ };
605
+ content: {
606
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
607
+ };
608
+ };
609
+ 403: {
610
+ headers: {
611
+ [name: string]: unknown;
612
+ };
613
+ content: {
614
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
615
+ };
616
+ };
617
+ 404: {
618
+ headers: {
619
+ [name: string]: unknown;
620
+ };
621
+ content: {
622
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
623
+ };
624
+ };
625
+ };
626
+ }>;
627
+ pathSerializer?: import("openapi-fetch").PathSerializer;
628
+ parseAs?: import("openapi-fetch").ParseAs;
629
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
630
+ headers?: import("openapi-fetch").HeadersOptions;
631
+ middleware?: import("openapi-fetch").Middleware[];
632
+ } & Omit<RequestInit, "body" | "headers">, `${string}/${string}`>>;
633
+ /** GET /admin/sentinel/decisions: List the sentinel's decisions */
634
+ listDecisions: (init_0?: ({
635
+ params?: {
636
+ query?: {
637
+ email?: string;
638
+ ip?: string;
639
+ action?: string;
640
+ cursor?: string;
641
+ limit?: number;
642
+ };
643
+ header?: never;
644
+ path?: never;
645
+ cookie?: never;
646
+ };
647
+ } & {
648
+ body?: undefined;
649
+ } & {
650
+ baseUrl?: string;
651
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
652
+ parameters: {
653
+ query?: {
654
+ email?: string;
655
+ ip?: string;
656
+ action?: string;
657
+ cursor?: string;
658
+ limit?: number;
659
+ };
660
+ header?: never;
661
+ path?: never;
662
+ cookie?: never;
663
+ };
664
+ requestBody?: never;
665
+ responses: {
666
+ 200: {
667
+ headers: {
668
+ [name: string]: unknown;
669
+ };
670
+ content: {
671
+ "application/json": {
672
+ data: {
673
+ id: string;
674
+ kind: string;
675
+ email: string;
676
+ ip: string;
677
+ score: number;
678
+ action: string;
679
+ enforced: boolean;
680
+ signals: string[];
681
+ reasons: string[];
682
+ created_at: string;
683
+ }[];
684
+ next_cursor: string | null;
685
+ };
686
+ };
687
+ };
688
+ 401: {
689
+ headers: {
690
+ [name: string]: unknown;
691
+ };
692
+ content: {
693
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
694
+ };
695
+ };
696
+ 403: {
697
+ headers: {
698
+ [name: string]: unknown;
699
+ };
700
+ content: {
701
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
702
+ };
703
+ };
704
+ 422: {
705
+ headers: {
706
+ [name: string]: unknown;
707
+ };
708
+ content: {
709
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
710
+ };
711
+ };
712
+ };
713
+ }>;
714
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
715
+ parameters: {
716
+ query?: {
717
+ email?: string;
718
+ ip?: string;
719
+ action?: string;
720
+ cursor?: string;
721
+ limit?: number;
722
+ };
723
+ header?: never;
724
+ path?: never;
725
+ cookie?: never;
726
+ };
727
+ requestBody?: never;
728
+ responses: {
729
+ 200: {
730
+ headers: {
731
+ [name: string]: unknown;
732
+ };
733
+ content: {
734
+ "application/json": {
735
+ data: {
736
+ id: string;
737
+ kind: string;
738
+ email: string;
739
+ ip: string;
740
+ score: number;
741
+ action: string;
742
+ enforced: boolean;
743
+ signals: string[];
744
+ reasons: string[];
745
+ created_at: string;
746
+ }[];
747
+ next_cursor: string | null;
748
+ };
749
+ };
750
+ };
751
+ 401: {
752
+ headers: {
753
+ [name: string]: unknown;
754
+ };
755
+ content: {
756
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
757
+ };
758
+ };
759
+ 403: {
760
+ headers: {
761
+ [name: string]: unknown;
762
+ };
763
+ content: {
764
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
765
+ };
766
+ };
767
+ 422: {
768
+ headers: {
769
+ [name: string]: unknown;
770
+ };
771
+ content: {
772
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
773
+ };
774
+ };
775
+ };
776
+ }>;
777
+ pathSerializer?: import("openapi-fetch").PathSerializer;
778
+ parseAs?: import("openapi-fetch").ParseAs;
779
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
780
+ headers?: import("openapi-fetch").HeadersOptions;
781
+ middleware?: import("openapi-fetch").Middleware[];
782
+ } & Omit<RequestInit, "body" | "headers"> & {
783
+ [key: string]: unknown;
784
+ }) | undefined) => Promise<import("openapi-fetch").FetchResponse<{
785
+ parameters: {
786
+ query?: {
787
+ email?: string;
788
+ ip?: string;
789
+ action?: string;
790
+ cursor?: string;
791
+ limit?: number;
792
+ };
793
+ header?: never;
794
+ path?: never;
795
+ cookie?: never;
796
+ };
797
+ requestBody?: never;
798
+ responses: {
799
+ 200: {
800
+ headers: {
801
+ [name: string]: unknown;
802
+ };
803
+ content: {
804
+ "application/json": {
805
+ data: {
806
+ id: string;
807
+ kind: string;
808
+ email: string;
809
+ ip: string;
810
+ score: number;
811
+ action: string;
812
+ enforced: boolean;
813
+ signals: string[];
814
+ reasons: string[];
815
+ created_at: string;
816
+ }[];
817
+ next_cursor: string | null;
818
+ };
819
+ };
820
+ };
821
+ 401: {
822
+ headers: {
823
+ [name: string]: unknown;
824
+ };
825
+ content: {
826
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
827
+ };
828
+ };
829
+ 403: {
830
+ headers: {
831
+ [name: string]: unknown;
832
+ };
833
+ content: {
834
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
835
+ };
836
+ };
837
+ 422: {
838
+ headers: {
839
+ [name: string]: unknown;
840
+ };
841
+ content: {
842
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
843
+ };
844
+ };
845
+ };
846
+ }, ({
847
+ params?: {
848
+ query?: {
849
+ email?: string;
850
+ ip?: string;
851
+ action?: string;
852
+ cursor?: string;
853
+ limit?: number;
854
+ };
855
+ header?: never;
856
+ path?: never;
857
+ cookie?: never;
858
+ };
859
+ } & {
860
+ body?: undefined;
861
+ } & {
862
+ baseUrl?: string;
863
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
864
+ parameters: {
865
+ query?: {
866
+ email?: string;
867
+ ip?: string;
868
+ action?: string;
869
+ cursor?: string;
870
+ limit?: number;
871
+ };
872
+ header?: never;
873
+ path?: never;
874
+ cookie?: never;
875
+ };
876
+ requestBody?: never;
877
+ responses: {
878
+ 200: {
879
+ headers: {
880
+ [name: string]: unknown;
881
+ };
882
+ content: {
883
+ "application/json": {
884
+ data: {
885
+ id: string;
886
+ kind: string;
887
+ email: string;
888
+ ip: string;
889
+ score: number;
890
+ action: string;
891
+ enforced: boolean;
892
+ signals: string[];
893
+ reasons: string[];
894
+ created_at: string;
895
+ }[];
896
+ next_cursor: string | null;
897
+ };
898
+ };
899
+ };
900
+ 401: {
901
+ headers: {
902
+ [name: string]: unknown;
903
+ };
904
+ content: {
905
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
906
+ };
907
+ };
908
+ 403: {
909
+ headers: {
910
+ [name: string]: unknown;
911
+ };
912
+ content: {
913
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
914
+ };
915
+ };
916
+ 422: {
917
+ headers: {
918
+ [name: string]: unknown;
919
+ };
920
+ content: {
921
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
922
+ };
923
+ };
924
+ };
925
+ }>;
926
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
927
+ parameters: {
928
+ query?: {
929
+ email?: string;
930
+ ip?: string;
931
+ action?: string;
932
+ cursor?: string;
933
+ limit?: number;
934
+ };
935
+ header?: never;
936
+ path?: never;
937
+ cookie?: never;
938
+ };
939
+ requestBody?: never;
940
+ responses: {
941
+ 200: {
942
+ headers: {
943
+ [name: string]: unknown;
944
+ };
945
+ content: {
946
+ "application/json": {
947
+ data: {
948
+ id: string;
949
+ kind: string;
950
+ email: string;
951
+ ip: string;
952
+ score: number;
953
+ action: string;
954
+ enforced: boolean;
955
+ signals: string[];
956
+ reasons: string[];
957
+ created_at: string;
958
+ }[];
959
+ next_cursor: string | null;
960
+ };
961
+ };
962
+ };
963
+ 401: {
964
+ headers: {
965
+ [name: string]: unknown;
966
+ };
967
+ content: {
968
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
969
+ };
970
+ };
971
+ 403: {
972
+ headers: {
973
+ [name: string]: unknown;
974
+ };
975
+ content: {
976
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
977
+ };
978
+ };
979
+ 422: {
980
+ headers: {
981
+ [name: string]: unknown;
982
+ };
983
+ content: {
984
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
985
+ };
986
+ };
987
+ };
988
+ }>;
989
+ pathSerializer?: import("openapi-fetch").PathSerializer;
990
+ parseAs?: import("openapi-fetch").ParseAs;
991
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
992
+ headers?: import("openapi-fetch").HeadersOptions;
993
+ middleware?: import("openapi-fetch").Middleware[];
994
+ } & Omit<RequestInit, "body" | "headers"> & {
995
+ [key: string]: unknown;
996
+ }) | undefined, `${string}/${string}`>>;
997
+ /** GET /admin/sentinel/ip-rules: List the IP rules */
998
+ listIpRules: (init_0?: ({
999
+ params?: {
1000
+ query?: never;
1001
+ header?: never;
1002
+ path?: never;
1003
+ cookie?: never;
1004
+ };
1005
+ } & {
1006
+ body?: undefined;
1007
+ } & {
1008
+ baseUrl?: string;
1009
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
1010
+ parameters: {
1011
+ query?: never;
1012
+ header?: never;
1013
+ path?: never;
1014
+ cookie?: never;
1015
+ };
1016
+ requestBody?: never;
1017
+ responses: {
1018
+ 200: {
1019
+ headers: {
1020
+ [name: string]: unknown;
1021
+ };
1022
+ content: {
1023
+ "application/json": {
1024
+ data: {
1025
+ id: string;
1026
+ cidr: string;
1027
+ action: string;
1028
+ note: string;
1029
+ created_by: string;
1030
+ created_at: string;
1031
+ }[];
1032
+ };
1033
+ };
1034
+ };
1035
+ 401: {
1036
+ headers: {
1037
+ [name: string]: unknown;
1038
+ };
1039
+ content: {
1040
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1041
+ };
1042
+ };
1043
+ 403: {
1044
+ headers: {
1045
+ [name: string]: unknown;
1046
+ };
1047
+ content: {
1048
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1049
+ };
1050
+ };
1051
+ };
1052
+ }>;
1053
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
1054
+ parameters: {
1055
+ query?: never;
1056
+ header?: never;
1057
+ path?: never;
1058
+ cookie?: never;
1059
+ };
1060
+ requestBody?: never;
1061
+ responses: {
1062
+ 200: {
1063
+ headers: {
1064
+ [name: string]: unknown;
1065
+ };
1066
+ content: {
1067
+ "application/json": {
1068
+ data: {
1069
+ id: string;
1070
+ cidr: string;
1071
+ action: string;
1072
+ note: string;
1073
+ created_by: string;
1074
+ created_at: string;
1075
+ }[];
1076
+ };
1077
+ };
1078
+ };
1079
+ 401: {
1080
+ headers: {
1081
+ [name: string]: unknown;
1082
+ };
1083
+ content: {
1084
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1085
+ };
1086
+ };
1087
+ 403: {
1088
+ headers: {
1089
+ [name: string]: unknown;
1090
+ };
1091
+ content: {
1092
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1093
+ };
1094
+ };
1095
+ };
1096
+ }>;
1097
+ pathSerializer?: import("openapi-fetch").PathSerializer;
1098
+ parseAs?: import("openapi-fetch").ParseAs;
1099
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
1100
+ headers?: import("openapi-fetch").HeadersOptions;
1101
+ middleware?: import("openapi-fetch").Middleware[];
1102
+ } & Omit<RequestInit, "body" | "headers"> & {
1103
+ [key: string]: unknown;
1104
+ }) | undefined) => Promise<import("openapi-fetch").FetchResponse<{
1105
+ parameters: {
1106
+ query?: never;
1107
+ header?: never;
1108
+ path?: never;
1109
+ cookie?: never;
1110
+ };
1111
+ requestBody?: never;
1112
+ responses: {
1113
+ 200: {
1114
+ headers: {
1115
+ [name: string]: unknown;
1116
+ };
1117
+ content: {
1118
+ "application/json": {
1119
+ data: {
1120
+ id: string;
1121
+ cidr: string;
1122
+ action: string;
1123
+ note: string;
1124
+ created_by: string;
1125
+ created_at: string;
1126
+ }[];
1127
+ };
1128
+ };
1129
+ };
1130
+ 401: {
1131
+ headers: {
1132
+ [name: string]: unknown;
1133
+ };
1134
+ content: {
1135
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1136
+ };
1137
+ };
1138
+ 403: {
1139
+ headers: {
1140
+ [name: string]: unknown;
1141
+ };
1142
+ content: {
1143
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1144
+ };
1145
+ };
1146
+ };
1147
+ }, ({
1148
+ params?: {
1149
+ query?: never;
1150
+ header?: never;
1151
+ path?: never;
1152
+ cookie?: never;
1153
+ };
1154
+ } & {
1155
+ body?: undefined;
1156
+ } & {
1157
+ baseUrl?: string;
1158
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
1159
+ parameters: {
1160
+ query?: never;
1161
+ header?: never;
1162
+ path?: never;
1163
+ cookie?: never;
1164
+ };
1165
+ requestBody?: never;
1166
+ responses: {
1167
+ 200: {
1168
+ headers: {
1169
+ [name: string]: unknown;
1170
+ };
1171
+ content: {
1172
+ "application/json": {
1173
+ data: {
1174
+ id: string;
1175
+ cidr: string;
1176
+ action: string;
1177
+ note: string;
1178
+ created_by: string;
1179
+ created_at: string;
1180
+ }[];
1181
+ };
1182
+ };
1183
+ };
1184
+ 401: {
1185
+ headers: {
1186
+ [name: string]: unknown;
1187
+ };
1188
+ content: {
1189
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1190
+ };
1191
+ };
1192
+ 403: {
1193
+ headers: {
1194
+ [name: string]: unknown;
1195
+ };
1196
+ content: {
1197
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1198
+ };
1199
+ };
1200
+ };
1201
+ }>;
1202
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
1203
+ parameters: {
1204
+ query?: never;
1205
+ header?: never;
1206
+ path?: never;
1207
+ cookie?: never;
1208
+ };
1209
+ requestBody?: never;
1210
+ responses: {
1211
+ 200: {
1212
+ headers: {
1213
+ [name: string]: unknown;
1214
+ };
1215
+ content: {
1216
+ "application/json": {
1217
+ data: {
1218
+ id: string;
1219
+ cidr: string;
1220
+ action: string;
1221
+ note: string;
1222
+ created_by: string;
1223
+ created_at: string;
1224
+ }[];
1225
+ };
1226
+ };
1227
+ };
1228
+ 401: {
1229
+ headers: {
1230
+ [name: string]: unknown;
1231
+ };
1232
+ content: {
1233
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1234
+ };
1235
+ };
1236
+ 403: {
1237
+ headers: {
1238
+ [name: string]: unknown;
1239
+ };
1240
+ content: {
1241
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1242
+ };
1243
+ };
1244
+ };
1245
+ }>;
1246
+ pathSerializer?: import("openapi-fetch").PathSerializer;
1247
+ parseAs?: import("openapi-fetch").ParseAs;
1248
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
1249
+ headers?: import("openapi-fetch").HeadersOptions;
1250
+ middleware?: import("openapi-fetch").Middleware[];
1251
+ } & Omit<RequestInit, "body" | "headers"> & {
1252
+ [key: string]: unknown;
1253
+ }) | undefined, `${string}/${string}`>>;
1254
+ /** POST /admin/sentinel/unblock: Clear the counters of an identifier */
1255
+ unblock: (init_0: {
1256
+ params?: {
1257
+ query?: never;
1258
+ header?: never;
1259
+ path?: never;
1260
+ cookie?: never;
1261
+ };
1262
+ } & {
1263
+ body: {
1264
+ identifier: string;
1265
+ } & {};
1266
+ } & {
1267
+ baseUrl?: string;
1268
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
1269
+ parameters: {
1270
+ query?: never;
1271
+ header?: never;
1272
+ path?: never;
1273
+ cookie?: never;
1274
+ };
1275
+ requestBody: {
1276
+ content: {
1277
+ "application/json": {
1278
+ identifier: string;
1279
+ };
1280
+ };
1281
+ };
1282
+ responses: {
1283
+ 200: {
1284
+ headers: {
1285
+ [name: string]: unknown;
1286
+ };
1287
+ content: {
1288
+ "application/json": {
1289
+ data: {
1290
+ status: string;
1291
+ identifier: string;
1292
+ };
1293
+ };
1294
+ };
1295
+ };
1296
+ 401: {
1297
+ headers: {
1298
+ [name: string]: unknown;
1299
+ };
1300
+ content: {
1301
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1302
+ };
1303
+ };
1304
+ 403: {
1305
+ headers: {
1306
+ [name: string]: unknown;
1307
+ };
1308
+ content: {
1309
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1310
+ };
1311
+ };
1312
+ 422: {
1313
+ headers: {
1314
+ [name: string]: unknown;
1315
+ };
1316
+ content: {
1317
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1318
+ };
1319
+ };
1320
+ };
1321
+ }>;
1322
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
1323
+ parameters: {
1324
+ query?: never;
1325
+ header?: never;
1326
+ path?: never;
1327
+ cookie?: never;
1328
+ };
1329
+ requestBody: {
1330
+ content: {
1331
+ "application/json": {
1332
+ identifier: string;
1333
+ };
1334
+ };
1335
+ };
1336
+ responses: {
1337
+ 200: {
1338
+ headers: {
1339
+ [name: string]: unknown;
1340
+ };
1341
+ content: {
1342
+ "application/json": {
1343
+ data: {
1344
+ status: string;
1345
+ identifier: string;
1346
+ };
1347
+ };
1348
+ };
1349
+ };
1350
+ 401: {
1351
+ headers: {
1352
+ [name: string]: unknown;
1353
+ };
1354
+ content: {
1355
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1356
+ };
1357
+ };
1358
+ 403: {
1359
+ headers: {
1360
+ [name: string]: unknown;
1361
+ };
1362
+ content: {
1363
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1364
+ };
1365
+ };
1366
+ 422: {
1367
+ headers: {
1368
+ [name: string]: unknown;
1369
+ };
1370
+ content: {
1371
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1372
+ };
1373
+ };
1374
+ };
1375
+ }>;
1376
+ pathSerializer?: import("openapi-fetch").PathSerializer;
1377
+ parseAs?: import("openapi-fetch").ParseAs;
1378
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
1379
+ headers?: import("openapi-fetch").HeadersOptions;
1380
+ middleware?: import("openapi-fetch").Middleware[];
1381
+ } & Omit<RequestInit, "body" | "headers"> & {
1382
+ [key: string]: unknown;
1383
+ }) => Promise<import("openapi-fetch").FetchResponse<{
1384
+ parameters: {
1385
+ query?: never;
1386
+ header?: never;
1387
+ path?: never;
1388
+ cookie?: never;
1389
+ };
1390
+ requestBody: {
1391
+ content: {
1392
+ "application/json": {
1393
+ identifier: string;
1394
+ };
1395
+ };
1396
+ };
1397
+ responses: {
1398
+ 200: {
1399
+ headers: {
1400
+ [name: string]: unknown;
1401
+ };
1402
+ content: {
1403
+ "application/json": {
1404
+ data: {
1405
+ status: string;
1406
+ identifier: string;
1407
+ };
1408
+ };
1409
+ };
1410
+ };
1411
+ 401: {
1412
+ headers: {
1413
+ [name: string]: unknown;
1414
+ };
1415
+ content: {
1416
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1417
+ };
1418
+ };
1419
+ 403: {
1420
+ headers: {
1421
+ [name: string]: unknown;
1422
+ };
1423
+ content: {
1424
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1425
+ };
1426
+ };
1427
+ 422: {
1428
+ headers: {
1429
+ [name: string]: unknown;
1430
+ };
1431
+ content: {
1432
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1433
+ };
1434
+ };
1435
+ };
1436
+ }, {
1437
+ params?: {
1438
+ query?: never;
1439
+ header?: never;
1440
+ path?: never;
1441
+ cookie?: never;
1442
+ };
1443
+ } & {
1444
+ body: {
1445
+ identifier: string;
1446
+ } & {};
1447
+ } & {
1448
+ baseUrl?: string;
1449
+ querySerializer?: import("openapi-fetch").QuerySerializerOptions | import("openapi-fetch").QuerySerializer<{
1450
+ parameters: {
1451
+ query?: never;
1452
+ header?: never;
1453
+ path?: never;
1454
+ cookie?: never;
1455
+ };
1456
+ requestBody: {
1457
+ content: {
1458
+ "application/json": {
1459
+ identifier: string;
1460
+ };
1461
+ };
1462
+ };
1463
+ responses: {
1464
+ 200: {
1465
+ headers: {
1466
+ [name: string]: unknown;
1467
+ };
1468
+ content: {
1469
+ "application/json": {
1470
+ data: {
1471
+ status: string;
1472
+ identifier: string;
1473
+ };
1474
+ };
1475
+ };
1476
+ };
1477
+ 401: {
1478
+ headers: {
1479
+ [name: string]: unknown;
1480
+ };
1481
+ content: {
1482
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1483
+ };
1484
+ };
1485
+ 403: {
1486
+ headers: {
1487
+ [name: string]: unknown;
1488
+ };
1489
+ content: {
1490
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1491
+ };
1492
+ };
1493
+ 422: {
1494
+ headers: {
1495
+ [name: string]: unknown;
1496
+ };
1497
+ content: {
1498
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1499
+ };
1500
+ };
1501
+ };
1502
+ }>;
1503
+ bodySerializer?: import("openapi-fetch").BodySerializer<{
1504
+ parameters: {
1505
+ query?: never;
1506
+ header?: never;
1507
+ path?: never;
1508
+ cookie?: never;
1509
+ };
1510
+ requestBody: {
1511
+ content: {
1512
+ "application/json": {
1513
+ identifier: string;
1514
+ };
1515
+ };
1516
+ };
1517
+ responses: {
1518
+ 200: {
1519
+ headers: {
1520
+ [name: string]: unknown;
1521
+ };
1522
+ content: {
1523
+ "application/json": {
1524
+ data: {
1525
+ status: string;
1526
+ identifier: string;
1527
+ };
1528
+ };
1529
+ };
1530
+ };
1531
+ 401: {
1532
+ headers: {
1533
+ [name: string]: unknown;
1534
+ };
1535
+ content: {
1536
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1537
+ };
1538
+ };
1539
+ 403: {
1540
+ headers: {
1541
+ [name: string]: unknown;
1542
+ };
1543
+ content: {
1544
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1545
+ };
1546
+ };
1547
+ 422: {
1548
+ headers: {
1549
+ [name: string]: unknown;
1550
+ };
1551
+ content: {
1552
+ "application/problem+json": import("./schema.js").components["schemas"]["Problem"];
1553
+ };
1554
+ };
1555
+ };
1556
+ }>;
1557
+ pathSerializer?: import("openapi-fetch").PathSerializer;
1558
+ parseAs?: import("openapi-fetch").ParseAs;
1559
+ fetch?: import("openapi-fetch").ClientOptions["fetch"];
1560
+ headers?: import("openapi-fetch").HeadersOptions;
1561
+ middleware?: import("openapi-fetch").Middleware[];
1562
+ } & Omit<RequestInit, "body" | "headers">, `${string}/${string}`>>;
1563
+ };
1564
+ export type SentinelApi = ReturnType<typeof sentinel>;