Projekt

Obecné

Profil

Stáhnout (63.1 KB) Statistiky
| Větev: | Tag: | Revize:
1
/* tslint:disable */
2
/* eslint-disable */
3
/**
4
 * AnnotationTool
5
 * KIV/ASWI ZČU Plzeň, 2022
6
 *
7
 * The version of the OpenAPI document: 0.1.1
8
 * 
9
 *
10
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
11
 * https://openapi-generator.tech
12
 * Do not edit the class manually.
13
 */
14

    
15

    
16
import { Configuration } from './configuration';
17
import globalAxios, { AxiosPromise, AxiosInstance, AxiosRequestConfig } from 'axios';
18
// Some imports not used depending on template conditions
19
// @ts-ignore
20
import { DUMMY_BASE_URL, assertParamExists, setApiKeyToObject, setBasicAuthToObject, setBearerAuthToObject, setOAuthToObject, setSearchParams, serializeDataIfNeeded, toPathString, createRequestFunction } from './common';
21
// @ts-ignore
22
import { BASE_PATH, COLLECTION_FORMATS, RequestArgs, BaseAPI, RequiredError } from './base';
23

    
24
/**
25
 * 
26
 * @export
27
 * @interface AnnotationInfo
28
 */
29
export interface AnnotationInfo {
30
    /**
31
     * 
32
     * @type {string}
33
     * @memberof AnnotationInfo
34
     */
35
    'sourceDocumentContent'?: string | null;
36
    /**
37
     * 
38
     * @type {string}
39
     * @memberof AnnotationInfo
40
     */
41
    'documentToRender'?: string | null;
42
    /**
43
     * 
44
     * @type {Array<number>}
45
     * @memberof AnnotationInfo
46
     */
47
    'tagStartPositions'?: Array<number> | null;
48
    /**
49
     * 
50
     * @type {Array<number>}
51
     * @memberof AnnotationInfo
52
     */
53
    'tagLengths'?: Array<number> | null;
54
    /**
55
     * 
56
     * @type {EState}
57
     * @memberof AnnotationInfo
58
     */
59
    'state'?: EState;
60
    /**
61
     * 
62
     * @type {EDocumentType}
63
     * @memberof AnnotationInfo
64
     */
65
    'type'?: EDocumentType;
66
    /**
67
     * 
68
     * @type {string}
69
     * @memberof AnnotationInfo
70
     */
71
    'note'?: string | null;
72
    /**
73
     * 
74
     * @type {Array<TagInstanceInfo>}
75
     * @memberof AnnotationInfo
76
     */
77
    'tagInstances'?: Array<TagInstanceInfo> | null;
78
}
79
/**
80
 * 
81
 * @export
82
 * @interface AnnotationInstanceAddRequest
83
 */
84
export interface AnnotationInstanceAddRequest {
85
    /**
86
     * 
87
     * @type {number}
88
     * @memberof AnnotationInstanceAddRequest
89
     */
90
    'position'?: number;
91
    /**
92
     * 
93
     * @type {number}
94
     * @memberof AnnotationInstanceAddRequest
95
     */
96
    'length'?: number;
97
    /**
98
     * 
99
     * @type {ETagType}
100
     * @memberof AnnotationInstanceAddRequest
101
     */
102
    'type'?: ETagType;
103
    /**
104
     * 
105
     * @type {string}
106
     * @memberof AnnotationInstanceAddRequest
107
     */
108
    'id'?: string;
109
    /**
110
     * 
111
     * @type {string}
112
     * @memberof AnnotationInstanceAddRequest
113
     */
114
    'instanceId'?: string | null;
115
}
116
/**
117
 * 
118
 * @export
119
 * @interface AnnotationListInfo
120
 */
121
export interface AnnotationListInfo {
122
    /**
123
     * 
124
     * @type {string}
125
     * @memberof AnnotationListInfo
126
     */
127
    'documentName'?: string | null;
128
    /**
129
     * 
130
     * @type {EState}
131
     * @memberof AnnotationListInfo
132
     */
133
    'state'?: EState;
134
    /**
135
     * 
136
     * @type {string}
137
     * @memberof AnnotationListInfo
138
     */
139
    'annotationId'?: string;
140
}
141
/**
142
 * 
143
 * @export
144
 * @interface AnnotationListResponse
145
 */
146
export interface AnnotationListResponse {
147
    /**
148
     * 
149
     * @type {Array<AnnotationListInfo>}
150
     * @memberof AnnotationListResponse
151
     */
152
    'annotations'?: Array<AnnotationListInfo> | null;
153
}
154
/**
155
 * 
156
 * @export
157
 * @interface AnnotationsAddRequest
158
 */
159
export interface AnnotationsAddRequest {
160
    /**
161
     * 
162
     * @type {Array<string>}
163
     * @memberof AnnotationsAddRequest
164
     */
165
    'userIdList'?: Array<string> | null;
166
    /**
167
     * 
168
     * @type {Array<string>}
169
     * @memberof AnnotationsAddRequest
170
     */
171
    'documentIdList'?: Array<string> | null;
172
}
173
/**
174
 * 
175
 * @export
176
 * @interface ChangeUserInfoRequest
177
 */
178
export interface ChangeUserInfoRequest {
179
    /**
180
     * 
181
     * @type {string}
182
     * @memberof ChangeUserInfoRequest
183
     */
184
    'password'?: string | null;
185
    /**
186
     * 
187
     * @type {string}
188
     * @memberof ChangeUserInfoRequest
189
     */
190
    'username'?: string | null;
191
    /**
192
     * 
193
     * @type {string}
194
     * @memberof ChangeUserInfoRequest
195
     */
196
    'name'?: string | null;
197
    /**
198
     * 
199
     * @type {string}
200
     * @memberof ChangeUserInfoRequest
201
     */
202
    'surname'?: string | null;
203
    /**
204
     * 
205
     * @type {ERole}
206
     * @memberof ChangeUserInfoRequest
207
     */
208
    'role'?: ERole;
209
}
210
/**
211
 * 
212
 * @export
213
 * @interface ClientInfo
214
 */
215
export interface ClientInfo {
216
    /**
217
     * 
218
     * @type {boolean}
219
     * @memberof ClientInfo
220
     */
221
    'isLogged'?: boolean;
222
    /**
223
     * 
224
     * @type {User}
225
     * @memberof ClientInfo
226
     */
227
    'loggedUser'?: User;
228
    /**
229
     * 
230
     * @type {string}
231
     * @memberof ClientInfo
232
     */
233
    'ip'?: string | null;
234
}
235
/**
236
 * 
237
 * @export
238
 * @interface CreateUserRequest
239
 */
240
export interface CreateUserRequest {
241
    /**
242
     * 
243
     * @type {string}
244
     * @memberof CreateUserRequest
245
     */
246
    'username'?: string | null;
247
    /**
248
     * 
249
     * @type {string}
250
     * @memberof CreateUserRequest
251
     */
252
    'password'?: string | null;
253
    /**
254
     * 
255
     * @type {string}
256
     * @memberof CreateUserRequest
257
     */
258
    'name'?: string | null;
259
    /**
260
     * 
261
     * @type {string}
262
     * @memberof CreateUserRequest
263
     */
264
    'surname'?: string | null;
265
    /**
266
     * 
267
     * @type {ERole}
268
     * @memberof CreateUserRequest
269
     */
270
    'role'?: ERole;
271
}
272
/**
273
 * 
274
 * @export
275
 * @interface DocumentAddInfo
276
 */
277
export interface DocumentAddInfo {
278
    /**
279
     * 
280
     * @type {string}
281
     * @memberof DocumentAddInfo
282
     */
283
    'name'?: string | null;
284
    /**
285
     * 
286
     * @type {EAddDocumentFormat}
287
     * @memberof DocumentAddInfo
288
     */
289
    'format'?: EAddDocumentFormat;
290
    /**
291
     * 
292
     * @type {string}
293
     * @memberof DocumentAddInfo
294
     */
295
    'content'?: string | null;
296
}
297
/**
298
 * 
299
 * @export
300
 * @interface DocumentAddRequest
301
 */
302
export interface DocumentAddRequest {
303
    /**
304
     * 
305
     * @type {Array<DocumentAddInfo>}
306
     * @memberof DocumentAddRequest
307
     */
308
    'documents'?: Array<DocumentAddInfo> | null;
309
}
310
/**
311
 * 
312
 * @export
313
 * @interface DocumentListInfo
314
 */
315
export interface DocumentListInfo {
316
    /**
317
     * 
318
     * @type {string}
319
     * @memberof DocumentListInfo
320
     */
321
    'id'?: string;
322
    /**
323
     * 
324
     * @type {string}
325
     * @memberof DocumentListInfo
326
     */
327
    'name'?: string | null;
328
    /**
329
     * 
330
     * @type {number}
331
     * @memberof DocumentListInfo
332
     */
333
    'length'?: number;
334
    /**
335
     * 
336
     * @type {number}
337
     * @memberof DocumentListInfo
338
     */
339
    'requiredAnnotations'?: number;
340
    /**
341
     * 
342
     * @type {Array<UserInfo>}
343
     * @memberof DocumentListInfo
344
     */
345
    'annotatingUsers'?: Array<UserInfo> | null;
346
}
347
/**
348
 * 
349
 * @export
350
 * @interface DocumentListResponse
351
 */
352
export interface DocumentListResponse {
353
    /**
354
     * 
355
     * @type {number}
356
     * @memberof DocumentListResponse
357
     */
358
    'totalCount'?: number;
359
    /**
360
     * 
361
     * @type {number}
362
     * @memberof DocumentListResponse
363
     */
364
    'pageCount'?: number;
365
    /**
366
     * 
367
     * @type {number}
368
     * @memberof DocumentListResponse
369
     */
370
    'pageIndex'?: number;
371
    /**
372
     * 
373
     * @type {Array<DocumentListInfo>}
374
     * @memberof DocumentListResponse
375
     */
376
    'documents'?: Array<DocumentListInfo> | null;
377
}
378
/**
379
 * 
380
 * @export
381
 * @enum {string}
382
 */
383

    
384
export const EAddDocumentFormat = {
385
    Zip: 'ZIP',
386
    Textfile: 'TEXTFILE'
387
} as const;
388

    
389
export type EAddDocumentFormat = typeof EAddDocumentFormat[keyof typeof EAddDocumentFormat];
390

    
391

    
392
/**
393
 * 
394
 * @export
395
 * @enum {string}
396
 */
397

    
398
export const EDocumentType = {
399
    Html: 'HTML',
400
    Text: 'TEXT'
401
} as const;
402

    
403
export type EDocumentType = typeof EDocumentType[keyof typeof EDocumentType];
404

    
405

    
406
/**
407
 * 
408
 * @export
409
 * @enum {string}
410
 */
411

    
412
export const ERole = {
413
    Annotator: 'ANNOTATOR',
414
    Administrator: 'ADMINISTRATOR'
415
} as const;
416

    
417
export type ERole = typeof ERole[keyof typeof ERole];
418

    
419

    
420
/**
421
 * 
422
 * @export
423
 * @enum {string}
424
 */
425

    
426
export const EState = {
427
    Done: 'DONE',
428
    InProgress: 'IN_PROGRESS',
429
    New: 'NEW'
430
} as const;
431

    
432
export type EState = typeof EState[keyof typeof EState];
433

    
434

    
435
/**
436
 * 
437
 * @export
438
 * @enum {string}
439
 */
440

    
441
export const ETagType = {
442
    Tag: 'TAG',
443
    Subtag: 'SUBTAG'
444
} as const;
445

    
446
export type ETagType = typeof ETagType[keyof typeof ETagType];
447

    
448

    
449
/**
450
 * 
451
 * @export
452
 * @interface LoginRequest
453
 */
454
export interface LoginRequest {
455
    /**
456
     * 
457
     * @type {string}
458
     * @memberof LoginRequest
459
     */
460
    'username'?: string | null;
461
    /**
462
     * 
463
     * @type {string}
464
     * @memberof LoginRequest
465
     */
466
    'password'?: string | null;
467
}
468
/**
469
 * 
470
 * @export
471
 * @interface LoginResponse
472
 */
473
export interface LoginResponse {
474
    /**
475
     * 
476
     * @type {boolean}
477
     * @memberof LoginResponse
478
     */
479
    'ok'?: boolean;
480
    /**
481
     * 
482
     * @type {string}
483
     * @memberof LoginResponse
484
     */
485
    'token'?: string | null;
486
    /**
487
     * 
488
     * @type {string}
489
     * @memberof LoginResponse
490
     */
491
    'expiration'?: string;
492
    /**
493
     * 
494
     * @type {ERole}
495
     * @memberof LoginResponse
496
     */
497
    'role'?: ERole;
498
}
499
/**
500
 * 
501
 * @export
502
 * @interface ProblemDetails
503
 */
504
export interface ProblemDetails {
505
    [key: string]: any | any;
506

    
507
    /**
508
     * 
509
     * @type {string}
510
     * @memberof ProblemDetails
511
     */
512
    'type'?: string | null;
513
    /**
514
     * 
515
     * @type {string}
516
     * @memberof ProblemDetails
517
     */
518
    'title'?: string | null;
519
    /**
520
     * 
521
     * @type {number}
522
     * @memberof ProblemDetails
523
     */
524
    'status'?: number | null;
525
    /**
526
     * 
527
     * @type {string}
528
     * @memberof ProblemDetails
529
     */
530
    'detail'?: string | null;
531
    /**
532
     * 
533
     * @type {string}
534
     * @memberof ProblemDetails
535
     */
536
    'instance'?: string | null;
537
}
538
/**
539
 * 
540
 * @export
541
 * @interface SubTagInfo
542
 */
543
export interface SubTagInfo {
544
    /**
545
     * 
546
     * @type {string}
547
     * @memberof SubTagInfo
548
     */
549
    'id'?: string;
550
    /**
551
     * 
552
     * @type {string}
553
     * @memberof SubTagInfo
554
     */
555
    'name'?: string | null;
556
    /**
557
     * 
558
     * @type {string}
559
     * @memberof SubTagInfo
560
     */
561
    'description'?: string | null;
562
}
563
/**
564
 * 
565
 * @export
566
 * @interface TagCategoryInfo
567
 */
568
export interface TagCategoryInfo {
569
    /**
570
     * 
571
     * @type {string}
572
     * @memberof TagCategoryInfo
573
     */
574
    'id'?: string;
575
    /**
576
     * 
577
     * @type {string}
578
     * @memberof TagCategoryInfo
579
     */
580
    'name'?: string | null;
581
    /**
582
     * 
583
     * @type {string}
584
     * @memberof TagCategoryInfo
585
     */
586
    'description'?: string | null;
587
    /**
588
     * 
589
     * @type {string}
590
     * @memberof TagCategoryInfo
591
     */
592
    'color'?: string | null;
593
    /**
594
     * 
595
     * @type {Array<TagInfo>}
596
     * @memberof TagCategoryInfo
597
     */
598
    'tags'?: Array<TagInfo> | null;
599
}
600
/**
601
 * 
602
 * @export
603
 * @interface TagInfo
604
 */
605
export interface TagInfo {
606
    /**
607
     * 
608
     * @type {string}
609
     * @memberof TagInfo
610
     */
611
    'id'?: string;
612
    /**
613
     * 
614
     * @type {string}
615
     * @memberof TagInfo
616
     */
617
    'name'?: string | null;
618
    /**
619
     * 
620
     * @type {string}
621
     * @memberof TagInfo
622
     */
623
    'description'?: string | null;
624
    /**
625
     * 
626
     * @type {string}
627
     * @memberof TagInfo
628
     */
629
    'color'?: string | null;
630
    /**
631
     * 
632
     * @type {Array<SubTagInfo>}
633
     * @memberof TagInfo
634
     */
635
    'subTags'?: Array<SubTagInfo> | null;
636
}
637
/**
638
 * 
639
 * @export
640
 * @interface TagInstanceInfo
641
 */
642
export interface TagInstanceInfo {
643
    /**
644
     * 
645
     * @type {string}
646
     * @memberof TagInstanceInfo
647
     */
648
    'occurenceId'?: string;
649
    /**
650
     * 
651
     * @type {string}
652
     * @memberof TagInstanceInfo
653
     */
654
    'tagName'?: string | null;
655
    /**
656
     * 
657
     * @type {string}
658
     * @memberof TagInstanceInfo
659
     */
660
    'tagId'?: string;
661
    /**
662
     * 
663
     * @type {string}
664
     * @memberof TagInstanceInfo
665
     */
666
    'tagCategoryName'?: string | null;
667
    /**
668
     * 
669
     * @type {string}
670
     * @memberof TagInstanceInfo
671
     */
672
    'tagCategoryId'?: string;
673
    /**
674
     * 
675
     * @type {string}
676
     * @memberof TagInstanceInfo
677
     */
678
    'subTagName'?: string | null;
679
    /**
680
     * 
681
     * @type {string}
682
     * @memberof TagInstanceInfo
683
     */
684
    'subTagId'?: string | null;
685
    /**
686
     * 
687
     * @type {string}
688
     * @memberof TagInstanceInfo
689
     */
690
    'instance'?: string;
691
    /**
692
     * 
693
     * @type {number}
694
     * @memberof TagInstanceInfo
695
     */
696
    'position'?: number;
697
    /**
698
     * 
699
     * @type {number}
700
     * @memberof TagInstanceInfo
701
     */
702
    'length'?: number;
703
    /**
704
     * 
705
     * @type {string}
706
     * @memberof TagInstanceInfo
707
     */
708
    'note'?: string | null;
709
}
710
/**
711
 * 
712
 * @export
713
 * @interface TagTreeResponse
714
 */
715
export interface TagTreeResponse {
716
    /**
717
     * 
718
     * @type {Array<TagCategoryInfo>}
719
     * @memberof TagTreeResponse
720
     */
721
    'tagCategories'?: Array<TagCategoryInfo> | null;
722
}
723
/**
724
 * 
725
 * @export
726
 * @interface User
727
 */
728
export interface User {
729
    /**
730
     * 
731
     * @type {string}
732
     * @memberof User
733
     */
734
    'id'?: string;
735
    /**
736
     * 
737
     * @type {string}
738
     * @memberof User
739
     */
740
    'username'?: string | null;
741
    /**
742
     * 
743
     * @type {string}
744
     * @memberof User
745
     */
746
    'name'?: string | null;
747
    /**
748
     * 
749
     * @type {string}
750
     * @memberof User
751
     */
752
    'surname'?: string | null;
753
    /**
754
     * 
755
     * @type {ERole}
756
     * @memberof User
757
     */
758
    'role'?: ERole;
759
}
760
/**
761
 * 
762
 * @export
763
 * @interface UserInfo
764
 */
765
export interface UserInfo {
766
    /**
767
     * 
768
     * @type {string}
769
     * @memberof UserInfo
770
     */
771
    'id'?: string;
772
    /**
773
     * 
774
     * @type {string}
775
     * @memberof UserInfo
776
     */
777
    'username'?: string | null;
778
    /**
779
     * 
780
     * @type {string}
781
     * @memberof UserInfo
782
     */
783
    'name'?: string | null;
784
    /**
785
     * 
786
     * @type {string}
787
     * @memberof UserInfo
788
     */
789
    'surname'?: string | null;
790
    /**
791
     * 
792
     * @type {number}
793
     * @memberof UserInfo
794
     */
795
    'assignedDocumentsCount'?: number;
796
    /**
797
     * 
798
     * @type {ERole}
799
     * @memberof UserInfo
800
     */
801
    'role'?: ERole;
802
}
803
/**
804
 * 
805
 * @export
806
 * @interface UserList
807
 */
808
export interface UserList {
809
    /**
810
     * 
811
     * @type {Array<UserInfo>}
812
     * @memberof UserList
813
     */
814
    'users'?: Array<UserInfo> | null;
815
}
816

    
817
/**
818
 * AnnotationApi - axios parameter creator
819
 * @export
820
 */
821
export const AnnotationApiAxiosParamCreator = function (configuration?: Configuration) {
822
    return {
823
        /**
824
         * 
825
         * @param {string} annotationId 
826
         * @param {*} [options] Override http request option.
827
         * @throws {RequiredError}
828
         */
829
        annotationAnnotationIdGet: async (annotationId: string, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
830
            // verify required parameter 'annotationId' is not null or undefined
831
            assertParamExists('annotationAnnotationIdGet', 'annotationId', annotationId)
832
            const localVarPath = `/annotation/{annotationId}`
833
                .replace(`{${"annotationId"}}`, encodeURIComponent(String(annotationId)));
834
            // use dummy base URL string because the URL constructor only accepts absolute URLs.
835
            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
836
            let baseOptions;
837
            if (configuration) {
838
                baseOptions = configuration.baseOptions;
839
            }
840

    
841
            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
842
            const localVarHeaderParameter = {} as any;
843
            const localVarQueryParameter = {} as any;
844

    
845

    
846
    
847
            setSearchParams(localVarUrlObj, localVarQueryParameter);
848
            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
849
            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
850

    
851
            return {
852
                url: toPathString(localVarUrlObj),
853
                options: localVarRequestOptions,
854
            };
855
        },
856
        /**
857
         * 
858
         * @param {string} annotationId 
859
         * @param {string} occurenceId 
860
         * @param {*} [options] Override http request option.
861
         * @throws {RequiredError}
862
         */
863
        annotationAnnotationIdOccurenceIdDelete: async (annotationId: string, occurenceId: string, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
864
            // verify required parameter 'annotationId' is not null or undefined
865
            assertParamExists('annotationAnnotationIdOccurenceIdDelete', 'annotationId', annotationId)
866
            // verify required parameter 'occurenceId' is not null or undefined
867
            assertParamExists('annotationAnnotationIdOccurenceIdDelete', 'occurenceId', occurenceId)
868
            const localVarPath = `/annotation/{annotationId}/{occurenceId}`
869
                .replace(`{${"annotationId"}}`, encodeURIComponent(String(annotationId)))
870
                .replace(`{${"occurenceId"}}`, encodeURIComponent(String(occurenceId)));
871
            // use dummy base URL string because the URL constructor only accepts absolute URLs.
872
            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
873
            let baseOptions;
874
            if (configuration) {
875
                baseOptions = configuration.baseOptions;
876
            }
877

    
878
            const localVarRequestOptions = { method: 'DELETE', ...baseOptions, ...options};
879
            const localVarHeaderParameter = {} as any;
880
            const localVarQueryParameter = {} as any;
881

    
882

    
883
    
884
            setSearchParams(localVarUrlObj, localVarQueryParameter);
885
            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
886
            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
887

    
888
            return {
889
                url: toPathString(localVarUrlObj),
890
                options: localVarRequestOptions,
891
            };
892
        },
893
        /**
894
         * 
895
         * @param {string} annotationId 
896
         * @param {AnnotationInstanceAddRequest} [annotationInstanceAddRequest] 
897
         * @param {*} [options] Override http request option.
898
         * @throws {RequiredError}
899
         */
900
        annotationAnnotationIdPost: async (annotationId: string, annotationInstanceAddRequest?: AnnotationInstanceAddRequest, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
901
            // verify required parameter 'annotationId' is not null or undefined
902
            assertParamExists('annotationAnnotationIdPost', 'annotationId', annotationId)
903
            const localVarPath = `/annotation/{annotationId}`
904
                .replace(`{${"annotationId"}}`, encodeURIComponent(String(annotationId)));
905
            // use dummy base URL string because the URL constructor only accepts absolute URLs.
906
            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
907
            let baseOptions;
908
            if (configuration) {
909
                baseOptions = configuration.baseOptions;
910
            }
911

    
912
            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
913
            const localVarHeaderParameter = {} as any;
914
            const localVarQueryParameter = {} as any;
915

    
916

    
917
    
918
            localVarHeaderParameter['Content-Type'] = 'application/json';
919

    
920
            setSearchParams(localVarUrlObj, localVarQueryParameter);
921
            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
922
            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
923
            localVarRequestOptions.data = serializeDataIfNeeded(annotationInstanceAddRequest, localVarRequestOptions, configuration)
924

    
925
            return {
926
                url: toPathString(localVarUrlObj),
927
                options: localVarRequestOptions,
928
            };
929
        },
930
        /**
931
         * 
932
         * @param {AnnotationsAddRequest} [annotationsAddRequest] 
933
         * @param {*} [options] Override http request option.
934
         * @throws {RequiredError}
935
         */
936
        annotationsPost: async (annotationsAddRequest?: AnnotationsAddRequest, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
937
            const localVarPath = `/annotations`;
938
            // use dummy base URL string because the URL constructor only accepts absolute URLs.
939
            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
940
            let baseOptions;
941
            if (configuration) {
942
                baseOptions = configuration.baseOptions;
943
            }
944

    
945
            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
946
            const localVarHeaderParameter = {} as any;
947
            const localVarQueryParameter = {} as any;
948

    
949

    
950
    
951
            localVarHeaderParameter['Content-Type'] = 'application/json';
952

    
953
            setSearchParams(localVarUrlObj, localVarQueryParameter);
954
            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
955
            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
956
            localVarRequestOptions.data = serializeDataIfNeeded(annotationsAddRequest, localVarRequestOptions, configuration)
957

    
958
            return {
959
                url: toPathString(localVarUrlObj),
960
                options: localVarRequestOptions,
961
            };
962
        },
963
    }
964
};
965

    
966
/**
967
 * AnnotationApi - functional programming interface
968
 * @export
969
 */
970
export const AnnotationApiFp = function(configuration?: Configuration) {
971
    const localVarAxiosParamCreator = AnnotationApiAxiosParamCreator(configuration)
972
    return {
973
        /**
974
         * 
975
         * @param {string} annotationId 
976
         * @param {*} [options] Override http request option.
977
         * @throws {RequiredError}
978
         */
979
        async annotationAnnotationIdGet(annotationId: string, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AnnotationInfo>> {
980
            const localVarAxiosArgs = await localVarAxiosParamCreator.annotationAnnotationIdGet(annotationId, options);
981
            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
982
        },
983
        /**
984
         * 
985
         * @param {string} annotationId 
986
         * @param {string} occurenceId 
987
         * @param {*} [options] Override http request option.
988
         * @throws {RequiredError}
989
         */
990
        async annotationAnnotationIdOccurenceIdDelete(annotationId: string, occurenceId: string, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
991
            const localVarAxiosArgs = await localVarAxiosParamCreator.annotationAnnotationIdOccurenceIdDelete(annotationId, occurenceId, options);
992
            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
993
        },
994
        /**
995
         * 
996
         * @param {string} annotationId 
997
         * @param {AnnotationInstanceAddRequest} [annotationInstanceAddRequest] 
998
         * @param {*} [options] Override http request option.
999
         * @throws {RequiredError}
1000
         */
1001
        async annotationAnnotationIdPost(annotationId: string, annotationInstanceAddRequest?: AnnotationInstanceAddRequest, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1002
            const localVarAxiosArgs = await localVarAxiosParamCreator.annotationAnnotationIdPost(annotationId, annotationInstanceAddRequest, options);
1003
            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
1004
        },
1005
        /**
1006
         * 
1007
         * @param {AnnotationsAddRequest} [annotationsAddRequest] 
1008
         * @param {*} [options] Override http request option.
1009
         * @throws {RequiredError}
1010
         */
1011
        async annotationsPost(annotationsAddRequest?: AnnotationsAddRequest, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1012
            const localVarAxiosArgs = await localVarAxiosParamCreator.annotationsPost(annotationsAddRequest, options);
1013
            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
1014
        },
1015
    }
1016
};
1017

    
1018
/**
1019
 * AnnotationApi - factory interface
1020
 * @export
1021
 */
1022
export const AnnotationApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
1023
    const localVarFp = AnnotationApiFp(configuration)
1024
    return {
1025
        /**
1026
         * 
1027
         * @param {string} annotationId 
1028
         * @param {*} [options] Override http request option.
1029
         * @throws {RequiredError}
1030
         */
1031
        annotationAnnotationIdGet(annotationId: string, options?: any): AxiosPromise<AnnotationInfo> {
1032
            return localVarFp.annotationAnnotationIdGet(annotationId, options).then((request) => request(axios, basePath));
1033
        },
1034
        /**
1035
         * 
1036
         * @param {string} annotationId 
1037
         * @param {string} occurenceId 
1038
         * @param {*} [options] Override http request option.
1039
         * @throws {RequiredError}
1040
         */
1041
        annotationAnnotationIdOccurenceIdDelete(annotationId: string, occurenceId: string, options?: any): AxiosPromise<void> {
1042
            return localVarFp.annotationAnnotationIdOccurenceIdDelete(annotationId, occurenceId, options).then((request) => request(axios, basePath));
1043
        },
1044
        /**
1045
         * 
1046
         * @param {string} annotationId 
1047
         * @param {AnnotationInstanceAddRequest} [annotationInstanceAddRequest] 
1048
         * @param {*} [options] Override http request option.
1049
         * @throws {RequiredError}
1050
         */
1051
        annotationAnnotationIdPost(annotationId: string, annotationInstanceAddRequest?: AnnotationInstanceAddRequest, options?: any): AxiosPromise<void> {
1052
            return localVarFp.annotationAnnotationIdPost(annotationId, annotationInstanceAddRequest, options).then((request) => request(axios, basePath));
1053
        },
1054
        /**
1055
         * 
1056
         * @param {AnnotationsAddRequest} [annotationsAddRequest] 
1057
         * @param {*} [options] Override http request option.
1058
         * @throws {RequiredError}
1059
         */
1060
        annotationsPost(annotationsAddRequest?: AnnotationsAddRequest, options?: any): AxiosPromise<void> {
1061
            return localVarFp.annotationsPost(annotationsAddRequest, options).then((request) => request(axios, basePath));
1062
        },
1063
    };
1064
};
1065

    
1066
/**
1067
 * AnnotationApi - object-oriented interface
1068
 * @export
1069
 * @class AnnotationApi
1070
 * @extends {BaseAPI}
1071
 */
1072
export class AnnotationApi extends BaseAPI {
1073
    /**
1074
     * 
1075
     * @param {string} annotationId 
1076
     * @param {*} [options] Override http request option.
1077
     * @throws {RequiredError}
1078
     * @memberof AnnotationApi
1079
     */
1080
    public annotationAnnotationIdGet(annotationId: string, options?: AxiosRequestConfig) {
1081
        return AnnotationApiFp(this.configuration).annotationAnnotationIdGet(annotationId, options).then((request) => request(this.axios, this.basePath));
1082
    }
1083

    
1084
    /**
1085
     * 
1086
     * @param {string} annotationId 
1087
     * @param {string} occurenceId 
1088
     * @param {*} [options] Override http request option.
1089
     * @throws {RequiredError}
1090
     * @memberof AnnotationApi
1091
     */
1092
    public annotationAnnotationIdOccurenceIdDelete(annotationId: string, occurenceId: string, options?: AxiosRequestConfig) {
1093
        return AnnotationApiFp(this.configuration).annotationAnnotationIdOccurenceIdDelete(annotationId, occurenceId, options).then((request) => request(this.axios, this.basePath));
1094
    }
1095

    
1096
    /**
1097
     * 
1098
     * @param {string} annotationId 
1099
     * @param {AnnotationInstanceAddRequest} [annotationInstanceAddRequest] 
1100
     * @param {*} [options] Override http request option.
1101
     * @throws {RequiredError}
1102
     * @memberof AnnotationApi
1103
     */
1104
    public annotationAnnotationIdPost(annotationId: string, annotationInstanceAddRequest?: AnnotationInstanceAddRequest, options?: AxiosRequestConfig) {
1105
        return AnnotationApiFp(this.configuration).annotationAnnotationIdPost(annotationId, annotationInstanceAddRequest, options).then((request) => request(this.axios, this.basePath));
1106
    }
1107

    
1108
    /**
1109
     * 
1110
     * @param {AnnotationsAddRequest} [annotationsAddRequest] 
1111
     * @param {*} [options] Override http request option.
1112
     * @throws {RequiredError}
1113
     * @memberof AnnotationApi
1114
     */
1115
    public annotationsPost(annotationsAddRequest?: AnnotationsAddRequest, options?: AxiosRequestConfig) {
1116
        return AnnotationApiFp(this.configuration).annotationsPost(annotationsAddRequest, options).then((request) => request(this.axios, this.basePath));
1117
    }
1118
}
1119

    
1120

    
1121
/**
1122
 * AuthApi - axios parameter creator
1123
 * @export
1124
 */
1125
export const AuthApiAxiosParamCreator = function (configuration?: Configuration) {
1126
    return {
1127
        /**
1128
         * 
1129
         * @param {LoginRequest} [loginRequest] 
1130
         * @param {*} [options] Override http request option.
1131
         * @throws {RequiredError}
1132
         */
1133
        authLoginPost: async (loginRequest?: LoginRequest, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
1134
            const localVarPath = `/auth/login`;
1135
            // use dummy base URL string because the URL constructor only accepts absolute URLs.
1136
            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
1137
            let baseOptions;
1138
            if (configuration) {
1139
                baseOptions = configuration.baseOptions;
1140
            }
1141

    
1142
            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
1143
            const localVarHeaderParameter = {} as any;
1144
            const localVarQueryParameter = {} as any;
1145

    
1146

    
1147
    
1148
            localVarHeaderParameter['Content-Type'] = 'application/json';
1149

    
1150
            setSearchParams(localVarUrlObj, localVarQueryParameter);
1151
            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
1152
            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
1153
            localVarRequestOptions.data = serializeDataIfNeeded(loginRequest, localVarRequestOptions, configuration)
1154

    
1155
            return {
1156
                url: toPathString(localVarUrlObj),
1157
                options: localVarRequestOptions,
1158
            };
1159
        },
1160
        /**
1161
         * 
1162
         * @param {*} [options] Override http request option.
1163
         * @throws {RequiredError}
1164
         */
1165
        authTestAaGet: async (options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
1166
            const localVarPath = `/auth/test/aa`;
1167
            // use dummy base URL string because the URL constructor only accepts absolute URLs.
1168
            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
1169
            let baseOptions;
1170
            if (configuration) {
1171
                baseOptions = configuration.baseOptions;
1172
            }
1173

    
1174
            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
1175
            const localVarHeaderParameter = {} as any;
1176
            const localVarQueryParameter = {} as any;
1177

    
1178

    
1179
    
1180
            setSearchParams(localVarUrlObj, localVarQueryParameter);
1181
            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
1182
            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
1183

    
1184
            return {
1185
                url: toPathString(localVarUrlObj),
1186
                options: localVarRequestOptions,
1187
            };
1188
        },
1189
        /**
1190
         * 
1191
         * @param {*} [options] Override http request option.
1192
         * @throws {RequiredError}
1193
         */
1194
        authTestGet: async (options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
1195
            const localVarPath = `/auth/test`;
1196
            // use dummy base URL string because the URL constructor only accepts absolute URLs.
1197
            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
1198
            let baseOptions;
1199
            if (configuration) {
1200
                baseOptions = configuration.baseOptions;
1201
            }
1202

    
1203
            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
1204
            const localVarHeaderParameter = {} as any;
1205
            const localVarQueryParameter = {} as any;
1206

    
1207

    
1208
    
1209
            setSearchParams(localVarUrlObj, localVarQueryParameter);
1210
            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
1211
            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
1212

    
1213
            return {
1214
                url: toPathString(localVarUrlObj),
1215
                options: localVarRequestOptions,
1216
            };
1217
        },
1218
    }
1219
};
1220

    
1221
/**
1222
 * AuthApi - functional programming interface
1223
 * @export
1224
 */
1225
export const AuthApiFp = function(configuration?: Configuration) {
1226
    const localVarAxiosParamCreator = AuthApiAxiosParamCreator(configuration)
1227
    return {
1228
        /**
1229
         * 
1230
         * @param {LoginRequest} [loginRequest] 
1231
         * @param {*} [options] Override http request option.
1232
         * @throws {RequiredError}
1233
         */
1234
        async authLoginPost(loginRequest?: LoginRequest, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<LoginResponse>> {
1235
            const localVarAxiosArgs = await localVarAxiosParamCreator.authLoginPost(loginRequest, options);
1236
            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
1237
        },
1238
        /**
1239
         * 
1240
         * @param {*} [options] Override http request option.
1241
         * @throws {RequiredError}
1242
         */
1243
        async authTestAaGet(options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ClientInfo>> {
1244
            const localVarAxiosArgs = await localVarAxiosParamCreator.authTestAaGet(options);
1245
            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
1246
        },
1247
        /**
1248
         * 
1249
         * @param {*} [options] Override http request option.
1250
         * @throws {RequiredError}
1251
         */
1252
        async authTestGet(options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ClientInfo>> {
1253
            const localVarAxiosArgs = await localVarAxiosParamCreator.authTestGet(options);
1254
            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
1255
        },
1256
    }
1257
};
1258

    
1259
/**
1260
 * AuthApi - factory interface
1261
 * @export
1262
 */
1263
export const AuthApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
1264
    const localVarFp = AuthApiFp(configuration)
1265
    return {
1266
        /**
1267
         * 
1268
         * @param {LoginRequest} [loginRequest] 
1269
         * @param {*} [options] Override http request option.
1270
         * @throws {RequiredError}
1271
         */
1272
        authLoginPost(loginRequest?: LoginRequest, options?: any): AxiosPromise<LoginResponse> {
1273
            return localVarFp.authLoginPost(loginRequest, options).then((request) => request(axios, basePath));
1274
        },
1275
        /**
1276
         * 
1277
         * @param {*} [options] Override http request option.
1278
         * @throws {RequiredError}
1279
         */
1280
        authTestAaGet(options?: any): AxiosPromise<ClientInfo> {
1281
            return localVarFp.authTestAaGet(options).then((request) => request(axios, basePath));
1282
        },
1283
        /**
1284
         * 
1285
         * @param {*} [options] Override http request option.
1286
         * @throws {RequiredError}
1287
         */
1288
        authTestGet(options?: any): AxiosPromise<ClientInfo> {
1289
            return localVarFp.authTestGet(options).then((request) => request(axios, basePath));
1290
        },
1291
    };
1292
};
1293

    
1294
/**
1295
 * AuthApi - object-oriented interface
1296
 * @export
1297
 * @class AuthApi
1298
 * @extends {BaseAPI}
1299
 */
1300
export class AuthApi extends BaseAPI {
1301
    /**
1302
     * 
1303
     * @param {LoginRequest} [loginRequest] 
1304
     * @param {*} [options] Override http request option.
1305
     * @throws {RequiredError}
1306
     * @memberof AuthApi
1307
     */
1308
    public authLoginPost(loginRequest?: LoginRequest, options?: AxiosRequestConfig) {
1309
        return AuthApiFp(this.configuration).authLoginPost(loginRequest, options).then((request) => request(this.axios, this.basePath));
1310
    }
1311

    
1312
    /**
1313
     * 
1314
     * @param {*} [options] Override http request option.
1315
     * @throws {RequiredError}
1316
     * @memberof AuthApi
1317
     */
1318
    public authTestAaGet(options?: AxiosRequestConfig) {
1319
        return AuthApiFp(this.configuration).authTestAaGet(options).then((request) => request(this.axios, this.basePath));
1320
    }
1321

    
1322
    /**
1323
     * 
1324
     * @param {*} [options] Override http request option.
1325
     * @throws {RequiredError}
1326
     * @memberof AuthApi
1327
     */
1328
    public authTestGet(options?: AxiosRequestConfig) {
1329
        return AuthApiFp(this.configuration).authTestGet(options).then((request) => request(this.axios, this.basePath));
1330
    }
1331
}
1332

    
1333

    
1334
/**
1335
 * DocumentApi - axios parameter creator
1336
 * @export
1337
 */
1338
export const DocumentApiAxiosParamCreator = function (configuration?: Configuration) {
1339
    return {
1340
        /**
1341
         * 
1342
         * @param {number} [pageIndex] 
1343
         * @param {number} [pageSize] 
1344
         * @param {*} [options] Override http request option.
1345
         * @throws {RequiredError}
1346
         */
1347
        documentsGet: async (pageIndex?: number, pageSize?: number, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
1348
            const localVarPath = `/documents`;
1349
            // use dummy base URL string because the URL constructor only accepts absolute URLs.
1350
            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
1351
            let baseOptions;
1352
            if (configuration) {
1353
                baseOptions = configuration.baseOptions;
1354
            }
1355

    
1356
            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
1357
            const localVarHeaderParameter = {} as any;
1358
            const localVarQueryParameter = {} as any;
1359

    
1360
            if (pageIndex !== undefined) {
1361
                localVarQueryParameter['pageIndex'] = pageIndex;
1362
            }
1363

    
1364
            if (pageSize !== undefined) {
1365
                localVarQueryParameter['pageSize'] = pageSize;
1366
            }
1367

    
1368

    
1369
    
1370
            setSearchParams(localVarUrlObj, localVarQueryParameter);
1371
            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
1372
            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
1373

    
1374
            return {
1375
                url: toPathString(localVarUrlObj),
1376
                options: localVarRequestOptions,
1377
            };
1378
        },
1379
        /**
1380
         * 
1381
         * @param {DocumentAddRequest} [documentAddRequest] 
1382
         * @param {*} [options] Override http request option.
1383
         * @throws {RequiredError}
1384
         */
1385
        documentsPost: async (documentAddRequest?: DocumentAddRequest, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
1386
            const localVarPath = `/documents`;
1387
            // use dummy base URL string because the URL constructor only accepts absolute URLs.
1388
            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
1389
            let baseOptions;
1390
            if (configuration) {
1391
                baseOptions = configuration.baseOptions;
1392
            }
1393

    
1394
            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
1395
            const localVarHeaderParameter = {} as any;
1396
            const localVarQueryParameter = {} as any;
1397

    
1398

    
1399
    
1400
            localVarHeaderParameter['Content-Type'] = 'application/json';
1401

    
1402
            setSearchParams(localVarUrlObj, localVarQueryParameter);
1403
            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
1404
            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
1405
            localVarRequestOptions.data = serializeDataIfNeeded(documentAddRequest, localVarRequestOptions, configuration)
1406

    
1407
            return {
1408
                url: toPathString(localVarUrlObj),
1409
                options: localVarRequestOptions,
1410
            };
1411
        },
1412
    }
1413
};
1414

    
1415
/**
1416
 * DocumentApi - functional programming interface
1417
 * @export
1418
 */
1419
export const DocumentApiFp = function(configuration?: Configuration) {
1420
    const localVarAxiosParamCreator = DocumentApiAxiosParamCreator(configuration)
1421
    return {
1422
        /**
1423
         * 
1424
         * @param {number} [pageIndex] 
1425
         * @param {number} [pageSize] 
1426
         * @param {*} [options] Override http request option.
1427
         * @throws {RequiredError}
1428
         */
1429
        async documentsGet(pageIndex?: number, pageSize?: number, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DocumentListResponse>> {
1430
            const localVarAxiosArgs = await localVarAxiosParamCreator.documentsGet(pageIndex, pageSize, options);
1431
            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
1432
        },
1433
        /**
1434
         * 
1435
         * @param {DocumentAddRequest} [documentAddRequest] 
1436
         * @param {*} [options] Override http request option.
1437
         * @throws {RequiredError}
1438
         */
1439
        async documentsPost(documentAddRequest?: DocumentAddRequest, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1440
            const localVarAxiosArgs = await localVarAxiosParamCreator.documentsPost(documentAddRequest, options);
1441
            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
1442
        },
1443
    }
1444
};
1445

    
1446
/**
1447
 * DocumentApi - factory interface
1448
 * @export
1449
 */
1450
export const DocumentApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
1451
    const localVarFp = DocumentApiFp(configuration)
1452
    return {
1453
        /**
1454
         * 
1455
         * @param {number} [pageIndex] 
1456
         * @param {number} [pageSize] 
1457
         * @param {*} [options] Override http request option.
1458
         * @throws {RequiredError}
1459
         */
1460
        documentsGet(pageIndex?: number, pageSize?: number, options?: any): AxiosPromise<DocumentListResponse> {
1461
            return localVarFp.documentsGet(pageIndex, pageSize, options).then((request) => request(axios, basePath));
1462
        },
1463
        /**
1464
         * 
1465
         * @param {DocumentAddRequest} [documentAddRequest] 
1466
         * @param {*} [options] Override http request option.
1467
         * @throws {RequiredError}
1468
         */
1469
        documentsPost(documentAddRequest?: DocumentAddRequest, options?: any): AxiosPromise<void> {
1470
            return localVarFp.documentsPost(documentAddRequest, options).then((request) => request(axios, basePath));
1471
        },
1472
    };
1473
};
1474

    
1475
/**
1476
 * DocumentApi - object-oriented interface
1477
 * @export
1478
 * @class DocumentApi
1479
 * @extends {BaseAPI}
1480
 */
1481
export class DocumentApi extends BaseAPI {
1482
    /**
1483
     * 
1484
     * @param {number} [pageIndex] 
1485
     * @param {number} [pageSize] 
1486
     * @param {*} [options] Override http request option.
1487
     * @throws {RequiredError}
1488
     * @memberof DocumentApi
1489
     */
1490
    public documentsGet(pageIndex?: number, pageSize?: number, options?: AxiosRequestConfig) {
1491
        return DocumentApiFp(this.configuration).documentsGet(pageIndex, pageSize, options).then((request) => request(this.axios, this.basePath));
1492
    }
1493

    
1494
    /**
1495
     * 
1496
     * @param {DocumentAddRequest} [documentAddRequest] 
1497
     * @param {*} [options] Override http request option.
1498
     * @throws {RequiredError}
1499
     * @memberof DocumentApi
1500
     */
1501
    public documentsPost(documentAddRequest?: DocumentAddRequest, options?: AxiosRequestConfig) {
1502
        return DocumentApiFp(this.configuration).documentsPost(documentAddRequest, options).then((request) => request(this.axios, this.basePath));
1503
    }
1504
}
1505

    
1506

    
1507
/**
1508
 * TagApi - axios parameter creator
1509
 * @export
1510
 */
1511
export const TagApiAxiosParamCreator = function (configuration?: Configuration) {
1512
    return {
1513
        /**
1514
         * 
1515
         * @param {*} [options] Override http request option.
1516
         * @throws {RequiredError}
1517
         */
1518
        tagsGet: async (options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
1519
            const localVarPath = `/tags`;
1520
            // use dummy base URL string because the URL constructor only accepts absolute URLs.
1521
            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
1522
            let baseOptions;
1523
            if (configuration) {
1524
                baseOptions = configuration.baseOptions;
1525
            }
1526

    
1527
            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
1528
            const localVarHeaderParameter = {} as any;
1529
            const localVarQueryParameter = {} as any;
1530

    
1531

    
1532
    
1533
            setSearchParams(localVarUrlObj, localVarQueryParameter);
1534
            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
1535
            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
1536

    
1537
            return {
1538
                url: toPathString(localVarUrlObj),
1539
                options: localVarRequestOptions,
1540
            };
1541
        },
1542
    }
1543
};
1544

    
1545
/**
1546
 * TagApi - functional programming interface
1547
 * @export
1548
 */
1549
export const TagApiFp = function(configuration?: Configuration) {
1550
    const localVarAxiosParamCreator = TagApiAxiosParamCreator(configuration)
1551
    return {
1552
        /**
1553
         * 
1554
         * @param {*} [options] Override http request option.
1555
         * @throws {RequiredError}
1556
         */
1557
        async tagsGet(options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<TagTreeResponse>> {
1558
            const localVarAxiosArgs = await localVarAxiosParamCreator.tagsGet(options);
1559
            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
1560
        },
1561
    }
1562
};
1563

    
1564
/**
1565
 * TagApi - factory interface
1566
 * @export
1567
 */
1568
export const TagApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
1569
    const localVarFp = TagApiFp(configuration)
1570
    return {
1571
        /**
1572
         * 
1573
         * @param {*} [options] Override http request option.
1574
         * @throws {RequiredError}
1575
         */
1576
        tagsGet(options?: any): AxiosPromise<TagTreeResponse> {
1577
            return localVarFp.tagsGet(options).then((request) => request(axios, basePath));
1578
        },
1579
    };
1580
};
1581

    
1582
/**
1583
 * TagApi - object-oriented interface
1584
 * @export
1585
 * @class TagApi
1586
 * @extends {BaseAPI}
1587
 */
1588
export class TagApi extends BaseAPI {
1589
    /**
1590
     * 
1591
     * @param {*} [options] Override http request option.
1592
     * @throws {RequiredError}
1593
     * @memberof TagApi
1594
     */
1595
    public tagsGet(options?: AxiosRequestConfig) {
1596
        return TagApiFp(this.configuration).tagsGet(options).then((request) => request(this.axios, this.basePath));
1597
    }
1598
}
1599

    
1600

    
1601
/**
1602
 * UserApi - axios parameter creator
1603
 * @export
1604
 */
1605
export const UserApiAxiosParamCreator = function (configuration?: Configuration) {
1606
    return {
1607
        /**
1608
         * 
1609
         * @param {*} [options] Override http request option.
1610
         * @throws {RequiredError}
1611
         */
1612
        userAnnotationsGet: async (options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
1613
            const localVarPath = `/user/annotations`;
1614
            // use dummy base URL string because the URL constructor only accepts absolute URLs.
1615
            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
1616
            let baseOptions;
1617
            if (configuration) {
1618
                baseOptions = configuration.baseOptions;
1619
            }
1620

    
1621
            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
1622
            const localVarHeaderParameter = {} as any;
1623
            const localVarQueryParameter = {} as any;
1624

    
1625

    
1626
    
1627
            setSearchParams(localVarUrlObj, localVarQueryParameter);
1628
            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
1629
            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
1630

    
1631
            return {
1632
                url: toPathString(localVarUrlObj),
1633
                options: localVarRequestOptions,
1634
            };
1635
        },
1636
        /**
1637
         * 
1638
         * @param {string} userId 
1639
         * @param {*} [options] Override http request option.
1640
         * @throws {RequiredError}
1641
         */
1642
        userUserIdAnnotationsGet: async (userId: string, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
1643
            // verify required parameter 'userId' is not null or undefined
1644
            assertParamExists('userUserIdAnnotationsGet', 'userId', userId)
1645
            const localVarPath = `/user/{userId}/annotations`
1646
                .replace(`{${"userId"}}`, encodeURIComponent(String(userId)));
1647
            // use dummy base URL string because the URL constructor only accepts absolute URLs.
1648
            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
1649
            let baseOptions;
1650
            if (configuration) {
1651
                baseOptions = configuration.baseOptions;
1652
            }
1653

    
1654
            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
1655
            const localVarHeaderParameter = {} as any;
1656
            const localVarQueryParameter = {} as any;
1657

    
1658

    
1659
    
1660
            setSearchParams(localVarUrlObj, localVarQueryParameter);
1661
            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
1662
            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
1663

    
1664
            return {
1665
                url: toPathString(localVarUrlObj),
1666
                options: localVarRequestOptions,
1667
            };
1668
        },
1669
        /**
1670
         * 
1671
         * @param {string} userId 
1672
         * @param {*} [options] Override http request option.
1673
         * @throws {RequiredError}
1674
         */
1675
        userUserIdDelete: async (userId: string, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
1676
            // verify required parameter 'userId' is not null or undefined
1677
            assertParamExists('userUserIdDelete', 'userId', userId)
1678
            const localVarPath = `/user/{userId}`
1679
                .replace(`{${"userId"}}`, encodeURIComponent(String(userId)));
1680
            // use dummy base URL string because the URL constructor only accepts absolute URLs.
1681
            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
1682
            let baseOptions;
1683
            if (configuration) {
1684
                baseOptions = configuration.baseOptions;
1685
            }
1686

    
1687
            const localVarRequestOptions = { method: 'DELETE', ...baseOptions, ...options};
1688
            const localVarHeaderParameter = {} as any;
1689
            const localVarQueryParameter = {} as any;
1690

    
1691

    
1692
    
1693
            setSearchParams(localVarUrlObj, localVarQueryParameter);
1694
            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
1695
            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
1696

    
1697
            return {
1698
                url: toPathString(localVarUrlObj),
1699
                options: localVarRequestOptions,
1700
            };
1701
        },
1702
        /**
1703
         * 
1704
         * @param {string} userId 
1705
         * @param {ChangeUserInfoRequest} [changeUserInfoRequest] 
1706
         * @param {*} [options] Override http request option.
1707
         * @throws {RequiredError}
1708
         */
1709
        userUserIdPut: async (userId: string, changeUserInfoRequest?: ChangeUserInfoRequest, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
1710
            // verify required parameter 'userId' is not null or undefined
1711
            assertParamExists('userUserIdPut', 'userId', userId)
1712
            const localVarPath = `/user/{userId}`
1713
                .replace(`{${"userId"}}`, encodeURIComponent(String(userId)));
1714
            // use dummy base URL string because the URL constructor only accepts absolute URLs.
1715
            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
1716
            let baseOptions;
1717
            if (configuration) {
1718
                baseOptions = configuration.baseOptions;
1719
            }
1720

    
1721
            const localVarRequestOptions = { method: 'PUT', ...baseOptions, ...options};
1722
            const localVarHeaderParameter = {} as any;
1723
            const localVarQueryParameter = {} as any;
1724

    
1725

    
1726
    
1727
            localVarHeaderParameter['Content-Type'] = 'application/json';
1728

    
1729
            setSearchParams(localVarUrlObj, localVarQueryParameter);
1730
            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
1731
            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
1732
            localVarRequestOptions.data = serializeDataIfNeeded(changeUserInfoRequest, localVarRequestOptions, configuration)
1733

    
1734
            return {
1735
                url: toPathString(localVarUrlObj),
1736
                options: localVarRequestOptions,
1737
            };
1738
        },
1739
        /**
1740
         * 
1741
         * @param {*} [options] Override http request option.
1742
         * @throws {RequiredError}
1743
         */
1744
        usersGet: async (options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
1745
            const localVarPath = `/users`;
1746
            // use dummy base URL string because the URL constructor only accepts absolute URLs.
1747
            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
1748
            let baseOptions;
1749
            if (configuration) {
1750
                baseOptions = configuration.baseOptions;
1751
            }
1752

    
1753
            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
1754
            const localVarHeaderParameter = {} as any;
1755
            const localVarQueryParameter = {} as any;
1756

    
1757

    
1758
    
1759
            setSearchParams(localVarUrlObj, localVarQueryParameter);
1760
            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
1761
            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
1762

    
1763
            return {
1764
                url: toPathString(localVarUrlObj),
1765
                options: localVarRequestOptions,
1766
            };
1767
        },
1768
        /**
1769
         * 
1770
         * @param {CreateUserRequest} [createUserRequest] 
1771
         * @param {*} [options] Override http request option.
1772
         * @throws {RequiredError}
1773
         */
1774
        usersPost: async (createUserRequest?: CreateUserRequest, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
1775
            const localVarPath = `/users`;
1776
            // use dummy base URL string because the URL constructor only accepts absolute URLs.
1777
            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
1778
            let baseOptions;
1779
            if (configuration) {
1780
                baseOptions = configuration.baseOptions;
1781
            }
1782

    
1783
            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
1784
            const localVarHeaderParameter = {} as any;
1785
            const localVarQueryParameter = {} as any;
1786

    
1787

    
1788
    
1789
            localVarHeaderParameter['Content-Type'] = 'application/json';
1790

    
1791
            setSearchParams(localVarUrlObj, localVarQueryParameter);
1792
            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
1793
            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
1794
            localVarRequestOptions.data = serializeDataIfNeeded(createUserRequest, localVarRequestOptions, configuration)
1795

    
1796
            return {
1797
                url: toPathString(localVarUrlObj),
1798
                options: localVarRequestOptions,
1799
            };
1800
        },
1801
    }
1802
};
1803

    
1804
/**
1805
 * UserApi - functional programming interface
1806
 * @export
1807
 */
1808
export const UserApiFp = function(configuration?: Configuration) {
1809
    const localVarAxiosParamCreator = UserApiAxiosParamCreator(configuration)
1810
    return {
1811
        /**
1812
         * 
1813
         * @param {*} [options] Override http request option.
1814
         * @throws {RequiredError}
1815
         */
1816
        async userAnnotationsGet(options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AnnotationListResponse>> {
1817
            const localVarAxiosArgs = await localVarAxiosParamCreator.userAnnotationsGet(options);
1818
            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
1819
        },
1820
        /**
1821
         * 
1822
         * @param {string} userId 
1823
         * @param {*} [options] Override http request option.
1824
         * @throws {RequiredError}
1825
         */
1826
        async userUserIdAnnotationsGet(userId: string, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AnnotationListResponse>> {
1827
            const localVarAxiosArgs = await localVarAxiosParamCreator.userUserIdAnnotationsGet(userId, options);
1828
            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
1829
        },
1830
        /**
1831
         * 
1832
         * @param {string} userId 
1833
         * @param {*} [options] Override http request option.
1834
         * @throws {RequiredError}
1835
         */
1836
        async userUserIdDelete(userId: string, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1837
            const localVarAxiosArgs = await localVarAxiosParamCreator.userUserIdDelete(userId, options);
1838
            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
1839
        },
1840
        /**
1841
         * 
1842
         * @param {string} userId 
1843
         * @param {ChangeUserInfoRequest} [changeUserInfoRequest] 
1844
         * @param {*} [options] Override http request option.
1845
         * @throws {RequiredError}
1846
         */
1847
        async userUserIdPut(userId: string, changeUserInfoRequest?: ChangeUserInfoRequest, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1848
            const localVarAxiosArgs = await localVarAxiosParamCreator.userUserIdPut(userId, changeUserInfoRequest, options);
1849
            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
1850
        },
1851
        /**
1852
         * 
1853
         * @param {*} [options] Override http request option.
1854
         * @throws {RequiredError}
1855
         */
1856
        async usersGet(options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<UserList>> {
1857
            const localVarAxiosArgs = await localVarAxiosParamCreator.usersGet(options);
1858
            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
1859
        },
1860
        /**
1861
         * 
1862
         * @param {CreateUserRequest} [createUserRequest] 
1863
         * @param {*} [options] Override http request option.
1864
         * @throws {RequiredError}
1865
         */
1866
        async usersPost(createUserRequest?: CreateUserRequest, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1867
            const localVarAxiosArgs = await localVarAxiosParamCreator.usersPost(createUserRequest, options);
1868
            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
1869
        },
1870
    }
1871
};
1872

    
1873
/**
1874
 * UserApi - factory interface
1875
 * @export
1876
 */
1877
export const UserApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
1878
    const localVarFp = UserApiFp(configuration)
1879
    return {
1880
        /**
1881
         * 
1882
         * @param {*} [options] Override http request option.
1883
         * @throws {RequiredError}
1884
         */
1885
        userAnnotationsGet(options?: any): AxiosPromise<AnnotationListResponse> {
1886
            return localVarFp.userAnnotationsGet(options).then((request) => request(axios, basePath));
1887
        },
1888
        /**
1889
         * 
1890
         * @param {string} userId 
1891
         * @param {*} [options] Override http request option.
1892
         * @throws {RequiredError}
1893
         */
1894
        userUserIdAnnotationsGet(userId: string, options?: any): AxiosPromise<AnnotationListResponse> {
1895
            return localVarFp.userUserIdAnnotationsGet(userId, options).then((request) => request(axios, basePath));
1896
        },
1897
        /**
1898
         * 
1899
         * @param {string} userId 
1900
         * @param {*} [options] Override http request option.
1901
         * @throws {RequiredError}
1902
         */
1903
        userUserIdDelete(userId: string, options?: any): AxiosPromise<void> {
1904
            return localVarFp.userUserIdDelete(userId, options).then((request) => request(axios, basePath));
1905
        },
1906
        /**
1907
         * 
1908
         * @param {string} userId 
1909
         * @param {ChangeUserInfoRequest} [changeUserInfoRequest] 
1910
         * @param {*} [options] Override http request option.
1911
         * @throws {RequiredError}
1912
         */
1913
        userUserIdPut(userId: string, changeUserInfoRequest?: ChangeUserInfoRequest, options?: any): AxiosPromise<void> {
1914
            return localVarFp.userUserIdPut(userId, changeUserInfoRequest, options).then((request) => request(axios, basePath));
1915
        },
1916
        /**
1917
         * 
1918
         * @param {*} [options] Override http request option.
1919
         * @throws {RequiredError}
1920
         */
1921
        usersGet(options?: any): AxiosPromise<UserList> {
1922
            return localVarFp.usersGet(options).then((request) => request(axios, basePath));
1923
        },
1924
        /**
1925
         * 
1926
         * @param {CreateUserRequest} [createUserRequest] 
1927
         * @param {*} [options] Override http request option.
1928
         * @throws {RequiredError}
1929
         */
1930
        usersPost(createUserRequest?: CreateUserRequest, options?: any): AxiosPromise<void> {
1931
            return localVarFp.usersPost(createUserRequest, options).then((request) => request(axios, basePath));
1932
        },
1933
    };
1934
};
1935

    
1936
/**
1937
 * UserApi - object-oriented interface
1938
 * @export
1939
 * @class UserApi
1940
 * @extends {BaseAPI}
1941
 */
1942
export class UserApi extends BaseAPI {
1943
    /**
1944
     * 
1945
     * @param {*} [options] Override http request option.
1946
     * @throws {RequiredError}
1947
     * @memberof UserApi
1948
     */
1949
    public userAnnotationsGet(options?: AxiosRequestConfig) {
1950
        return UserApiFp(this.configuration).userAnnotationsGet(options).then((request) => request(this.axios, this.basePath));
1951
    }
1952

    
1953
    /**
1954
     * 
1955
     * @param {string} userId 
1956
     * @param {*} [options] Override http request option.
1957
     * @throws {RequiredError}
1958
     * @memberof UserApi
1959
     */
1960
    public userUserIdAnnotationsGet(userId: string, options?: AxiosRequestConfig) {
1961
        return UserApiFp(this.configuration).userUserIdAnnotationsGet(userId, options).then((request) => request(this.axios, this.basePath));
1962
    }
1963

    
1964
    /**
1965
     * 
1966
     * @param {string} userId 
1967
     * @param {*} [options] Override http request option.
1968
     * @throws {RequiredError}
1969
     * @memberof UserApi
1970
     */
1971
    public userUserIdDelete(userId: string, options?: AxiosRequestConfig) {
1972
        return UserApiFp(this.configuration).userUserIdDelete(userId, options).then((request) => request(this.axios, this.basePath));
1973
    }
1974

    
1975
    /**
1976
     * 
1977
     * @param {string} userId 
1978
     * @param {ChangeUserInfoRequest} [changeUserInfoRequest] 
1979
     * @param {*} [options] Override http request option.
1980
     * @throws {RequiredError}
1981
     * @memberof UserApi
1982
     */
1983
    public userUserIdPut(userId: string, changeUserInfoRequest?: ChangeUserInfoRequest, options?: AxiosRequestConfig) {
1984
        return UserApiFp(this.configuration).userUserIdPut(userId, changeUserInfoRequest, options).then((request) => request(this.axios, this.basePath));
1985
    }
1986

    
1987
    /**
1988
     * 
1989
     * @param {*} [options] Override http request option.
1990
     * @throws {RequiredError}
1991
     * @memberof UserApi
1992
     */
1993
    public usersGet(options?: AxiosRequestConfig) {
1994
        return UserApiFp(this.configuration).usersGet(options).then((request) => request(this.axios, this.basePath));
1995
    }
1996

    
1997
    /**
1998
     * 
1999
     * @param {CreateUserRequest} [createUserRequest] 
2000
     * @param {*} [options] Override http request option.
2001
     * @throws {RequiredError}
2002
     * @memberof UserApi
2003
     */
2004
    public usersPost(createUserRequest?: CreateUserRequest, options?: AxiosRequestConfig) {
2005
        return UserApiFp(this.configuration).usersPost(createUserRequest, options).then((request) => request(this.axios, this.basePath));
2006
    }
2007
}
2008

    
2009

    
(4-4/9)