@vrplatform/api 1.3.1-stage.5681 → 1.3.1-stage.5684
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.
- package/build/main/generated/v1.d.ts +2186 -4
- package/build/main/generated/v1.js.map +1 -1
- package/build/module/generated/v1.d.ts +2186 -4
- package/build/module/generated/v1.js.map +1 -1
- package/package.json +1 -1
- package/src/generated/v1.ts +2186 -4
|
@@ -980,11 +980,158 @@ export interface paths {
|
|
|
980
980
|
get?: never;
|
|
981
981
|
put?: never;
|
|
982
982
|
/**
|
|
983
|
-
* @description Import a CSV
|
|
983
|
+
* @description Import a CSV; mapped bank records require this connection's signed upload
|
|
984
984
|
*
|
|
985
985
|
* Required scope: integrations:import
|
|
986
986
|
*/
|
|
987
|
-
post: operations["
|
|
987
|
+
post: operations["postConnectionsByIdCsvImport"];
|
|
988
|
+
delete?: never;
|
|
989
|
+
options?: never;
|
|
990
|
+
head?: never;
|
|
991
|
+
patch?: never;
|
|
992
|
+
trace?: never;
|
|
993
|
+
};
|
|
994
|
+
"/connections/{id}/csv-import/preview": {
|
|
995
|
+
parameters: {
|
|
996
|
+
query?: never;
|
|
997
|
+
header?: never;
|
|
998
|
+
path?: never;
|
|
999
|
+
cookie?: never;
|
|
1000
|
+
};
|
|
1001
|
+
get?: never;
|
|
1002
|
+
put?: never;
|
|
1003
|
+
/**
|
|
1004
|
+
* @description Start a bank-record CSV preview from this connection's signed upload
|
|
1005
|
+
*
|
|
1006
|
+
* Required scope: integrations:import
|
|
1007
|
+
*/
|
|
1008
|
+
post: operations["postConnectionsByIdCsvImportPreview"];
|
|
1009
|
+
delete?: never;
|
|
1010
|
+
options?: never;
|
|
1011
|
+
head?: never;
|
|
1012
|
+
patch?: never;
|
|
1013
|
+
trace?: never;
|
|
1014
|
+
};
|
|
1015
|
+
"/connections/{id}/csv-import/preview/{previewId}": {
|
|
1016
|
+
parameters: {
|
|
1017
|
+
query?: never;
|
|
1018
|
+
header?: never;
|
|
1019
|
+
path?: never;
|
|
1020
|
+
cookie?: never;
|
|
1021
|
+
};
|
|
1022
|
+
/**
|
|
1023
|
+
* @description Get a validated bank-record CSV preview result
|
|
1024
|
+
*
|
|
1025
|
+
* Required scope: integrations:import
|
|
1026
|
+
*/
|
|
1027
|
+
get: operations["getConnectionsByIdCsvImportPreviewByPreviewId"];
|
|
1028
|
+
put?: never;
|
|
1029
|
+
post?: never;
|
|
1030
|
+
delete?: never;
|
|
1031
|
+
options?: never;
|
|
1032
|
+
head?: never;
|
|
1033
|
+
patch?: never;
|
|
1034
|
+
trace?: never;
|
|
1035
|
+
};
|
|
1036
|
+
"/connections/{id}/csv-import/uploads": {
|
|
1037
|
+
parameters: {
|
|
1038
|
+
query?: never;
|
|
1039
|
+
header?: never;
|
|
1040
|
+
path?: never;
|
|
1041
|
+
cookie?: never;
|
|
1042
|
+
};
|
|
1043
|
+
get?: never;
|
|
1044
|
+
put?: never;
|
|
1045
|
+
/**
|
|
1046
|
+
* @description Start a size-bound multipart CSV import upload for this connection
|
|
1047
|
+
*
|
|
1048
|
+
* Required scope: integrations:import
|
|
1049
|
+
*/
|
|
1050
|
+
post: operations["postConnectionsByIdCsvImportUploads"];
|
|
1051
|
+
delete?: never;
|
|
1052
|
+
options?: never;
|
|
1053
|
+
head?: never;
|
|
1054
|
+
patch?: never;
|
|
1055
|
+
trace?: never;
|
|
1056
|
+
};
|
|
1057
|
+
"/connections/{id}/csv-import/uploads/{uploadRef}": {
|
|
1058
|
+
parameters: {
|
|
1059
|
+
query?: never;
|
|
1060
|
+
header?: never;
|
|
1061
|
+
path?: never;
|
|
1062
|
+
cookie?: never;
|
|
1063
|
+
};
|
|
1064
|
+
get?: never;
|
|
1065
|
+
put?: never;
|
|
1066
|
+
post?: never;
|
|
1067
|
+
/**
|
|
1068
|
+
* @description Abort a multipart CSV import upload
|
|
1069
|
+
*
|
|
1070
|
+
* Required scope: integrations:import
|
|
1071
|
+
*/
|
|
1072
|
+
delete: operations["deleteConnectionsByIdCsvImportUploadsByUploadRef"];
|
|
1073
|
+
options?: never;
|
|
1074
|
+
head?: never;
|
|
1075
|
+
patch?: never;
|
|
1076
|
+
trace?: never;
|
|
1077
|
+
};
|
|
1078
|
+
"/connections/{id}/csv-import/uploads/{uploadRef}/complete": {
|
|
1079
|
+
parameters: {
|
|
1080
|
+
query?: never;
|
|
1081
|
+
header?: never;
|
|
1082
|
+
path?: never;
|
|
1083
|
+
cookie?: never;
|
|
1084
|
+
};
|
|
1085
|
+
get?: never;
|
|
1086
|
+
put?: never;
|
|
1087
|
+
/**
|
|
1088
|
+
* @description Complete the full ordered multipart CSV import upload
|
|
1089
|
+
*
|
|
1090
|
+
* Required scope: integrations:import
|
|
1091
|
+
*/
|
|
1092
|
+
post: operations["postConnectionsByIdCsvImportUploadsByUploadRefComplete"];
|
|
1093
|
+
delete?: never;
|
|
1094
|
+
options?: never;
|
|
1095
|
+
head?: never;
|
|
1096
|
+
patch?: never;
|
|
1097
|
+
trace?: never;
|
|
1098
|
+
};
|
|
1099
|
+
"/connections/{id}/csv-import/uploads/{uploadRef}/parts/{partNumber}": {
|
|
1100
|
+
parameters: {
|
|
1101
|
+
query?: never;
|
|
1102
|
+
header?: never;
|
|
1103
|
+
path?: never;
|
|
1104
|
+
cookie?: never;
|
|
1105
|
+
};
|
|
1106
|
+
get?: never;
|
|
1107
|
+
/**
|
|
1108
|
+
* @description Upload one exact-size part of a multipart CSV import
|
|
1109
|
+
*
|
|
1110
|
+
* Required scope: integrations:import
|
|
1111
|
+
*/
|
|
1112
|
+
put: operations["putConnectionsByIdCsvImportUploadsByUploadRefPartsByPartNumber"];
|
|
1113
|
+
post?: never;
|
|
1114
|
+
delete?: never;
|
|
1115
|
+
options?: never;
|
|
1116
|
+
head?: never;
|
|
1117
|
+
patch?: never;
|
|
1118
|
+
trace?: never;
|
|
1119
|
+
};
|
|
1120
|
+
"/connections/{id}/csv-import/{syncId}": {
|
|
1121
|
+
parameters: {
|
|
1122
|
+
query?: never;
|
|
1123
|
+
header?: never;
|
|
1124
|
+
path?: never;
|
|
1125
|
+
cookie?: never;
|
|
1126
|
+
};
|
|
1127
|
+
/**
|
|
1128
|
+
* @description Get an asynchronous CSV import result
|
|
1129
|
+
*
|
|
1130
|
+
* Required scope: integrations:import
|
|
1131
|
+
*/
|
|
1132
|
+
get: operations["getConnectionsByIdCsvImportBySyncId"];
|
|
1133
|
+
put?: never;
|
|
1134
|
+
post?: never;
|
|
988
1135
|
delete?: never;
|
|
989
1136
|
options?: never;
|
|
990
1137
|
head?: never;
|
|
@@ -25428,7 +25575,7 @@ export interface operations {
|
|
|
25428
25575
|
};
|
|
25429
25576
|
};
|
|
25430
25577
|
};
|
|
25431
|
-
|
|
25578
|
+
postConnectionsByIdCsvImport: {
|
|
25432
25579
|
parameters: {
|
|
25433
25580
|
query?: never;
|
|
25434
25581
|
header?: never;
|
|
@@ -25447,6 +25594,36 @@ export interface operations {
|
|
|
25447
25594
|
params?: {
|
|
25448
25595
|
[key: string]: unknown;
|
|
25449
25596
|
};
|
|
25597
|
+
mapping?: {
|
|
25598
|
+
/** @constant */
|
|
25599
|
+
version: 1;
|
|
25600
|
+
/** @enum {string} */
|
|
25601
|
+
delimiter: "," | ";" | "\t" | "|";
|
|
25602
|
+
headerRow: number;
|
|
25603
|
+
date: {
|
|
25604
|
+
source?: string;
|
|
25605
|
+
/** @enum {string} */
|
|
25606
|
+
format?: "yyyy-mm-dd" | "mm/dd/yyyy" | "dd/mm/yyyy" | "dd.mm.yyyy";
|
|
25607
|
+
};
|
|
25608
|
+
description: {
|
|
25609
|
+
sources: string[];
|
|
25610
|
+
/** @constant */
|
|
25611
|
+
operation: "join";
|
|
25612
|
+
};
|
|
25613
|
+
amount: {
|
|
25614
|
+
/** @enum {string} */
|
|
25615
|
+
mode: "signed" | "debitCredit";
|
|
25616
|
+
source?: string;
|
|
25617
|
+
debit?: string;
|
|
25618
|
+
credit?: string;
|
|
25619
|
+
/** @constant */
|
|
25620
|
+
debitSign: -1;
|
|
25621
|
+
/** @constant */
|
|
25622
|
+
creditSign: 1;
|
|
25623
|
+
};
|
|
25624
|
+
excludedRows: number[];
|
|
25625
|
+
};
|
|
25626
|
+
sourceHash?: string;
|
|
25450
25627
|
};
|
|
25451
25628
|
};
|
|
25452
25629
|
};
|
|
@@ -25458,7 +25635,7 @@ export interface operations {
|
|
|
25458
25635
|
};
|
|
25459
25636
|
content: {
|
|
25460
25637
|
"application/json": {
|
|
25461
|
-
data: {
|
|
25638
|
+
data: ({
|
|
25462
25639
|
syncId: string;
|
|
25463
25640
|
/** @enum {string} */
|
|
25464
25641
|
status: "completed";
|
|
@@ -25471,6 +25648,2011 @@ export interface operations {
|
|
|
25471
25648
|
rowNumber: number;
|
|
25472
25649
|
message: string;
|
|
25473
25650
|
}[];
|
|
25651
|
+
}) | {
|
|
25652
|
+
syncId: string;
|
|
25653
|
+
/** @enum {string} */
|
|
25654
|
+
status: "queued";
|
|
25655
|
+
};
|
|
25656
|
+
};
|
|
25657
|
+
};
|
|
25658
|
+
};
|
|
25659
|
+
/** @description Bad request */
|
|
25660
|
+
400: {
|
|
25661
|
+
headers: {
|
|
25662
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
25663
|
+
"Retry-After"?: number;
|
|
25664
|
+
[name: string]: unknown;
|
|
25665
|
+
};
|
|
25666
|
+
content: {
|
|
25667
|
+
"application/json": {
|
|
25668
|
+
code: string;
|
|
25669
|
+
message: string;
|
|
25670
|
+
links?: {
|
|
25671
|
+
docs: string;
|
|
25672
|
+
schema: string;
|
|
25673
|
+
};
|
|
25674
|
+
issues?: {
|
|
25675
|
+
message: string;
|
|
25676
|
+
path?: (string | number)[];
|
|
25677
|
+
schema?: string;
|
|
25678
|
+
}[];
|
|
25679
|
+
retryable?: boolean;
|
|
25680
|
+
context?: unknown;
|
|
25681
|
+
};
|
|
25682
|
+
};
|
|
25683
|
+
};
|
|
25684
|
+
/** @description Unauthorized */
|
|
25685
|
+
401: {
|
|
25686
|
+
headers: {
|
|
25687
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
25688
|
+
"Retry-After"?: number;
|
|
25689
|
+
[name: string]: unknown;
|
|
25690
|
+
};
|
|
25691
|
+
content: {
|
|
25692
|
+
"application/json": {
|
|
25693
|
+
code: string;
|
|
25694
|
+
message: string;
|
|
25695
|
+
links?: {
|
|
25696
|
+
docs: string;
|
|
25697
|
+
schema: string;
|
|
25698
|
+
};
|
|
25699
|
+
issues?: {
|
|
25700
|
+
message: string;
|
|
25701
|
+
path?: (string | number)[];
|
|
25702
|
+
schema?: string;
|
|
25703
|
+
}[];
|
|
25704
|
+
retryable?: boolean;
|
|
25705
|
+
context?: unknown;
|
|
25706
|
+
};
|
|
25707
|
+
};
|
|
25708
|
+
};
|
|
25709
|
+
/** @description Forbidden */
|
|
25710
|
+
403: {
|
|
25711
|
+
headers: {
|
|
25712
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
25713
|
+
"Retry-After"?: number;
|
|
25714
|
+
[name: string]: unknown;
|
|
25715
|
+
};
|
|
25716
|
+
content: {
|
|
25717
|
+
"application/json": {
|
|
25718
|
+
code: string;
|
|
25719
|
+
message: string;
|
|
25720
|
+
links?: {
|
|
25721
|
+
docs: string;
|
|
25722
|
+
schema: string;
|
|
25723
|
+
};
|
|
25724
|
+
issues?: {
|
|
25725
|
+
message: string;
|
|
25726
|
+
path?: (string | number)[];
|
|
25727
|
+
schema?: string;
|
|
25728
|
+
}[];
|
|
25729
|
+
retryable?: boolean;
|
|
25730
|
+
context?: unknown;
|
|
25731
|
+
};
|
|
25732
|
+
};
|
|
25733
|
+
};
|
|
25734
|
+
/** @description Not found */
|
|
25735
|
+
404: {
|
|
25736
|
+
headers: {
|
|
25737
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
25738
|
+
"Retry-After"?: number;
|
|
25739
|
+
[name: string]: unknown;
|
|
25740
|
+
};
|
|
25741
|
+
content: {
|
|
25742
|
+
"application/json": {
|
|
25743
|
+
code: string;
|
|
25744
|
+
message: string;
|
|
25745
|
+
links?: {
|
|
25746
|
+
docs: string;
|
|
25747
|
+
schema: string;
|
|
25748
|
+
};
|
|
25749
|
+
issues?: {
|
|
25750
|
+
message: string;
|
|
25751
|
+
path?: (string | number)[];
|
|
25752
|
+
schema?: string;
|
|
25753
|
+
}[];
|
|
25754
|
+
retryable?: boolean;
|
|
25755
|
+
context?: unknown;
|
|
25756
|
+
};
|
|
25757
|
+
};
|
|
25758
|
+
};
|
|
25759
|
+
/** @description Conflict */
|
|
25760
|
+
409: {
|
|
25761
|
+
headers: {
|
|
25762
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
25763
|
+
"Retry-After"?: number;
|
|
25764
|
+
[name: string]: unknown;
|
|
25765
|
+
};
|
|
25766
|
+
content: {
|
|
25767
|
+
"application/json": {
|
|
25768
|
+
code: string;
|
|
25769
|
+
message: string;
|
|
25770
|
+
links?: {
|
|
25771
|
+
docs: string;
|
|
25772
|
+
schema: string;
|
|
25773
|
+
};
|
|
25774
|
+
issues?: {
|
|
25775
|
+
message: string;
|
|
25776
|
+
path?: (string | number)[];
|
|
25777
|
+
schema?: string;
|
|
25778
|
+
}[];
|
|
25779
|
+
retryable?: boolean;
|
|
25780
|
+
context?: unknown;
|
|
25781
|
+
};
|
|
25782
|
+
};
|
|
25783
|
+
};
|
|
25784
|
+
/** @description Gone */
|
|
25785
|
+
410: {
|
|
25786
|
+
headers: {
|
|
25787
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
25788
|
+
"Retry-After"?: number;
|
|
25789
|
+
[name: string]: unknown;
|
|
25790
|
+
};
|
|
25791
|
+
content: {
|
|
25792
|
+
"application/json": {
|
|
25793
|
+
code: string;
|
|
25794
|
+
message: string;
|
|
25795
|
+
links?: {
|
|
25796
|
+
docs: string;
|
|
25797
|
+
schema: string;
|
|
25798
|
+
};
|
|
25799
|
+
issues?: {
|
|
25800
|
+
message: string;
|
|
25801
|
+
path?: (string | number)[];
|
|
25802
|
+
schema?: string;
|
|
25803
|
+
}[];
|
|
25804
|
+
retryable?: boolean;
|
|
25805
|
+
context?: unknown;
|
|
25806
|
+
};
|
|
25807
|
+
};
|
|
25808
|
+
};
|
|
25809
|
+
/** @description Unprocessable content */
|
|
25810
|
+
422: {
|
|
25811
|
+
headers: {
|
|
25812
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
25813
|
+
"Retry-After"?: number;
|
|
25814
|
+
[name: string]: unknown;
|
|
25815
|
+
};
|
|
25816
|
+
content: {
|
|
25817
|
+
"application/json": {
|
|
25818
|
+
code: string;
|
|
25819
|
+
message: string;
|
|
25820
|
+
links?: {
|
|
25821
|
+
docs: string;
|
|
25822
|
+
schema: string;
|
|
25823
|
+
};
|
|
25824
|
+
issues?: {
|
|
25825
|
+
message: string;
|
|
25826
|
+
path?: (string | number)[];
|
|
25827
|
+
schema?: string;
|
|
25828
|
+
}[];
|
|
25829
|
+
retryable?: boolean;
|
|
25830
|
+
context?: unknown;
|
|
25831
|
+
};
|
|
25832
|
+
};
|
|
25833
|
+
};
|
|
25834
|
+
/** @description Internal server error */
|
|
25835
|
+
500: {
|
|
25836
|
+
headers: {
|
|
25837
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
25838
|
+
"Retry-After"?: number;
|
|
25839
|
+
[name: string]: unknown;
|
|
25840
|
+
};
|
|
25841
|
+
content: {
|
|
25842
|
+
"application/json": {
|
|
25843
|
+
code: string;
|
|
25844
|
+
message: string;
|
|
25845
|
+
links?: {
|
|
25846
|
+
docs: string;
|
|
25847
|
+
schema: string;
|
|
25848
|
+
};
|
|
25849
|
+
issues?: {
|
|
25850
|
+
message: string;
|
|
25851
|
+
path?: (string | number)[];
|
|
25852
|
+
schema?: string;
|
|
25853
|
+
}[];
|
|
25854
|
+
retryable?: boolean;
|
|
25855
|
+
context?: unknown;
|
|
25856
|
+
};
|
|
25857
|
+
};
|
|
25858
|
+
};
|
|
25859
|
+
/** @description Service unavailable */
|
|
25860
|
+
503: {
|
|
25861
|
+
headers: {
|
|
25862
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
25863
|
+
"Retry-After"?: number;
|
|
25864
|
+
[name: string]: unknown;
|
|
25865
|
+
};
|
|
25866
|
+
content: {
|
|
25867
|
+
"application/json": {
|
|
25868
|
+
code: string;
|
|
25869
|
+
message: string;
|
|
25870
|
+
links?: {
|
|
25871
|
+
docs: string;
|
|
25872
|
+
schema: string;
|
|
25873
|
+
};
|
|
25874
|
+
issues?: {
|
|
25875
|
+
message: string;
|
|
25876
|
+
path?: (string | number)[];
|
|
25877
|
+
schema?: string;
|
|
25878
|
+
}[];
|
|
25879
|
+
retryable?: boolean;
|
|
25880
|
+
context?: unknown;
|
|
25881
|
+
};
|
|
25882
|
+
};
|
|
25883
|
+
};
|
|
25884
|
+
};
|
|
25885
|
+
};
|
|
25886
|
+
postConnectionsByIdCsvImportPreview: {
|
|
25887
|
+
parameters: {
|
|
25888
|
+
query?: never;
|
|
25889
|
+
header?: never;
|
|
25890
|
+
path: {
|
|
25891
|
+
id: string;
|
|
25892
|
+
};
|
|
25893
|
+
cookie?: never;
|
|
25894
|
+
};
|
|
25895
|
+
requestBody?: {
|
|
25896
|
+
content: {
|
|
25897
|
+
"application/json": {
|
|
25898
|
+
/** Format: uri */
|
|
25899
|
+
fileUri: string;
|
|
25900
|
+
mapping?: {
|
|
25901
|
+
/** @constant */
|
|
25902
|
+
version: 1;
|
|
25903
|
+
/** @enum {string} */
|
|
25904
|
+
delimiter: "," | ";" | "\t" | "|";
|
|
25905
|
+
headerRow: number;
|
|
25906
|
+
date: {
|
|
25907
|
+
source?: string;
|
|
25908
|
+
/** @enum {string} */
|
|
25909
|
+
format?: "yyyy-mm-dd" | "mm/dd/yyyy" | "dd/mm/yyyy" | "dd.mm.yyyy";
|
|
25910
|
+
};
|
|
25911
|
+
description: {
|
|
25912
|
+
sources: string[];
|
|
25913
|
+
/** @constant */
|
|
25914
|
+
operation: "join";
|
|
25915
|
+
};
|
|
25916
|
+
amount: {
|
|
25917
|
+
/** @enum {string} */
|
|
25918
|
+
mode: "signed" | "debitCredit";
|
|
25919
|
+
source?: string;
|
|
25920
|
+
debit?: string;
|
|
25921
|
+
credit?: string;
|
|
25922
|
+
/** @constant */
|
|
25923
|
+
debitSign: -1;
|
|
25924
|
+
/** @constant */
|
|
25925
|
+
creditSign: 1;
|
|
25926
|
+
};
|
|
25927
|
+
excludedRows: number[];
|
|
25928
|
+
};
|
|
25929
|
+
};
|
|
25930
|
+
};
|
|
25931
|
+
};
|
|
25932
|
+
responses: {
|
|
25933
|
+
/** @description Successful response */
|
|
25934
|
+
200: {
|
|
25935
|
+
headers: {
|
|
25936
|
+
[name: string]: unknown;
|
|
25937
|
+
};
|
|
25938
|
+
content: {
|
|
25939
|
+
"application/json": {
|
|
25940
|
+
data: {
|
|
25941
|
+
/** @constant */
|
|
25942
|
+
status: "queued";
|
|
25943
|
+
/** Format: uuid */
|
|
25944
|
+
previewId: string;
|
|
25945
|
+
/** Format: uuid */
|
|
25946
|
+
syncId: string;
|
|
25947
|
+
} | {
|
|
25948
|
+
/** @constant */
|
|
25949
|
+
status: "processing";
|
|
25950
|
+
/** Format: uuid */
|
|
25951
|
+
previewId: string;
|
|
25952
|
+
/** Format: uuid */
|
|
25953
|
+
syncId: string;
|
|
25954
|
+
} | {
|
|
25955
|
+
/** @constant */
|
|
25956
|
+
status: "completed";
|
|
25957
|
+
/** Format: uuid */
|
|
25958
|
+
previewId: string;
|
|
25959
|
+
/** Format: uuid */
|
|
25960
|
+
syncId: string;
|
|
25961
|
+
result: {
|
|
25962
|
+
canImport: boolean;
|
|
25963
|
+
columns: string[];
|
|
25964
|
+
issues: {
|
|
25965
|
+
rowNumber: number;
|
|
25966
|
+
message: string;
|
|
25967
|
+
}[];
|
|
25968
|
+
mapping: {
|
|
25969
|
+
/** @constant */
|
|
25970
|
+
version: 1;
|
|
25971
|
+
/** @enum {string} */
|
|
25972
|
+
delimiter: "," | ";" | "\t" | "|";
|
|
25973
|
+
headerRow: number;
|
|
25974
|
+
date: {
|
|
25975
|
+
source?: string;
|
|
25976
|
+
/** @enum {string} */
|
|
25977
|
+
format?: "yyyy-mm-dd" | "mm/dd/yyyy" | "dd/mm/yyyy" | "dd.mm.yyyy";
|
|
25978
|
+
};
|
|
25979
|
+
description: {
|
|
25980
|
+
sources: string[];
|
|
25981
|
+
/** @constant */
|
|
25982
|
+
operation: "join";
|
|
25983
|
+
};
|
|
25984
|
+
amount: {
|
|
25985
|
+
/** @enum {string} */
|
|
25986
|
+
mode: "signed" | "debitCredit";
|
|
25987
|
+
source?: string;
|
|
25988
|
+
debit?: string;
|
|
25989
|
+
credit?: string;
|
|
25990
|
+
/** @constant */
|
|
25991
|
+
debitSign: -1;
|
|
25992
|
+
/** @constant */
|
|
25993
|
+
creditSign: 1;
|
|
25994
|
+
};
|
|
25995
|
+
excludedRows: number[];
|
|
25996
|
+
};
|
|
25997
|
+
sampleRows: {
|
|
25998
|
+
rowNumber: number;
|
|
25999
|
+
source: {
|
|
26000
|
+
[key: string]: string | null;
|
|
26001
|
+
};
|
|
26002
|
+
transformed?: {
|
|
26003
|
+
Date: string;
|
|
26004
|
+
Description: string;
|
|
26005
|
+
Amount: number;
|
|
26006
|
+
};
|
|
26007
|
+
}[];
|
|
26008
|
+
sourceHash: string;
|
|
26009
|
+
totals: {
|
|
26010
|
+
rows: number;
|
|
26011
|
+
valid: number;
|
|
26012
|
+
invalid: number;
|
|
26013
|
+
excluded: number;
|
|
26014
|
+
moneyIn: number;
|
|
26015
|
+
moneyOut: number;
|
|
26016
|
+
net: number;
|
|
26017
|
+
};
|
|
26018
|
+
};
|
|
26019
|
+
} | {
|
|
26020
|
+
/** @constant */
|
|
26021
|
+
status: "failed";
|
|
26022
|
+
/** Format: uuid */
|
|
26023
|
+
previewId: string;
|
|
26024
|
+
/** Format: uuid */
|
|
26025
|
+
syncId: string;
|
|
26026
|
+
error: string;
|
|
26027
|
+
};
|
|
26028
|
+
};
|
|
26029
|
+
};
|
|
26030
|
+
};
|
|
26031
|
+
/** @description Bad request */
|
|
26032
|
+
400: {
|
|
26033
|
+
headers: {
|
|
26034
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26035
|
+
"Retry-After"?: number;
|
|
26036
|
+
[name: string]: unknown;
|
|
26037
|
+
};
|
|
26038
|
+
content: {
|
|
26039
|
+
"application/json": {
|
|
26040
|
+
code: string;
|
|
26041
|
+
message: string;
|
|
26042
|
+
links?: {
|
|
26043
|
+
docs: string;
|
|
26044
|
+
schema: string;
|
|
26045
|
+
};
|
|
26046
|
+
issues?: {
|
|
26047
|
+
message: string;
|
|
26048
|
+
path?: (string | number)[];
|
|
26049
|
+
schema?: string;
|
|
26050
|
+
}[];
|
|
26051
|
+
retryable?: boolean;
|
|
26052
|
+
context?: unknown;
|
|
26053
|
+
};
|
|
26054
|
+
};
|
|
26055
|
+
};
|
|
26056
|
+
/** @description Unauthorized */
|
|
26057
|
+
401: {
|
|
26058
|
+
headers: {
|
|
26059
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26060
|
+
"Retry-After"?: number;
|
|
26061
|
+
[name: string]: unknown;
|
|
26062
|
+
};
|
|
26063
|
+
content: {
|
|
26064
|
+
"application/json": {
|
|
26065
|
+
code: string;
|
|
26066
|
+
message: string;
|
|
26067
|
+
links?: {
|
|
26068
|
+
docs: string;
|
|
26069
|
+
schema: string;
|
|
26070
|
+
};
|
|
26071
|
+
issues?: {
|
|
26072
|
+
message: string;
|
|
26073
|
+
path?: (string | number)[];
|
|
26074
|
+
schema?: string;
|
|
26075
|
+
}[];
|
|
26076
|
+
retryable?: boolean;
|
|
26077
|
+
context?: unknown;
|
|
26078
|
+
};
|
|
26079
|
+
};
|
|
26080
|
+
};
|
|
26081
|
+
/** @description Forbidden */
|
|
26082
|
+
403: {
|
|
26083
|
+
headers: {
|
|
26084
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26085
|
+
"Retry-After"?: number;
|
|
26086
|
+
[name: string]: unknown;
|
|
26087
|
+
};
|
|
26088
|
+
content: {
|
|
26089
|
+
"application/json": {
|
|
26090
|
+
code: string;
|
|
26091
|
+
message: string;
|
|
26092
|
+
links?: {
|
|
26093
|
+
docs: string;
|
|
26094
|
+
schema: string;
|
|
26095
|
+
};
|
|
26096
|
+
issues?: {
|
|
26097
|
+
message: string;
|
|
26098
|
+
path?: (string | number)[];
|
|
26099
|
+
schema?: string;
|
|
26100
|
+
}[];
|
|
26101
|
+
retryable?: boolean;
|
|
26102
|
+
context?: unknown;
|
|
26103
|
+
};
|
|
26104
|
+
};
|
|
26105
|
+
};
|
|
26106
|
+
/** @description Not found */
|
|
26107
|
+
404: {
|
|
26108
|
+
headers: {
|
|
26109
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26110
|
+
"Retry-After"?: number;
|
|
26111
|
+
[name: string]: unknown;
|
|
26112
|
+
};
|
|
26113
|
+
content: {
|
|
26114
|
+
"application/json": {
|
|
26115
|
+
code: string;
|
|
26116
|
+
message: string;
|
|
26117
|
+
links?: {
|
|
26118
|
+
docs: string;
|
|
26119
|
+
schema: string;
|
|
26120
|
+
};
|
|
26121
|
+
issues?: {
|
|
26122
|
+
message: string;
|
|
26123
|
+
path?: (string | number)[];
|
|
26124
|
+
schema?: string;
|
|
26125
|
+
}[];
|
|
26126
|
+
retryable?: boolean;
|
|
26127
|
+
context?: unknown;
|
|
26128
|
+
};
|
|
26129
|
+
};
|
|
26130
|
+
};
|
|
26131
|
+
/** @description Conflict */
|
|
26132
|
+
409: {
|
|
26133
|
+
headers: {
|
|
26134
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26135
|
+
"Retry-After"?: number;
|
|
26136
|
+
[name: string]: unknown;
|
|
26137
|
+
};
|
|
26138
|
+
content: {
|
|
26139
|
+
"application/json": {
|
|
26140
|
+
code: string;
|
|
26141
|
+
message: string;
|
|
26142
|
+
links?: {
|
|
26143
|
+
docs: string;
|
|
26144
|
+
schema: string;
|
|
26145
|
+
};
|
|
26146
|
+
issues?: {
|
|
26147
|
+
message: string;
|
|
26148
|
+
path?: (string | number)[];
|
|
26149
|
+
schema?: string;
|
|
26150
|
+
}[];
|
|
26151
|
+
retryable?: boolean;
|
|
26152
|
+
context?: unknown;
|
|
26153
|
+
};
|
|
26154
|
+
};
|
|
26155
|
+
};
|
|
26156
|
+
/** @description Gone */
|
|
26157
|
+
410: {
|
|
26158
|
+
headers: {
|
|
26159
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26160
|
+
"Retry-After"?: number;
|
|
26161
|
+
[name: string]: unknown;
|
|
26162
|
+
};
|
|
26163
|
+
content: {
|
|
26164
|
+
"application/json": {
|
|
26165
|
+
code: string;
|
|
26166
|
+
message: string;
|
|
26167
|
+
links?: {
|
|
26168
|
+
docs: string;
|
|
26169
|
+
schema: string;
|
|
26170
|
+
};
|
|
26171
|
+
issues?: {
|
|
26172
|
+
message: string;
|
|
26173
|
+
path?: (string | number)[];
|
|
26174
|
+
schema?: string;
|
|
26175
|
+
}[];
|
|
26176
|
+
retryable?: boolean;
|
|
26177
|
+
context?: unknown;
|
|
26178
|
+
};
|
|
26179
|
+
};
|
|
26180
|
+
};
|
|
26181
|
+
/** @description Unprocessable content */
|
|
26182
|
+
422: {
|
|
26183
|
+
headers: {
|
|
26184
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26185
|
+
"Retry-After"?: number;
|
|
26186
|
+
[name: string]: unknown;
|
|
26187
|
+
};
|
|
26188
|
+
content: {
|
|
26189
|
+
"application/json": {
|
|
26190
|
+
code: string;
|
|
26191
|
+
message: string;
|
|
26192
|
+
links?: {
|
|
26193
|
+
docs: string;
|
|
26194
|
+
schema: string;
|
|
26195
|
+
};
|
|
26196
|
+
issues?: {
|
|
26197
|
+
message: string;
|
|
26198
|
+
path?: (string | number)[];
|
|
26199
|
+
schema?: string;
|
|
26200
|
+
}[];
|
|
26201
|
+
retryable?: boolean;
|
|
26202
|
+
context?: unknown;
|
|
26203
|
+
};
|
|
26204
|
+
};
|
|
26205
|
+
};
|
|
26206
|
+
/** @description Internal server error */
|
|
26207
|
+
500: {
|
|
26208
|
+
headers: {
|
|
26209
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26210
|
+
"Retry-After"?: number;
|
|
26211
|
+
[name: string]: unknown;
|
|
26212
|
+
};
|
|
26213
|
+
content: {
|
|
26214
|
+
"application/json": {
|
|
26215
|
+
code: string;
|
|
26216
|
+
message: string;
|
|
26217
|
+
links?: {
|
|
26218
|
+
docs: string;
|
|
26219
|
+
schema: string;
|
|
26220
|
+
};
|
|
26221
|
+
issues?: {
|
|
26222
|
+
message: string;
|
|
26223
|
+
path?: (string | number)[];
|
|
26224
|
+
schema?: string;
|
|
26225
|
+
}[];
|
|
26226
|
+
retryable?: boolean;
|
|
26227
|
+
context?: unknown;
|
|
26228
|
+
};
|
|
26229
|
+
};
|
|
26230
|
+
};
|
|
26231
|
+
/** @description Service unavailable */
|
|
26232
|
+
503: {
|
|
26233
|
+
headers: {
|
|
26234
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26235
|
+
"Retry-After"?: number;
|
|
26236
|
+
[name: string]: unknown;
|
|
26237
|
+
};
|
|
26238
|
+
content: {
|
|
26239
|
+
"application/json": {
|
|
26240
|
+
code: string;
|
|
26241
|
+
message: string;
|
|
26242
|
+
links?: {
|
|
26243
|
+
docs: string;
|
|
26244
|
+
schema: string;
|
|
26245
|
+
};
|
|
26246
|
+
issues?: {
|
|
26247
|
+
message: string;
|
|
26248
|
+
path?: (string | number)[];
|
|
26249
|
+
schema?: string;
|
|
26250
|
+
}[];
|
|
26251
|
+
retryable?: boolean;
|
|
26252
|
+
context?: unknown;
|
|
26253
|
+
};
|
|
26254
|
+
};
|
|
26255
|
+
};
|
|
26256
|
+
};
|
|
26257
|
+
};
|
|
26258
|
+
getConnectionsByIdCsvImportPreviewByPreviewId: {
|
|
26259
|
+
parameters: {
|
|
26260
|
+
query?: never;
|
|
26261
|
+
header?: never;
|
|
26262
|
+
path: {
|
|
26263
|
+
id: string;
|
|
26264
|
+
previewId: string;
|
|
26265
|
+
};
|
|
26266
|
+
cookie?: never;
|
|
26267
|
+
};
|
|
26268
|
+
requestBody?: never;
|
|
26269
|
+
responses: {
|
|
26270
|
+
/** @description Successful response */
|
|
26271
|
+
200: {
|
|
26272
|
+
headers: {
|
|
26273
|
+
[name: string]: unknown;
|
|
26274
|
+
};
|
|
26275
|
+
content: {
|
|
26276
|
+
"application/json": {
|
|
26277
|
+
data: {
|
|
26278
|
+
/** @constant */
|
|
26279
|
+
status: "queued";
|
|
26280
|
+
/** Format: uuid */
|
|
26281
|
+
previewId: string;
|
|
26282
|
+
/** Format: uuid */
|
|
26283
|
+
syncId: string;
|
|
26284
|
+
} | {
|
|
26285
|
+
/** @constant */
|
|
26286
|
+
status: "processing";
|
|
26287
|
+
/** Format: uuid */
|
|
26288
|
+
previewId: string;
|
|
26289
|
+
/** Format: uuid */
|
|
26290
|
+
syncId: string;
|
|
26291
|
+
} | {
|
|
26292
|
+
/** @constant */
|
|
26293
|
+
status: "completed";
|
|
26294
|
+
/** Format: uuid */
|
|
26295
|
+
previewId: string;
|
|
26296
|
+
/** Format: uuid */
|
|
26297
|
+
syncId: string;
|
|
26298
|
+
result: {
|
|
26299
|
+
canImport: boolean;
|
|
26300
|
+
columns: string[];
|
|
26301
|
+
issues: {
|
|
26302
|
+
rowNumber: number;
|
|
26303
|
+
message: string;
|
|
26304
|
+
}[];
|
|
26305
|
+
mapping: {
|
|
26306
|
+
/** @constant */
|
|
26307
|
+
version: 1;
|
|
26308
|
+
/** @enum {string} */
|
|
26309
|
+
delimiter: "," | ";" | "\t" | "|";
|
|
26310
|
+
headerRow: number;
|
|
26311
|
+
date: {
|
|
26312
|
+
source?: string;
|
|
26313
|
+
/** @enum {string} */
|
|
26314
|
+
format?: "yyyy-mm-dd" | "mm/dd/yyyy" | "dd/mm/yyyy" | "dd.mm.yyyy";
|
|
26315
|
+
};
|
|
26316
|
+
description: {
|
|
26317
|
+
sources: string[];
|
|
26318
|
+
/** @constant */
|
|
26319
|
+
operation: "join";
|
|
26320
|
+
};
|
|
26321
|
+
amount: {
|
|
26322
|
+
/** @enum {string} */
|
|
26323
|
+
mode: "signed" | "debitCredit";
|
|
26324
|
+
source?: string;
|
|
26325
|
+
debit?: string;
|
|
26326
|
+
credit?: string;
|
|
26327
|
+
/** @constant */
|
|
26328
|
+
debitSign: -1;
|
|
26329
|
+
/** @constant */
|
|
26330
|
+
creditSign: 1;
|
|
26331
|
+
};
|
|
26332
|
+
excludedRows: number[];
|
|
26333
|
+
};
|
|
26334
|
+
sampleRows: {
|
|
26335
|
+
rowNumber: number;
|
|
26336
|
+
source: {
|
|
26337
|
+
[key: string]: string | null;
|
|
26338
|
+
};
|
|
26339
|
+
transformed?: {
|
|
26340
|
+
Date: string;
|
|
26341
|
+
Description: string;
|
|
26342
|
+
Amount: number;
|
|
26343
|
+
};
|
|
26344
|
+
}[];
|
|
26345
|
+
sourceHash: string;
|
|
26346
|
+
totals: {
|
|
26347
|
+
rows: number;
|
|
26348
|
+
valid: number;
|
|
26349
|
+
invalid: number;
|
|
26350
|
+
excluded: number;
|
|
26351
|
+
moneyIn: number;
|
|
26352
|
+
moneyOut: number;
|
|
26353
|
+
net: number;
|
|
26354
|
+
};
|
|
26355
|
+
};
|
|
26356
|
+
} | {
|
|
26357
|
+
/** @constant */
|
|
26358
|
+
status: "failed";
|
|
26359
|
+
/** Format: uuid */
|
|
26360
|
+
previewId: string;
|
|
26361
|
+
/** Format: uuid */
|
|
26362
|
+
syncId: string;
|
|
26363
|
+
error: string;
|
|
26364
|
+
};
|
|
26365
|
+
};
|
|
26366
|
+
};
|
|
26367
|
+
};
|
|
26368
|
+
/** @description Bad request */
|
|
26369
|
+
400: {
|
|
26370
|
+
headers: {
|
|
26371
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26372
|
+
"Retry-After"?: number;
|
|
26373
|
+
[name: string]: unknown;
|
|
26374
|
+
};
|
|
26375
|
+
content: {
|
|
26376
|
+
"application/json": {
|
|
26377
|
+
code: string;
|
|
26378
|
+
message: string;
|
|
26379
|
+
links?: {
|
|
26380
|
+
docs: string;
|
|
26381
|
+
schema: string;
|
|
26382
|
+
};
|
|
26383
|
+
issues?: {
|
|
26384
|
+
message: string;
|
|
26385
|
+
path?: (string | number)[];
|
|
26386
|
+
schema?: string;
|
|
26387
|
+
}[];
|
|
26388
|
+
retryable?: boolean;
|
|
26389
|
+
context?: unknown;
|
|
26390
|
+
};
|
|
26391
|
+
};
|
|
26392
|
+
};
|
|
26393
|
+
/** @description Unauthorized */
|
|
26394
|
+
401: {
|
|
26395
|
+
headers: {
|
|
26396
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26397
|
+
"Retry-After"?: number;
|
|
26398
|
+
[name: string]: unknown;
|
|
26399
|
+
};
|
|
26400
|
+
content: {
|
|
26401
|
+
"application/json": {
|
|
26402
|
+
code: string;
|
|
26403
|
+
message: string;
|
|
26404
|
+
links?: {
|
|
26405
|
+
docs: string;
|
|
26406
|
+
schema: string;
|
|
26407
|
+
};
|
|
26408
|
+
issues?: {
|
|
26409
|
+
message: string;
|
|
26410
|
+
path?: (string | number)[];
|
|
26411
|
+
schema?: string;
|
|
26412
|
+
}[];
|
|
26413
|
+
retryable?: boolean;
|
|
26414
|
+
context?: unknown;
|
|
26415
|
+
};
|
|
26416
|
+
};
|
|
26417
|
+
};
|
|
26418
|
+
/** @description Forbidden */
|
|
26419
|
+
403: {
|
|
26420
|
+
headers: {
|
|
26421
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26422
|
+
"Retry-After"?: number;
|
|
26423
|
+
[name: string]: unknown;
|
|
26424
|
+
};
|
|
26425
|
+
content: {
|
|
26426
|
+
"application/json": {
|
|
26427
|
+
code: string;
|
|
26428
|
+
message: string;
|
|
26429
|
+
links?: {
|
|
26430
|
+
docs: string;
|
|
26431
|
+
schema: string;
|
|
26432
|
+
};
|
|
26433
|
+
issues?: {
|
|
26434
|
+
message: string;
|
|
26435
|
+
path?: (string | number)[];
|
|
26436
|
+
schema?: string;
|
|
26437
|
+
}[];
|
|
26438
|
+
retryable?: boolean;
|
|
26439
|
+
context?: unknown;
|
|
26440
|
+
};
|
|
26441
|
+
};
|
|
26442
|
+
};
|
|
26443
|
+
/** @description Not found */
|
|
26444
|
+
404: {
|
|
26445
|
+
headers: {
|
|
26446
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26447
|
+
"Retry-After"?: number;
|
|
26448
|
+
[name: string]: unknown;
|
|
26449
|
+
};
|
|
26450
|
+
content: {
|
|
26451
|
+
"application/json": {
|
|
26452
|
+
code: string;
|
|
26453
|
+
message: string;
|
|
26454
|
+
links?: {
|
|
26455
|
+
docs: string;
|
|
26456
|
+
schema: string;
|
|
26457
|
+
};
|
|
26458
|
+
issues?: {
|
|
26459
|
+
message: string;
|
|
26460
|
+
path?: (string | number)[];
|
|
26461
|
+
schema?: string;
|
|
26462
|
+
}[];
|
|
26463
|
+
retryable?: boolean;
|
|
26464
|
+
context?: unknown;
|
|
26465
|
+
};
|
|
26466
|
+
};
|
|
26467
|
+
};
|
|
26468
|
+
/** @description Conflict */
|
|
26469
|
+
409: {
|
|
26470
|
+
headers: {
|
|
26471
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26472
|
+
"Retry-After"?: number;
|
|
26473
|
+
[name: string]: unknown;
|
|
26474
|
+
};
|
|
26475
|
+
content: {
|
|
26476
|
+
"application/json": {
|
|
26477
|
+
code: string;
|
|
26478
|
+
message: string;
|
|
26479
|
+
links?: {
|
|
26480
|
+
docs: string;
|
|
26481
|
+
schema: string;
|
|
26482
|
+
};
|
|
26483
|
+
issues?: {
|
|
26484
|
+
message: string;
|
|
26485
|
+
path?: (string | number)[];
|
|
26486
|
+
schema?: string;
|
|
26487
|
+
}[];
|
|
26488
|
+
retryable?: boolean;
|
|
26489
|
+
context?: unknown;
|
|
26490
|
+
};
|
|
26491
|
+
};
|
|
26492
|
+
};
|
|
26493
|
+
/** @description Gone */
|
|
26494
|
+
410: {
|
|
26495
|
+
headers: {
|
|
26496
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26497
|
+
"Retry-After"?: number;
|
|
26498
|
+
[name: string]: unknown;
|
|
26499
|
+
};
|
|
26500
|
+
content: {
|
|
26501
|
+
"application/json": {
|
|
26502
|
+
code: string;
|
|
26503
|
+
message: string;
|
|
26504
|
+
links?: {
|
|
26505
|
+
docs: string;
|
|
26506
|
+
schema: string;
|
|
26507
|
+
};
|
|
26508
|
+
issues?: {
|
|
26509
|
+
message: string;
|
|
26510
|
+
path?: (string | number)[];
|
|
26511
|
+
schema?: string;
|
|
26512
|
+
}[];
|
|
26513
|
+
retryable?: boolean;
|
|
26514
|
+
context?: unknown;
|
|
26515
|
+
};
|
|
26516
|
+
};
|
|
26517
|
+
};
|
|
26518
|
+
/** @description Unprocessable content */
|
|
26519
|
+
422: {
|
|
26520
|
+
headers: {
|
|
26521
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26522
|
+
"Retry-After"?: number;
|
|
26523
|
+
[name: string]: unknown;
|
|
26524
|
+
};
|
|
26525
|
+
content: {
|
|
26526
|
+
"application/json": {
|
|
26527
|
+
code: string;
|
|
26528
|
+
message: string;
|
|
26529
|
+
links?: {
|
|
26530
|
+
docs: string;
|
|
26531
|
+
schema: string;
|
|
26532
|
+
};
|
|
26533
|
+
issues?: {
|
|
26534
|
+
message: string;
|
|
26535
|
+
path?: (string | number)[];
|
|
26536
|
+
schema?: string;
|
|
26537
|
+
}[];
|
|
26538
|
+
retryable?: boolean;
|
|
26539
|
+
context?: unknown;
|
|
26540
|
+
};
|
|
26541
|
+
};
|
|
26542
|
+
};
|
|
26543
|
+
/** @description Internal server error */
|
|
26544
|
+
500: {
|
|
26545
|
+
headers: {
|
|
26546
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26547
|
+
"Retry-After"?: number;
|
|
26548
|
+
[name: string]: unknown;
|
|
26549
|
+
};
|
|
26550
|
+
content: {
|
|
26551
|
+
"application/json": {
|
|
26552
|
+
code: string;
|
|
26553
|
+
message: string;
|
|
26554
|
+
links?: {
|
|
26555
|
+
docs: string;
|
|
26556
|
+
schema: string;
|
|
26557
|
+
};
|
|
26558
|
+
issues?: {
|
|
26559
|
+
message: string;
|
|
26560
|
+
path?: (string | number)[];
|
|
26561
|
+
schema?: string;
|
|
26562
|
+
}[];
|
|
26563
|
+
retryable?: boolean;
|
|
26564
|
+
context?: unknown;
|
|
26565
|
+
};
|
|
26566
|
+
};
|
|
26567
|
+
};
|
|
26568
|
+
/** @description Service unavailable */
|
|
26569
|
+
503: {
|
|
26570
|
+
headers: {
|
|
26571
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26572
|
+
"Retry-After"?: number;
|
|
26573
|
+
[name: string]: unknown;
|
|
26574
|
+
};
|
|
26575
|
+
content: {
|
|
26576
|
+
"application/json": {
|
|
26577
|
+
code: string;
|
|
26578
|
+
message: string;
|
|
26579
|
+
links?: {
|
|
26580
|
+
docs: string;
|
|
26581
|
+
schema: string;
|
|
26582
|
+
};
|
|
26583
|
+
issues?: {
|
|
26584
|
+
message: string;
|
|
26585
|
+
path?: (string | number)[];
|
|
26586
|
+
schema?: string;
|
|
26587
|
+
}[];
|
|
26588
|
+
retryable?: boolean;
|
|
26589
|
+
context?: unknown;
|
|
26590
|
+
};
|
|
26591
|
+
};
|
|
26592
|
+
};
|
|
26593
|
+
};
|
|
26594
|
+
};
|
|
26595
|
+
postConnectionsByIdCsvImportUploads: {
|
|
26596
|
+
parameters: {
|
|
26597
|
+
query?: never;
|
|
26598
|
+
header?: never;
|
|
26599
|
+
path: {
|
|
26600
|
+
id: string;
|
|
26601
|
+
};
|
|
26602
|
+
cookie?: never;
|
|
26603
|
+
};
|
|
26604
|
+
requestBody?: {
|
|
26605
|
+
content: {
|
|
26606
|
+
"application/json": {
|
|
26607
|
+
fileName: string;
|
|
26608
|
+
fileSize: number;
|
|
26609
|
+
};
|
|
26610
|
+
};
|
|
26611
|
+
};
|
|
26612
|
+
responses: {
|
|
26613
|
+
/** @description Successful response */
|
|
26614
|
+
200: {
|
|
26615
|
+
headers: {
|
|
26616
|
+
[name: string]: unknown;
|
|
26617
|
+
};
|
|
26618
|
+
content: {
|
|
26619
|
+
"application/json": {
|
|
26620
|
+
key: string;
|
|
26621
|
+
uploadRef: string;
|
|
26622
|
+
partSize: number;
|
|
26623
|
+
};
|
|
26624
|
+
};
|
|
26625
|
+
};
|
|
26626
|
+
/** @description Bad request */
|
|
26627
|
+
400: {
|
|
26628
|
+
headers: {
|
|
26629
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26630
|
+
"Retry-After"?: number;
|
|
26631
|
+
[name: string]: unknown;
|
|
26632
|
+
};
|
|
26633
|
+
content: {
|
|
26634
|
+
"application/json": {
|
|
26635
|
+
code: string;
|
|
26636
|
+
message: string;
|
|
26637
|
+
links?: {
|
|
26638
|
+
docs: string;
|
|
26639
|
+
schema: string;
|
|
26640
|
+
};
|
|
26641
|
+
issues?: {
|
|
26642
|
+
message: string;
|
|
26643
|
+
path?: (string | number)[];
|
|
26644
|
+
schema?: string;
|
|
26645
|
+
}[];
|
|
26646
|
+
retryable?: boolean;
|
|
26647
|
+
context?: unknown;
|
|
26648
|
+
};
|
|
26649
|
+
};
|
|
26650
|
+
};
|
|
26651
|
+
/** @description Unauthorized */
|
|
26652
|
+
401: {
|
|
26653
|
+
headers: {
|
|
26654
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26655
|
+
"Retry-After"?: number;
|
|
26656
|
+
[name: string]: unknown;
|
|
26657
|
+
};
|
|
26658
|
+
content: {
|
|
26659
|
+
"application/json": {
|
|
26660
|
+
code: string;
|
|
26661
|
+
message: string;
|
|
26662
|
+
links?: {
|
|
26663
|
+
docs: string;
|
|
26664
|
+
schema: string;
|
|
26665
|
+
};
|
|
26666
|
+
issues?: {
|
|
26667
|
+
message: string;
|
|
26668
|
+
path?: (string | number)[];
|
|
26669
|
+
schema?: string;
|
|
26670
|
+
}[];
|
|
26671
|
+
retryable?: boolean;
|
|
26672
|
+
context?: unknown;
|
|
26673
|
+
};
|
|
26674
|
+
};
|
|
26675
|
+
};
|
|
26676
|
+
/** @description Forbidden */
|
|
26677
|
+
403: {
|
|
26678
|
+
headers: {
|
|
26679
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26680
|
+
"Retry-After"?: number;
|
|
26681
|
+
[name: string]: unknown;
|
|
26682
|
+
};
|
|
26683
|
+
content: {
|
|
26684
|
+
"application/json": {
|
|
26685
|
+
code: string;
|
|
26686
|
+
message: string;
|
|
26687
|
+
links?: {
|
|
26688
|
+
docs: string;
|
|
26689
|
+
schema: string;
|
|
26690
|
+
};
|
|
26691
|
+
issues?: {
|
|
26692
|
+
message: string;
|
|
26693
|
+
path?: (string | number)[];
|
|
26694
|
+
schema?: string;
|
|
26695
|
+
}[];
|
|
26696
|
+
retryable?: boolean;
|
|
26697
|
+
context?: unknown;
|
|
26698
|
+
};
|
|
26699
|
+
};
|
|
26700
|
+
};
|
|
26701
|
+
/** @description Not found */
|
|
26702
|
+
404: {
|
|
26703
|
+
headers: {
|
|
26704
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26705
|
+
"Retry-After"?: number;
|
|
26706
|
+
[name: string]: unknown;
|
|
26707
|
+
};
|
|
26708
|
+
content: {
|
|
26709
|
+
"application/json": {
|
|
26710
|
+
code: string;
|
|
26711
|
+
message: string;
|
|
26712
|
+
links?: {
|
|
26713
|
+
docs: string;
|
|
26714
|
+
schema: string;
|
|
26715
|
+
};
|
|
26716
|
+
issues?: {
|
|
26717
|
+
message: string;
|
|
26718
|
+
path?: (string | number)[];
|
|
26719
|
+
schema?: string;
|
|
26720
|
+
}[];
|
|
26721
|
+
retryable?: boolean;
|
|
26722
|
+
context?: unknown;
|
|
26723
|
+
};
|
|
26724
|
+
};
|
|
26725
|
+
};
|
|
26726
|
+
/** @description Conflict */
|
|
26727
|
+
409: {
|
|
26728
|
+
headers: {
|
|
26729
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26730
|
+
"Retry-After"?: number;
|
|
26731
|
+
[name: string]: unknown;
|
|
26732
|
+
};
|
|
26733
|
+
content: {
|
|
26734
|
+
"application/json": {
|
|
26735
|
+
code: string;
|
|
26736
|
+
message: string;
|
|
26737
|
+
links?: {
|
|
26738
|
+
docs: string;
|
|
26739
|
+
schema: string;
|
|
26740
|
+
};
|
|
26741
|
+
issues?: {
|
|
26742
|
+
message: string;
|
|
26743
|
+
path?: (string | number)[];
|
|
26744
|
+
schema?: string;
|
|
26745
|
+
}[];
|
|
26746
|
+
retryable?: boolean;
|
|
26747
|
+
context?: unknown;
|
|
26748
|
+
};
|
|
26749
|
+
};
|
|
26750
|
+
};
|
|
26751
|
+
/** @description Gone */
|
|
26752
|
+
410: {
|
|
26753
|
+
headers: {
|
|
26754
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26755
|
+
"Retry-After"?: number;
|
|
26756
|
+
[name: string]: unknown;
|
|
26757
|
+
};
|
|
26758
|
+
content: {
|
|
26759
|
+
"application/json": {
|
|
26760
|
+
code: string;
|
|
26761
|
+
message: string;
|
|
26762
|
+
links?: {
|
|
26763
|
+
docs: string;
|
|
26764
|
+
schema: string;
|
|
26765
|
+
};
|
|
26766
|
+
issues?: {
|
|
26767
|
+
message: string;
|
|
26768
|
+
path?: (string | number)[];
|
|
26769
|
+
schema?: string;
|
|
26770
|
+
}[];
|
|
26771
|
+
retryable?: boolean;
|
|
26772
|
+
context?: unknown;
|
|
26773
|
+
};
|
|
26774
|
+
};
|
|
26775
|
+
};
|
|
26776
|
+
/** @description Unprocessable content */
|
|
26777
|
+
422: {
|
|
26778
|
+
headers: {
|
|
26779
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26780
|
+
"Retry-After"?: number;
|
|
26781
|
+
[name: string]: unknown;
|
|
26782
|
+
};
|
|
26783
|
+
content: {
|
|
26784
|
+
"application/json": {
|
|
26785
|
+
code: string;
|
|
26786
|
+
message: string;
|
|
26787
|
+
links?: {
|
|
26788
|
+
docs: string;
|
|
26789
|
+
schema: string;
|
|
26790
|
+
};
|
|
26791
|
+
issues?: {
|
|
26792
|
+
message: string;
|
|
26793
|
+
path?: (string | number)[];
|
|
26794
|
+
schema?: string;
|
|
26795
|
+
}[];
|
|
26796
|
+
retryable?: boolean;
|
|
26797
|
+
context?: unknown;
|
|
26798
|
+
};
|
|
26799
|
+
};
|
|
26800
|
+
};
|
|
26801
|
+
/** @description Internal server error */
|
|
26802
|
+
500: {
|
|
26803
|
+
headers: {
|
|
26804
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26805
|
+
"Retry-After"?: number;
|
|
26806
|
+
[name: string]: unknown;
|
|
26807
|
+
};
|
|
26808
|
+
content: {
|
|
26809
|
+
"application/json": {
|
|
26810
|
+
code: string;
|
|
26811
|
+
message: string;
|
|
26812
|
+
links?: {
|
|
26813
|
+
docs: string;
|
|
26814
|
+
schema: string;
|
|
26815
|
+
};
|
|
26816
|
+
issues?: {
|
|
26817
|
+
message: string;
|
|
26818
|
+
path?: (string | number)[];
|
|
26819
|
+
schema?: string;
|
|
26820
|
+
}[];
|
|
26821
|
+
retryable?: boolean;
|
|
26822
|
+
context?: unknown;
|
|
26823
|
+
};
|
|
26824
|
+
};
|
|
26825
|
+
};
|
|
26826
|
+
/** @description Service unavailable */
|
|
26827
|
+
503: {
|
|
26828
|
+
headers: {
|
|
26829
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26830
|
+
"Retry-After"?: number;
|
|
26831
|
+
[name: string]: unknown;
|
|
26832
|
+
};
|
|
26833
|
+
content: {
|
|
26834
|
+
"application/json": {
|
|
26835
|
+
code: string;
|
|
26836
|
+
message: string;
|
|
26837
|
+
links?: {
|
|
26838
|
+
docs: string;
|
|
26839
|
+
schema: string;
|
|
26840
|
+
};
|
|
26841
|
+
issues?: {
|
|
26842
|
+
message: string;
|
|
26843
|
+
path?: (string | number)[];
|
|
26844
|
+
schema?: string;
|
|
26845
|
+
}[];
|
|
26846
|
+
retryable?: boolean;
|
|
26847
|
+
context?: unknown;
|
|
26848
|
+
};
|
|
26849
|
+
};
|
|
26850
|
+
};
|
|
26851
|
+
};
|
|
26852
|
+
};
|
|
26853
|
+
deleteConnectionsByIdCsvImportUploadsByUploadRef: {
|
|
26854
|
+
parameters: {
|
|
26855
|
+
query: {
|
|
26856
|
+
key: string;
|
|
26857
|
+
};
|
|
26858
|
+
header?: never;
|
|
26859
|
+
path: {
|
|
26860
|
+
id: string;
|
|
26861
|
+
uploadRef: string;
|
|
26862
|
+
};
|
|
26863
|
+
cookie?: never;
|
|
26864
|
+
};
|
|
26865
|
+
requestBody?: never;
|
|
26866
|
+
responses: {
|
|
26867
|
+
/** @description Successful response */
|
|
26868
|
+
200: {
|
|
26869
|
+
headers: {
|
|
26870
|
+
[name: string]: unknown;
|
|
26871
|
+
};
|
|
26872
|
+
content: {
|
|
26873
|
+
"application/json": {
|
|
26874
|
+
/** @constant */
|
|
26875
|
+
status: "deleted";
|
|
26876
|
+
};
|
|
26877
|
+
};
|
|
26878
|
+
};
|
|
26879
|
+
/** @description Bad request */
|
|
26880
|
+
400: {
|
|
26881
|
+
headers: {
|
|
26882
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26883
|
+
"Retry-After"?: number;
|
|
26884
|
+
[name: string]: unknown;
|
|
26885
|
+
};
|
|
26886
|
+
content: {
|
|
26887
|
+
"application/json": {
|
|
26888
|
+
code: string;
|
|
26889
|
+
message: string;
|
|
26890
|
+
links?: {
|
|
26891
|
+
docs: string;
|
|
26892
|
+
schema: string;
|
|
26893
|
+
};
|
|
26894
|
+
issues?: {
|
|
26895
|
+
message: string;
|
|
26896
|
+
path?: (string | number)[];
|
|
26897
|
+
schema?: string;
|
|
26898
|
+
}[];
|
|
26899
|
+
retryable?: boolean;
|
|
26900
|
+
context?: unknown;
|
|
26901
|
+
};
|
|
26902
|
+
};
|
|
26903
|
+
};
|
|
26904
|
+
/** @description Unauthorized */
|
|
26905
|
+
401: {
|
|
26906
|
+
headers: {
|
|
26907
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26908
|
+
"Retry-After"?: number;
|
|
26909
|
+
[name: string]: unknown;
|
|
26910
|
+
};
|
|
26911
|
+
content: {
|
|
26912
|
+
"application/json": {
|
|
26913
|
+
code: string;
|
|
26914
|
+
message: string;
|
|
26915
|
+
links?: {
|
|
26916
|
+
docs: string;
|
|
26917
|
+
schema: string;
|
|
26918
|
+
};
|
|
26919
|
+
issues?: {
|
|
26920
|
+
message: string;
|
|
26921
|
+
path?: (string | number)[];
|
|
26922
|
+
schema?: string;
|
|
26923
|
+
}[];
|
|
26924
|
+
retryable?: boolean;
|
|
26925
|
+
context?: unknown;
|
|
26926
|
+
};
|
|
26927
|
+
};
|
|
26928
|
+
};
|
|
26929
|
+
/** @description Forbidden */
|
|
26930
|
+
403: {
|
|
26931
|
+
headers: {
|
|
26932
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26933
|
+
"Retry-After"?: number;
|
|
26934
|
+
[name: string]: unknown;
|
|
26935
|
+
};
|
|
26936
|
+
content: {
|
|
26937
|
+
"application/json": {
|
|
26938
|
+
code: string;
|
|
26939
|
+
message: string;
|
|
26940
|
+
links?: {
|
|
26941
|
+
docs: string;
|
|
26942
|
+
schema: string;
|
|
26943
|
+
};
|
|
26944
|
+
issues?: {
|
|
26945
|
+
message: string;
|
|
26946
|
+
path?: (string | number)[];
|
|
26947
|
+
schema?: string;
|
|
26948
|
+
}[];
|
|
26949
|
+
retryable?: boolean;
|
|
26950
|
+
context?: unknown;
|
|
26951
|
+
};
|
|
26952
|
+
};
|
|
26953
|
+
};
|
|
26954
|
+
/** @description Not found */
|
|
26955
|
+
404: {
|
|
26956
|
+
headers: {
|
|
26957
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26958
|
+
"Retry-After"?: number;
|
|
26959
|
+
[name: string]: unknown;
|
|
26960
|
+
};
|
|
26961
|
+
content: {
|
|
26962
|
+
"application/json": {
|
|
26963
|
+
code: string;
|
|
26964
|
+
message: string;
|
|
26965
|
+
links?: {
|
|
26966
|
+
docs: string;
|
|
26967
|
+
schema: string;
|
|
26968
|
+
};
|
|
26969
|
+
issues?: {
|
|
26970
|
+
message: string;
|
|
26971
|
+
path?: (string | number)[];
|
|
26972
|
+
schema?: string;
|
|
26973
|
+
}[];
|
|
26974
|
+
retryable?: boolean;
|
|
26975
|
+
context?: unknown;
|
|
26976
|
+
};
|
|
26977
|
+
};
|
|
26978
|
+
};
|
|
26979
|
+
/** @description Conflict */
|
|
26980
|
+
409: {
|
|
26981
|
+
headers: {
|
|
26982
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
26983
|
+
"Retry-After"?: number;
|
|
26984
|
+
[name: string]: unknown;
|
|
26985
|
+
};
|
|
26986
|
+
content: {
|
|
26987
|
+
"application/json": {
|
|
26988
|
+
code: string;
|
|
26989
|
+
message: string;
|
|
26990
|
+
links?: {
|
|
26991
|
+
docs: string;
|
|
26992
|
+
schema: string;
|
|
26993
|
+
};
|
|
26994
|
+
issues?: {
|
|
26995
|
+
message: string;
|
|
26996
|
+
path?: (string | number)[];
|
|
26997
|
+
schema?: string;
|
|
26998
|
+
}[];
|
|
26999
|
+
retryable?: boolean;
|
|
27000
|
+
context?: unknown;
|
|
27001
|
+
};
|
|
27002
|
+
};
|
|
27003
|
+
};
|
|
27004
|
+
/** @description Gone */
|
|
27005
|
+
410: {
|
|
27006
|
+
headers: {
|
|
27007
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
27008
|
+
"Retry-After"?: number;
|
|
27009
|
+
[name: string]: unknown;
|
|
27010
|
+
};
|
|
27011
|
+
content: {
|
|
27012
|
+
"application/json": {
|
|
27013
|
+
code: string;
|
|
27014
|
+
message: string;
|
|
27015
|
+
links?: {
|
|
27016
|
+
docs: string;
|
|
27017
|
+
schema: string;
|
|
27018
|
+
};
|
|
27019
|
+
issues?: {
|
|
27020
|
+
message: string;
|
|
27021
|
+
path?: (string | number)[];
|
|
27022
|
+
schema?: string;
|
|
27023
|
+
}[];
|
|
27024
|
+
retryable?: boolean;
|
|
27025
|
+
context?: unknown;
|
|
27026
|
+
};
|
|
27027
|
+
};
|
|
27028
|
+
};
|
|
27029
|
+
/** @description Unprocessable content */
|
|
27030
|
+
422: {
|
|
27031
|
+
headers: {
|
|
27032
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
27033
|
+
"Retry-After"?: number;
|
|
27034
|
+
[name: string]: unknown;
|
|
27035
|
+
};
|
|
27036
|
+
content: {
|
|
27037
|
+
"application/json": {
|
|
27038
|
+
code: string;
|
|
27039
|
+
message: string;
|
|
27040
|
+
links?: {
|
|
27041
|
+
docs: string;
|
|
27042
|
+
schema: string;
|
|
27043
|
+
};
|
|
27044
|
+
issues?: {
|
|
27045
|
+
message: string;
|
|
27046
|
+
path?: (string | number)[];
|
|
27047
|
+
schema?: string;
|
|
27048
|
+
}[];
|
|
27049
|
+
retryable?: boolean;
|
|
27050
|
+
context?: unknown;
|
|
27051
|
+
};
|
|
27052
|
+
};
|
|
27053
|
+
};
|
|
27054
|
+
/** @description Internal server error */
|
|
27055
|
+
500: {
|
|
27056
|
+
headers: {
|
|
27057
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
27058
|
+
"Retry-After"?: number;
|
|
27059
|
+
[name: string]: unknown;
|
|
27060
|
+
};
|
|
27061
|
+
content: {
|
|
27062
|
+
"application/json": {
|
|
27063
|
+
code: string;
|
|
27064
|
+
message: string;
|
|
27065
|
+
links?: {
|
|
27066
|
+
docs: string;
|
|
27067
|
+
schema: string;
|
|
27068
|
+
};
|
|
27069
|
+
issues?: {
|
|
27070
|
+
message: string;
|
|
27071
|
+
path?: (string | number)[];
|
|
27072
|
+
schema?: string;
|
|
27073
|
+
}[];
|
|
27074
|
+
retryable?: boolean;
|
|
27075
|
+
context?: unknown;
|
|
27076
|
+
};
|
|
27077
|
+
};
|
|
27078
|
+
};
|
|
27079
|
+
/** @description Service unavailable */
|
|
27080
|
+
503: {
|
|
27081
|
+
headers: {
|
|
27082
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
27083
|
+
"Retry-After"?: number;
|
|
27084
|
+
[name: string]: unknown;
|
|
27085
|
+
};
|
|
27086
|
+
content: {
|
|
27087
|
+
"application/json": {
|
|
27088
|
+
code: string;
|
|
27089
|
+
message: string;
|
|
27090
|
+
links?: {
|
|
27091
|
+
docs: string;
|
|
27092
|
+
schema: string;
|
|
27093
|
+
};
|
|
27094
|
+
issues?: {
|
|
27095
|
+
message: string;
|
|
27096
|
+
path?: (string | number)[];
|
|
27097
|
+
schema?: string;
|
|
27098
|
+
}[];
|
|
27099
|
+
retryable?: boolean;
|
|
27100
|
+
context?: unknown;
|
|
27101
|
+
};
|
|
27102
|
+
};
|
|
27103
|
+
};
|
|
27104
|
+
};
|
|
27105
|
+
};
|
|
27106
|
+
postConnectionsByIdCsvImportUploadsByUploadRefComplete: {
|
|
27107
|
+
parameters: {
|
|
27108
|
+
query?: never;
|
|
27109
|
+
header?: never;
|
|
27110
|
+
path: {
|
|
27111
|
+
id: string;
|
|
27112
|
+
uploadRef: string;
|
|
27113
|
+
};
|
|
27114
|
+
cookie?: never;
|
|
27115
|
+
};
|
|
27116
|
+
requestBody?: {
|
|
27117
|
+
content: {
|
|
27118
|
+
"application/json": {
|
|
27119
|
+
key: string;
|
|
27120
|
+
parts: {
|
|
27121
|
+
etag: string;
|
|
27122
|
+
partNumber: number;
|
|
27123
|
+
}[];
|
|
27124
|
+
};
|
|
27125
|
+
};
|
|
27126
|
+
};
|
|
27127
|
+
responses: {
|
|
27128
|
+
/** @description Successful response */
|
|
27129
|
+
200: {
|
|
27130
|
+
headers: {
|
|
27131
|
+
[name: string]: unknown;
|
|
27132
|
+
};
|
|
27133
|
+
content: {
|
|
27134
|
+
"application/json": {
|
|
27135
|
+
fileUri: string;
|
|
27136
|
+
};
|
|
27137
|
+
};
|
|
27138
|
+
};
|
|
27139
|
+
/** @description Bad request */
|
|
27140
|
+
400: {
|
|
27141
|
+
headers: {
|
|
27142
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
27143
|
+
"Retry-After"?: number;
|
|
27144
|
+
[name: string]: unknown;
|
|
27145
|
+
};
|
|
27146
|
+
content: {
|
|
27147
|
+
"application/json": {
|
|
27148
|
+
code: string;
|
|
27149
|
+
message: string;
|
|
27150
|
+
links?: {
|
|
27151
|
+
docs: string;
|
|
27152
|
+
schema: string;
|
|
27153
|
+
};
|
|
27154
|
+
issues?: {
|
|
27155
|
+
message: string;
|
|
27156
|
+
path?: (string | number)[];
|
|
27157
|
+
schema?: string;
|
|
27158
|
+
}[];
|
|
27159
|
+
retryable?: boolean;
|
|
27160
|
+
context?: unknown;
|
|
27161
|
+
};
|
|
27162
|
+
};
|
|
27163
|
+
};
|
|
27164
|
+
/** @description Unauthorized */
|
|
27165
|
+
401: {
|
|
27166
|
+
headers: {
|
|
27167
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
27168
|
+
"Retry-After"?: number;
|
|
27169
|
+
[name: string]: unknown;
|
|
27170
|
+
};
|
|
27171
|
+
content: {
|
|
27172
|
+
"application/json": {
|
|
27173
|
+
code: string;
|
|
27174
|
+
message: string;
|
|
27175
|
+
links?: {
|
|
27176
|
+
docs: string;
|
|
27177
|
+
schema: string;
|
|
27178
|
+
};
|
|
27179
|
+
issues?: {
|
|
27180
|
+
message: string;
|
|
27181
|
+
path?: (string | number)[];
|
|
27182
|
+
schema?: string;
|
|
27183
|
+
}[];
|
|
27184
|
+
retryable?: boolean;
|
|
27185
|
+
context?: unknown;
|
|
27186
|
+
};
|
|
27187
|
+
};
|
|
27188
|
+
};
|
|
27189
|
+
/** @description Forbidden */
|
|
27190
|
+
403: {
|
|
27191
|
+
headers: {
|
|
27192
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
27193
|
+
"Retry-After"?: number;
|
|
27194
|
+
[name: string]: unknown;
|
|
27195
|
+
};
|
|
27196
|
+
content: {
|
|
27197
|
+
"application/json": {
|
|
27198
|
+
code: string;
|
|
27199
|
+
message: string;
|
|
27200
|
+
links?: {
|
|
27201
|
+
docs: string;
|
|
27202
|
+
schema: string;
|
|
27203
|
+
};
|
|
27204
|
+
issues?: {
|
|
27205
|
+
message: string;
|
|
27206
|
+
path?: (string | number)[];
|
|
27207
|
+
schema?: string;
|
|
27208
|
+
}[];
|
|
27209
|
+
retryable?: boolean;
|
|
27210
|
+
context?: unknown;
|
|
27211
|
+
};
|
|
27212
|
+
};
|
|
27213
|
+
};
|
|
27214
|
+
/** @description Not found */
|
|
27215
|
+
404: {
|
|
27216
|
+
headers: {
|
|
27217
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
27218
|
+
"Retry-After"?: number;
|
|
27219
|
+
[name: string]: unknown;
|
|
27220
|
+
};
|
|
27221
|
+
content: {
|
|
27222
|
+
"application/json": {
|
|
27223
|
+
code: string;
|
|
27224
|
+
message: string;
|
|
27225
|
+
links?: {
|
|
27226
|
+
docs: string;
|
|
27227
|
+
schema: string;
|
|
27228
|
+
};
|
|
27229
|
+
issues?: {
|
|
27230
|
+
message: string;
|
|
27231
|
+
path?: (string | number)[];
|
|
27232
|
+
schema?: string;
|
|
27233
|
+
}[];
|
|
27234
|
+
retryable?: boolean;
|
|
27235
|
+
context?: unknown;
|
|
27236
|
+
};
|
|
27237
|
+
};
|
|
27238
|
+
};
|
|
27239
|
+
/** @description Conflict */
|
|
27240
|
+
409: {
|
|
27241
|
+
headers: {
|
|
27242
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
27243
|
+
"Retry-After"?: number;
|
|
27244
|
+
[name: string]: unknown;
|
|
27245
|
+
};
|
|
27246
|
+
content: {
|
|
27247
|
+
"application/json": {
|
|
27248
|
+
code: string;
|
|
27249
|
+
message: string;
|
|
27250
|
+
links?: {
|
|
27251
|
+
docs: string;
|
|
27252
|
+
schema: string;
|
|
27253
|
+
};
|
|
27254
|
+
issues?: {
|
|
27255
|
+
message: string;
|
|
27256
|
+
path?: (string | number)[];
|
|
27257
|
+
schema?: string;
|
|
27258
|
+
}[];
|
|
27259
|
+
retryable?: boolean;
|
|
27260
|
+
context?: unknown;
|
|
27261
|
+
};
|
|
27262
|
+
};
|
|
27263
|
+
};
|
|
27264
|
+
/** @description Gone */
|
|
27265
|
+
410: {
|
|
27266
|
+
headers: {
|
|
27267
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
27268
|
+
"Retry-After"?: number;
|
|
27269
|
+
[name: string]: unknown;
|
|
27270
|
+
};
|
|
27271
|
+
content: {
|
|
27272
|
+
"application/json": {
|
|
27273
|
+
code: string;
|
|
27274
|
+
message: string;
|
|
27275
|
+
links?: {
|
|
27276
|
+
docs: string;
|
|
27277
|
+
schema: string;
|
|
27278
|
+
};
|
|
27279
|
+
issues?: {
|
|
27280
|
+
message: string;
|
|
27281
|
+
path?: (string | number)[];
|
|
27282
|
+
schema?: string;
|
|
27283
|
+
}[];
|
|
27284
|
+
retryable?: boolean;
|
|
27285
|
+
context?: unknown;
|
|
27286
|
+
};
|
|
27287
|
+
};
|
|
27288
|
+
};
|
|
27289
|
+
/** @description Unprocessable content */
|
|
27290
|
+
422: {
|
|
27291
|
+
headers: {
|
|
27292
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
27293
|
+
"Retry-After"?: number;
|
|
27294
|
+
[name: string]: unknown;
|
|
27295
|
+
};
|
|
27296
|
+
content: {
|
|
27297
|
+
"application/json": {
|
|
27298
|
+
code: string;
|
|
27299
|
+
message: string;
|
|
27300
|
+
links?: {
|
|
27301
|
+
docs: string;
|
|
27302
|
+
schema: string;
|
|
27303
|
+
};
|
|
27304
|
+
issues?: {
|
|
27305
|
+
message: string;
|
|
27306
|
+
path?: (string | number)[];
|
|
27307
|
+
schema?: string;
|
|
27308
|
+
}[];
|
|
27309
|
+
retryable?: boolean;
|
|
27310
|
+
context?: unknown;
|
|
27311
|
+
};
|
|
27312
|
+
};
|
|
27313
|
+
};
|
|
27314
|
+
/** @description Internal server error */
|
|
27315
|
+
500: {
|
|
27316
|
+
headers: {
|
|
27317
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
27318
|
+
"Retry-After"?: number;
|
|
27319
|
+
[name: string]: unknown;
|
|
27320
|
+
};
|
|
27321
|
+
content: {
|
|
27322
|
+
"application/json": {
|
|
27323
|
+
code: string;
|
|
27324
|
+
message: string;
|
|
27325
|
+
links?: {
|
|
27326
|
+
docs: string;
|
|
27327
|
+
schema: string;
|
|
27328
|
+
};
|
|
27329
|
+
issues?: {
|
|
27330
|
+
message: string;
|
|
27331
|
+
path?: (string | number)[];
|
|
27332
|
+
schema?: string;
|
|
27333
|
+
}[];
|
|
27334
|
+
retryable?: boolean;
|
|
27335
|
+
context?: unknown;
|
|
27336
|
+
};
|
|
27337
|
+
};
|
|
27338
|
+
};
|
|
27339
|
+
/** @description Service unavailable */
|
|
27340
|
+
503: {
|
|
27341
|
+
headers: {
|
|
27342
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
27343
|
+
"Retry-After"?: number;
|
|
27344
|
+
[name: string]: unknown;
|
|
27345
|
+
};
|
|
27346
|
+
content: {
|
|
27347
|
+
"application/json": {
|
|
27348
|
+
code: string;
|
|
27349
|
+
message: string;
|
|
27350
|
+
links?: {
|
|
27351
|
+
docs: string;
|
|
27352
|
+
schema: string;
|
|
27353
|
+
};
|
|
27354
|
+
issues?: {
|
|
27355
|
+
message: string;
|
|
27356
|
+
path?: (string | number)[];
|
|
27357
|
+
schema?: string;
|
|
27358
|
+
}[];
|
|
27359
|
+
retryable?: boolean;
|
|
27360
|
+
context?: unknown;
|
|
27361
|
+
};
|
|
27362
|
+
};
|
|
27363
|
+
};
|
|
27364
|
+
};
|
|
27365
|
+
};
|
|
27366
|
+
putConnectionsByIdCsvImportUploadsByUploadRefPartsByPartNumber: {
|
|
27367
|
+
parameters: {
|
|
27368
|
+
query: {
|
|
27369
|
+
key: string;
|
|
27370
|
+
};
|
|
27371
|
+
header?: never;
|
|
27372
|
+
path: {
|
|
27373
|
+
id: string;
|
|
27374
|
+
uploadRef: string;
|
|
27375
|
+
partNumber: number;
|
|
27376
|
+
};
|
|
27377
|
+
cookie?: never;
|
|
27378
|
+
};
|
|
27379
|
+
requestBody?: never;
|
|
27380
|
+
responses: {
|
|
27381
|
+
/** @description Successful response */
|
|
27382
|
+
200: {
|
|
27383
|
+
headers: {
|
|
27384
|
+
[name: string]: unknown;
|
|
27385
|
+
};
|
|
27386
|
+
content: {
|
|
27387
|
+
"application/json": {
|
|
27388
|
+
etag: string;
|
|
27389
|
+
partNumber: number;
|
|
27390
|
+
};
|
|
27391
|
+
};
|
|
27392
|
+
};
|
|
27393
|
+
/** @description Bad request */
|
|
27394
|
+
400: {
|
|
27395
|
+
headers: {
|
|
27396
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
27397
|
+
"Retry-After"?: number;
|
|
27398
|
+
[name: string]: unknown;
|
|
27399
|
+
};
|
|
27400
|
+
content: {
|
|
27401
|
+
"application/json": {
|
|
27402
|
+
code: string;
|
|
27403
|
+
message: string;
|
|
27404
|
+
links?: {
|
|
27405
|
+
docs: string;
|
|
27406
|
+
schema: string;
|
|
27407
|
+
};
|
|
27408
|
+
issues?: {
|
|
27409
|
+
message: string;
|
|
27410
|
+
path?: (string | number)[];
|
|
27411
|
+
schema?: string;
|
|
27412
|
+
}[];
|
|
27413
|
+
retryable?: boolean;
|
|
27414
|
+
context?: unknown;
|
|
27415
|
+
};
|
|
27416
|
+
};
|
|
27417
|
+
};
|
|
27418
|
+
/** @description Unauthorized */
|
|
27419
|
+
401: {
|
|
27420
|
+
headers: {
|
|
27421
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
27422
|
+
"Retry-After"?: number;
|
|
27423
|
+
[name: string]: unknown;
|
|
27424
|
+
};
|
|
27425
|
+
content: {
|
|
27426
|
+
"application/json": {
|
|
27427
|
+
code: string;
|
|
27428
|
+
message: string;
|
|
27429
|
+
links?: {
|
|
27430
|
+
docs: string;
|
|
27431
|
+
schema: string;
|
|
27432
|
+
};
|
|
27433
|
+
issues?: {
|
|
27434
|
+
message: string;
|
|
27435
|
+
path?: (string | number)[];
|
|
27436
|
+
schema?: string;
|
|
27437
|
+
}[];
|
|
27438
|
+
retryable?: boolean;
|
|
27439
|
+
context?: unknown;
|
|
27440
|
+
};
|
|
27441
|
+
};
|
|
27442
|
+
};
|
|
27443
|
+
/** @description Forbidden */
|
|
27444
|
+
403: {
|
|
27445
|
+
headers: {
|
|
27446
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
27447
|
+
"Retry-After"?: number;
|
|
27448
|
+
[name: string]: unknown;
|
|
27449
|
+
};
|
|
27450
|
+
content: {
|
|
27451
|
+
"application/json": {
|
|
27452
|
+
code: string;
|
|
27453
|
+
message: string;
|
|
27454
|
+
links?: {
|
|
27455
|
+
docs: string;
|
|
27456
|
+
schema: string;
|
|
27457
|
+
};
|
|
27458
|
+
issues?: {
|
|
27459
|
+
message: string;
|
|
27460
|
+
path?: (string | number)[];
|
|
27461
|
+
schema?: string;
|
|
27462
|
+
}[];
|
|
27463
|
+
retryable?: boolean;
|
|
27464
|
+
context?: unknown;
|
|
27465
|
+
};
|
|
27466
|
+
};
|
|
27467
|
+
};
|
|
27468
|
+
/** @description Not found */
|
|
27469
|
+
404: {
|
|
27470
|
+
headers: {
|
|
27471
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
27472
|
+
"Retry-After"?: number;
|
|
27473
|
+
[name: string]: unknown;
|
|
27474
|
+
};
|
|
27475
|
+
content: {
|
|
27476
|
+
"application/json": {
|
|
27477
|
+
code: string;
|
|
27478
|
+
message: string;
|
|
27479
|
+
links?: {
|
|
27480
|
+
docs: string;
|
|
27481
|
+
schema: string;
|
|
27482
|
+
};
|
|
27483
|
+
issues?: {
|
|
27484
|
+
message: string;
|
|
27485
|
+
path?: (string | number)[];
|
|
27486
|
+
schema?: string;
|
|
27487
|
+
}[];
|
|
27488
|
+
retryable?: boolean;
|
|
27489
|
+
context?: unknown;
|
|
27490
|
+
};
|
|
27491
|
+
};
|
|
27492
|
+
};
|
|
27493
|
+
/** @description Conflict */
|
|
27494
|
+
409: {
|
|
27495
|
+
headers: {
|
|
27496
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
27497
|
+
"Retry-After"?: number;
|
|
27498
|
+
[name: string]: unknown;
|
|
27499
|
+
};
|
|
27500
|
+
content: {
|
|
27501
|
+
"application/json": {
|
|
27502
|
+
code: string;
|
|
27503
|
+
message: string;
|
|
27504
|
+
links?: {
|
|
27505
|
+
docs: string;
|
|
27506
|
+
schema: string;
|
|
27507
|
+
};
|
|
27508
|
+
issues?: {
|
|
27509
|
+
message: string;
|
|
27510
|
+
path?: (string | number)[];
|
|
27511
|
+
schema?: string;
|
|
27512
|
+
}[];
|
|
27513
|
+
retryable?: boolean;
|
|
27514
|
+
context?: unknown;
|
|
27515
|
+
};
|
|
27516
|
+
};
|
|
27517
|
+
};
|
|
27518
|
+
/** @description Gone */
|
|
27519
|
+
410: {
|
|
27520
|
+
headers: {
|
|
27521
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
27522
|
+
"Retry-After"?: number;
|
|
27523
|
+
[name: string]: unknown;
|
|
27524
|
+
};
|
|
27525
|
+
content: {
|
|
27526
|
+
"application/json": {
|
|
27527
|
+
code: string;
|
|
27528
|
+
message: string;
|
|
27529
|
+
links?: {
|
|
27530
|
+
docs: string;
|
|
27531
|
+
schema: string;
|
|
27532
|
+
};
|
|
27533
|
+
issues?: {
|
|
27534
|
+
message: string;
|
|
27535
|
+
path?: (string | number)[];
|
|
27536
|
+
schema?: string;
|
|
27537
|
+
}[];
|
|
27538
|
+
retryable?: boolean;
|
|
27539
|
+
context?: unknown;
|
|
27540
|
+
};
|
|
27541
|
+
};
|
|
27542
|
+
};
|
|
27543
|
+
/** @description Unprocessable content */
|
|
27544
|
+
422: {
|
|
27545
|
+
headers: {
|
|
27546
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
27547
|
+
"Retry-After"?: number;
|
|
27548
|
+
[name: string]: unknown;
|
|
27549
|
+
};
|
|
27550
|
+
content: {
|
|
27551
|
+
"application/json": {
|
|
27552
|
+
code: string;
|
|
27553
|
+
message: string;
|
|
27554
|
+
links?: {
|
|
27555
|
+
docs: string;
|
|
27556
|
+
schema: string;
|
|
27557
|
+
};
|
|
27558
|
+
issues?: {
|
|
27559
|
+
message: string;
|
|
27560
|
+
path?: (string | number)[];
|
|
27561
|
+
schema?: string;
|
|
27562
|
+
}[];
|
|
27563
|
+
retryable?: boolean;
|
|
27564
|
+
context?: unknown;
|
|
27565
|
+
};
|
|
27566
|
+
};
|
|
27567
|
+
};
|
|
27568
|
+
/** @description Internal server error */
|
|
27569
|
+
500: {
|
|
27570
|
+
headers: {
|
|
27571
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
27572
|
+
"Retry-After"?: number;
|
|
27573
|
+
[name: string]: unknown;
|
|
27574
|
+
};
|
|
27575
|
+
content: {
|
|
27576
|
+
"application/json": {
|
|
27577
|
+
code: string;
|
|
27578
|
+
message: string;
|
|
27579
|
+
links?: {
|
|
27580
|
+
docs: string;
|
|
27581
|
+
schema: string;
|
|
27582
|
+
};
|
|
27583
|
+
issues?: {
|
|
27584
|
+
message: string;
|
|
27585
|
+
path?: (string | number)[];
|
|
27586
|
+
schema?: string;
|
|
27587
|
+
}[];
|
|
27588
|
+
retryable?: boolean;
|
|
27589
|
+
context?: unknown;
|
|
27590
|
+
};
|
|
27591
|
+
};
|
|
27592
|
+
};
|
|
27593
|
+
/** @description Service unavailable */
|
|
27594
|
+
503: {
|
|
27595
|
+
headers: {
|
|
27596
|
+
/** @description Seconds to wait when retryable=true and the server supplies a delay. */
|
|
27597
|
+
"Retry-After"?: number;
|
|
27598
|
+
[name: string]: unknown;
|
|
27599
|
+
};
|
|
27600
|
+
content: {
|
|
27601
|
+
"application/json": {
|
|
27602
|
+
code: string;
|
|
27603
|
+
message: string;
|
|
27604
|
+
links?: {
|
|
27605
|
+
docs: string;
|
|
27606
|
+
schema: string;
|
|
27607
|
+
};
|
|
27608
|
+
issues?: {
|
|
27609
|
+
message: string;
|
|
27610
|
+
path?: (string | number)[];
|
|
27611
|
+
schema?: string;
|
|
27612
|
+
}[];
|
|
27613
|
+
retryable?: boolean;
|
|
27614
|
+
context?: unknown;
|
|
27615
|
+
};
|
|
27616
|
+
};
|
|
27617
|
+
};
|
|
27618
|
+
};
|
|
27619
|
+
};
|
|
27620
|
+
getConnectionsByIdCsvImportBySyncId: {
|
|
27621
|
+
parameters: {
|
|
27622
|
+
query?: never;
|
|
27623
|
+
header?: never;
|
|
27624
|
+
path: {
|
|
27625
|
+
id: string;
|
|
27626
|
+
syncId: string;
|
|
27627
|
+
};
|
|
27628
|
+
cookie?: never;
|
|
27629
|
+
};
|
|
27630
|
+
requestBody?: never;
|
|
27631
|
+
responses: {
|
|
27632
|
+
/** @description Successful response */
|
|
27633
|
+
200: {
|
|
27634
|
+
headers: {
|
|
27635
|
+
[name: string]: unknown;
|
|
27636
|
+
};
|
|
27637
|
+
content: {
|
|
27638
|
+
"application/json": {
|
|
27639
|
+
data: ({
|
|
27640
|
+
syncId: string;
|
|
27641
|
+
/** @enum {string} */
|
|
27642
|
+
status: "completed";
|
|
27643
|
+
} | {
|
|
27644
|
+
/** @enum {string} */
|
|
27645
|
+
status: "failed";
|
|
27646
|
+
syncId: string;
|
|
27647
|
+
error: string;
|
|
27648
|
+
parseErrors?: {
|
|
27649
|
+
rowNumber: number;
|
|
27650
|
+
message: string;
|
|
27651
|
+
}[];
|
|
27652
|
+
}) | {
|
|
27653
|
+
syncId: string;
|
|
27654
|
+
/** @enum {string} */
|
|
27655
|
+
status: "queued";
|
|
25474
27656
|
};
|
|
25475
27657
|
};
|
|
25476
27658
|
};
|