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