@sjcrh/proteinpaint-types 2.129.0 → 2.129.6-2b2fdc7ee.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/chunk-UWNYHMCA.js +493 -0
- package/dist/gdc.grin2.js +1 -1
- package/dist/index.js +1 -1
- package/package.json +1 -1
- package/src/dataset.ts +44 -26
- package/src/routes/gdc.grin2.ts +58 -2
- package/dist/chunk-DJ5QE625.js +0 -294
|
@@ -0,0 +1,493 @@
|
|
|
1
|
+
import {
|
|
2
|
+
__toESM,
|
|
3
|
+
require_lib
|
|
4
|
+
} from "./chunk-CNSSF43V.js";
|
|
5
|
+
|
|
6
|
+
// dist/gdc.grin2.ts
|
|
7
|
+
var import_typia = __toESM(require_lib(), 1);
|
|
8
|
+
|
|
9
|
+
// src/routes/gdc.grin2.ts
|
|
10
|
+
var gdcGRIN2listPayload = {
|
|
11
|
+
request: {
|
|
12
|
+
typeId: "GdcGRIN2listRequest"
|
|
13
|
+
},
|
|
14
|
+
response: {
|
|
15
|
+
typeId: "GdcGRIN2listResponse"
|
|
16
|
+
}
|
|
17
|
+
};
|
|
18
|
+
var runGRIN2Payload = {
|
|
19
|
+
request: {
|
|
20
|
+
typeId: "RunGRIN2Request"
|
|
21
|
+
},
|
|
22
|
+
response: {
|
|
23
|
+
typeId: "RunGRIN2Response"
|
|
24
|
+
}
|
|
25
|
+
};
|
|
26
|
+
|
|
27
|
+
// dist/gdc.grin2.ts
|
|
28
|
+
var validGdcGRIN2listRequest = (input) => {
|
|
29
|
+
const errors = [];
|
|
30
|
+
const __is = (input2) => {
|
|
31
|
+
const $io0 = (input3) => (void 0 === input3.mafOptions || "object" === typeof input3.mafOptions && null !== input3.mafOptions && $io1(input3.mafOptions)) && true && true;
|
|
32
|
+
const $io1 = (input3) => "WXS" === input3.experimentalStrategy;
|
|
33
|
+
return "object" === typeof input2 && null !== input2 && false === Array.isArray(input2) && $io0(input2);
|
|
34
|
+
};
|
|
35
|
+
if (false === __is(input)) {
|
|
36
|
+
const $report = import_typia.createValidate.report(errors);
|
|
37
|
+
((input2, _path, _exceptionable = true) => {
|
|
38
|
+
const $vo0 = (input3, _path2, _exceptionable2 = true) => [true, void 0 === input3.mafOptions || ("object" === typeof input3.mafOptions && null !== input3.mafOptions || $report(_exceptionable2, {
|
|
39
|
+
path: _path2 + ".mafOptions",
|
|
40
|
+
expected: "(__type | undefined)",
|
|
41
|
+
value: input3.mafOptions
|
|
42
|
+
})) && $vo1(input3.mafOptions, _path2 + ".mafOptions", _exceptionable2) || $report(_exceptionable2, {
|
|
43
|
+
path: _path2 + ".mafOptions",
|
|
44
|
+
expected: "(__type | undefined)",
|
|
45
|
+
value: input3.mafOptions
|
|
46
|
+
}), true, true].every((flag) => flag);
|
|
47
|
+
const $vo1 = (input3, _path2, _exceptionable2 = true) => ["WXS" === input3.experimentalStrategy || $report(_exceptionable2, {
|
|
48
|
+
path: _path2 + ".experimentalStrategy",
|
|
49
|
+
expected: '"WXS"',
|
|
50
|
+
value: input3.experimentalStrategy
|
|
51
|
+
})].every((flag) => flag);
|
|
52
|
+
return ("object" === typeof input2 && null !== input2 && false === Array.isArray(input2) || $report(true, {
|
|
53
|
+
path: _path + "",
|
|
54
|
+
expected: "GdcGRIN2listRequest",
|
|
55
|
+
value: input2
|
|
56
|
+
})) && $vo0(input2, _path + "", true) || $report(true, {
|
|
57
|
+
path: _path + "",
|
|
58
|
+
expected: "GdcGRIN2listRequest",
|
|
59
|
+
value: input2
|
|
60
|
+
});
|
|
61
|
+
})(input, "$input", true);
|
|
62
|
+
}
|
|
63
|
+
const success = 0 === errors.length;
|
|
64
|
+
return {
|
|
65
|
+
success,
|
|
66
|
+
errors,
|
|
67
|
+
data: success ? input : void 0
|
|
68
|
+
};
|
|
69
|
+
};
|
|
70
|
+
var validGdcGRIN2listResponse = (input) => {
|
|
71
|
+
const errors = [];
|
|
72
|
+
const __is = (input2) => {
|
|
73
|
+
const $io0 = (input3) => Array.isArray(input3.files) && input3.files.every((elem) => "object" === typeof elem && null !== elem && $io1(elem)) && "number" === typeof input3.filesTotal && "number" === typeof input3.maxTotalSizeCompressed && (void 0 === input3.fileCounts || "object" === typeof input3.fileCounts && null !== input3.fileCounts && $io2(input3.fileCounts)) && (void 0 === input3.appliedFilters || "object" === typeof input3.appliedFilters && null !== input3.appliedFilters && false === Array.isArray(input3.appliedFilters) && $io3(input3.appliedFilters)) && (void 0 === input3.deduplicationStats || "object" === typeof input3.deduplicationStats && null !== input3.deduplicationStats && $io4(input3.deduplicationStats));
|
|
74
|
+
const $io1 = (input3) => "string" === typeof input3.id && "string" === typeof input3.case_submitter_id && "string" === typeof input3.case_uuid && "number" === typeof input3.file_size && (Array.isArray(input3.sample_types) && input3.sample_types.every((elem) => "string" === typeof elem)) && "string" === typeof input3.project_id && (void 0 === input3.file_format || "MAF" === input3.file_format);
|
|
75
|
+
const $io2 = (input3) => "number" === typeof input3.maf;
|
|
76
|
+
const $io3 = (input3) => void 0 === input3.experimentalStrategy || "WXS" === input3.experimentalStrategy;
|
|
77
|
+
const $io4 = (input3) => "number" === typeof input3.originalFileCount && "number" === typeof input3.deduplicatedFileCount && "number" === typeof input3.duplicatesRemoved && (void 0 === input3.caseDetails || Array.isArray(input3.caseDetails) && input3.caseDetails.every((elem) => "object" === typeof elem && null !== elem && $io5(elem))) && (Array.isArray(input3.filteredFiles) && input3.filteredFiles.every((elem) => "object" === typeof elem && null !== elem && $io6(elem)));
|
|
78
|
+
const $io5 = (input3) => "string" === typeof input3.caseName && "number" === typeof input3.fileCount && "number" === typeof input3.keptFileSize;
|
|
79
|
+
const $io6 = (input3) => "string" === typeof input3.fileId && "number" === typeof input3.fileSize && "string" === typeof input3.reason;
|
|
80
|
+
return "object" === typeof input2 && null !== input2 && $io0(input2);
|
|
81
|
+
};
|
|
82
|
+
if (false === __is(input)) {
|
|
83
|
+
const $report = import_typia.createValidate.report(errors);
|
|
84
|
+
((input2, _path, _exceptionable = true) => {
|
|
85
|
+
const $vo0 = (input3, _path2, _exceptionable2 = true) => [(Array.isArray(input3.files) || $report(_exceptionable2, {
|
|
86
|
+
path: _path2 + ".files",
|
|
87
|
+
expected: "Array<GdcGRIN2File>",
|
|
88
|
+
value: input3.files
|
|
89
|
+
})) && input3.files.map((elem, _index1) => ("object" === typeof elem && null !== elem || $report(_exceptionable2, {
|
|
90
|
+
path: _path2 + ".files[" + _index1 + "]",
|
|
91
|
+
expected: "GdcGRIN2File",
|
|
92
|
+
value: elem
|
|
93
|
+
})) && $vo1(elem, _path2 + ".files[" + _index1 + "]", _exceptionable2) || $report(_exceptionable2, {
|
|
94
|
+
path: _path2 + ".files[" + _index1 + "]",
|
|
95
|
+
expected: "GdcGRIN2File",
|
|
96
|
+
value: elem
|
|
97
|
+
})).every((flag) => flag) || $report(_exceptionable2, {
|
|
98
|
+
path: _path2 + ".files",
|
|
99
|
+
expected: "Array<GdcGRIN2File>",
|
|
100
|
+
value: input3.files
|
|
101
|
+
}), "number" === typeof input3.filesTotal || $report(_exceptionable2, {
|
|
102
|
+
path: _path2 + ".filesTotal",
|
|
103
|
+
expected: "number",
|
|
104
|
+
value: input3.filesTotal
|
|
105
|
+
}), "number" === typeof input3.maxTotalSizeCompressed || $report(_exceptionable2, {
|
|
106
|
+
path: _path2 + ".maxTotalSizeCompressed",
|
|
107
|
+
expected: "number",
|
|
108
|
+
value: input3.maxTotalSizeCompressed
|
|
109
|
+
}), void 0 === input3.fileCounts || ("object" === typeof input3.fileCounts && null !== input3.fileCounts || $report(_exceptionable2, {
|
|
110
|
+
path: _path2 + ".fileCounts",
|
|
111
|
+
expected: "(__type | undefined)",
|
|
112
|
+
value: input3.fileCounts
|
|
113
|
+
})) && $vo2(input3.fileCounts, _path2 + ".fileCounts", _exceptionable2) || $report(_exceptionable2, {
|
|
114
|
+
path: _path2 + ".fileCounts",
|
|
115
|
+
expected: "(__type | undefined)",
|
|
116
|
+
value: input3.fileCounts
|
|
117
|
+
}), void 0 === input3.appliedFilters || ("object" === typeof input3.appliedFilters && null !== input3.appliedFilters && false === Array.isArray(input3.appliedFilters) || $report(_exceptionable2, {
|
|
118
|
+
path: _path2 + ".appliedFilters",
|
|
119
|
+
expected: "(__type.o1 | undefined)",
|
|
120
|
+
value: input3.appliedFilters
|
|
121
|
+
})) && $vo3(input3.appliedFilters, _path2 + ".appliedFilters", _exceptionable2) || $report(_exceptionable2, {
|
|
122
|
+
path: _path2 + ".appliedFilters",
|
|
123
|
+
expected: "(__type.o1 | undefined)",
|
|
124
|
+
value: input3.appliedFilters
|
|
125
|
+
}), void 0 === input3.deduplicationStats || ("object" === typeof input3.deduplicationStats && null !== input3.deduplicationStats || $report(_exceptionable2, {
|
|
126
|
+
path: _path2 + ".deduplicationStats",
|
|
127
|
+
expected: "(__type.o2 | undefined)",
|
|
128
|
+
value: input3.deduplicationStats
|
|
129
|
+
})) && $vo4(input3.deduplicationStats, _path2 + ".deduplicationStats", _exceptionable2) || $report(_exceptionable2, {
|
|
130
|
+
path: _path2 + ".deduplicationStats",
|
|
131
|
+
expected: "(__type.o2 | undefined)",
|
|
132
|
+
value: input3.deduplicationStats
|
|
133
|
+
})].every((flag) => flag);
|
|
134
|
+
const $vo1 = (input3, _path2, _exceptionable2 = true) => ["string" === typeof input3.id || $report(_exceptionable2, {
|
|
135
|
+
path: _path2 + ".id",
|
|
136
|
+
expected: "string",
|
|
137
|
+
value: input3.id
|
|
138
|
+
}), "string" === typeof input3.case_submitter_id || $report(_exceptionable2, {
|
|
139
|
+
path: _path2 + ".case_submitter_id",
|
|
140
|
+
expected: "string",
|
|
141
|
+
value: input3.case_submitter_id
|
|
142
|
+
}), "string" === typeof input3.case_uuid || $report(_exceptionable2, {
|
|
143
|
+
path: _path2 + ".case_uuid",
|
|
144
|
+
expected: "string",
|
|
145
|
+
value: input3.case_uuid
|
|
146
|
+
}), "number" === typeof input3.file_size || $report(_exceptionable2, {
|
|
147
|
+
path: _path2 + ".file_size",
|
|
148
|
+
expected: "number",
|
|
149
|
+
value: input3.file_size
|
|
150
|
+
}), (Array.isArray(input3.sample_types) || $report(_exceptionable2, {
|
|
151
|
+
path: _path2 + ".sample_types",
|
|
152
|
+
expected: "Array<string>",
|
|
153
|
+
value: input3.sample_types
|
|
154
|
+
})) && input3.sample_types.map((elem, _index2) => "string" === typeof elem || $report(_exceptionable2, {
|
|
155
|
+
path: _path2 + ".sample_types[" + _index2 + "]",
|
|
156
|
+
expected: "string",
|
|
157
|
+
value: elem
|
|
158
|
+
})).every((flag) => flag) || $report(_exceptionable2, {
|
|
159
|
+
path: _path2 + ".sample_types",
|
|
160
|
+
expected: "Array<string>",
|
|
161
|
+
value: input3.sample_types
|
|
162
|
+
}), "string" === typeof input3.project_id || $report(_exceptionable2, {
|
|
163
|
+
path: _path2 + ".project_id",
|
|
164
|
+
expected: "string",
|
|
165
|
+
value: input3.project_id
|
|
166
|
+
}), void 0 === input3.file_format || "MAF" === input3.file_format || $report(_exceptionable2, {
|
|
167
|
+
path: _path2 + ".file_format",
|
|
168
|
+
expected: '("MAF" | undefined)',
|
|
169
|
+
value: input3.file_format
|
|
170
|
+
})].every((flag) => flag);
|
|
171
|
+
const $vo2 = (input3, _path2, _exceptionable2 = true) => ["number" === typeof input3.maf || $report(_exceptionable2, {
|
|
172
|
+
path: _path2 + ".maf",
|
|
173
|
+
expected: "number",
|
|
174
|
+
value: input3.maf
|
|
175
|
+
})].every((flag) => flag);
|
|
176
|
+
const $vo3 = (input3, _path2, _exceptionable2 = true) => [void 0 === input3.experimentalStrategy || "WXS" === input3.experimentalStrategy || $report(_exceptionable2, {
|
|
177
|
+
path: _path2 + ".experimentalStrategy",
|
|
178
|
+
expected: '("WXS" | undefined)',
|
|
179
|
+
value: input3.experimentalStrategy
|
|
180
|
+
})].every((flag) => flag);
|
|
181
|
+
const $vo4 = (input3, _path2, _exceptionable2 = true) => ["number" === typeof input3.originalFileCount || $report(_exceptionable2, {
|
|
182
|
+
path: _path2 + ".originalFileCount",
|
|
183
|
+
expected: "number",
|
|
184
|
+
value: input3.originalFileCount
|
|
185
|
+
}), "number" === typeof input3.deduplicatedFileCount || $report(_exceptionable2, {
|
|
186
|
+
path: _path2 + ".deduplicatedFileCount",
|
|
187
|
+
expected: "number",
|
|
188
|
+
value: input3.deduplicatedFileCount
|
|
189
|
+
}), "number" === typeof input3.duplicatesRemoved || $report(_exceptionable2, {
|
|
190
|
+
path: _path2 + ".duplicatesRemoved",
|
|
191
|
+
expected: "number",
|
|
192
|
+
value: input3.duplicatesRemoved
|
|
193
|
+
}), void 0 === input3.caseDetails || (Array.isArray(input3.caseDetails) || $report(_exceptionable2, {
|
|
194
|
+
path: _path2 + ".caseDetails",
|
|
195
|
+
expected: "(Array<__type> | undefined)",
|
|
196
|
+
value: input3.caseDetails
|
|
197
|
+
})) && input3.caseDetails.map((elem, _index3) => ("object" === typeof elem && null !== elem || $report(_exceptionable2, {
|
|
198
|
+
path: _path2 + ".caseDetails[" + _index3 + "]",
|
|
199
|
+
expected: "__type.o3",
|
|
200
|
+
value: elem
|
|
201
|
+
})) && $vo5(elem, _path2 + ".caseDetails[" + _index3 + "]", _exceptionable2) || $report(_exceptionable2, {
|
|
202
|
+
path: _path2 + ".caseDetails[" + _index3 + "]",
|
|
203
|
+
expected: "__type.o3",
|
|
204
|
+
value: elem
|
|
205
|
+
})).every((flag) => flag) || $report(_exceptionable2, {
|
|
206
|
+
path: _path2 + ".caseDetails",
|
|
207
|
+
expected: "(Array<__type> | undefined)",
|
|
208
|
+
value: input3.caseDetails
|
|
209
|
+
}), (Array.isArray(input3.filteredFiles) || $report(_exceptionable2, {
|
|
210
|
+
path: _path2 + ".filteredFiles",
|
|
211
|
+
expected: "Array<__type>.o1",
|
|
212
|
+
value: input3.filteredFiles
|
|
213
|
+
})) && input3.filteredFiles.map((elem, _index4) => ("object" === typeof elem && null !== elem || $report(_exceptionable2, {
|
|
214
|
+
path: _path2 + ".filteredFiles[" + _index4 + "]",
|
|
215
|
+
expected: "__type.o4",
|
|
216
|
+
value: elem
|
|
217
|
+
})) && $vo6(elem, _path2 + ".filteredFiles[" + _index4 + "]", _exceptionable2) || $report(_exceptionable2, {
|
|
218
|
+
path: _path2 + ".filteredFiles[" + _index4 + "]",
|
|
219
|
+
expected: "__type.o4",
|
|
220
|
+
value: elem
|
|
221
|
+
})).every((flag) => flag) || $report(_exceptionable2, {
|
|
222
|
+
path: _path2 + ".filteredFiles",
|
|
223
|
+
expected: "Array<__type>.o1",
|
|
224
|
+
value: input3.filteredFiles
|
|
225
|
+
})].every((flag) => flag);
|
|
226
|
+
const $vo5 = (input3, _path2, _exceptionable2 = true) => ["string" === typeof input3.caseName || $report(_exceptionable2, {
|
|
227
|
+
path: _path2 + ".caseName",
|
|
228
|
+
expected: "string",
|
|
229
|
+
value: input3.caseName
|
|
230
|
+
}), "number" === typeof input3.fileCount || $report(_exceptionable2, {
|
|
231
|
+
path: _path2 + ".fileCount",
|
|
232
|
+
expected: "number",
|
|
233
|
+
value: input3.fileCount
|
|
234
|
+
}), "number" === typeof input3.keptFileSize || $report(_exceptionable2, {
|
|
235
|
+
path: _path2 + ".keptFileSize",
|
|
236
|
+
expected: "number",
|
|
237
|
+
value: input3.keptFileSize
|
|
238
|
+
})].every((flag) => flag);
|
|
239
|
+
const $vo6 = (input3, _path2, _exceptionable2 = true) => ["string" === typeof input3.fileId || $report(_exceptionable2, {
|
|
240
|
+
path: _path2 + ".fileId",
|
|
241
|
+
expected: "string",
|
|
242
|
+
value: input3.fileId
|
|
243
|
+
}), "number" === typeof input3.fileSize || $report(_exceptionable2, {
|
|
244
|
+
path: _path2 + ".fileSize",
|
|
245
|
+
expected: "number",
|
|
246
|
+
value: input3.fileSize
|
|
247
|
+
}), "string" === typeof input3.reason || $report(_exceptionable2, {
|
|
248
|
+
path: _path2 + ".reason",
|
|
249
|
+
expected: "string",
|
|
250
|
+
value: input3.reason
|
|
251
|
+
})].every((flag) => flag);
|
|
252
|
+
return ("object" === typeof input2 && null !== input2 || $report(true, {
|
|
253
|
+
path: _path + "",
|
|
254
|
+
expected: "GdcGRIN2listResponse",
|
|
255
|
+
value: input2
|
|
256
|
+
})) && $vo0(input2, _path + "", true) || $report(true, {
|
|
257
|
+
path: _path + "",
|
|
258
|
+
expected: "GdcGRIN2listResponse",
|
|
259
|
+
value: input2
|
|
260
|
+
});
|
|
261
|
+
})(input, "$input", true);
|
|
262
|
+
}
|
|
263
|
+
const success = 0 === errors.length;
|
|
264
|
+
return {
|
|
265
|
+
success,
|
|
266
|
+
errors,
|
|
267
|
+
data: success ? input : void 0
|
|
268
|
+
};
|
|
269
|
+
};
|
|
270
|
+
var validRunGRIN2Request = (input) => {
|
|
271
|
+
const errors = [];
|
|
272
|
+
const __is = (input2) => {
|
|
273
|
+
const $join = import_typia.createValidate.join;
|
|
274
|
+
const $io0 = (input3) => "object" === typeof input3.caseFiles && null !== input3.caseFiles && false === Array.isArray(input3.caseFiles) && $io1(input3.caseFiles) && (void 0 === input3.mafOptions || "object" === typeof input3.mafOptions && null !== input3.mafOptions && false === Array.isArray(input3.mafOptions) && $io3(input3.mafOptions));
|
|
275
|
+
const $io1 = (input3) => Object.keys(input3).every((key) => {
|
|
276
|
+
const value = input3[key];
|
|
277
|
+
if (void 0 === value)
|
|
278
|
+
return true;
|
|
279
|
+
if (RegExp(/(.*)/).test(key))
|
|
280
|
+
return "object" === typeof value && null !== value && false === Array.isArray(value) && $io2(value);
|
|
281
|
+
return true;
|
|
282
|
+
});
|
|
283
|
+
const $io2 = (input3) => void 0 === input3.maf || "string" === typeof input3.maf;
|
|
284
|
+
const $io3 = (input3) => (void 0 === input3.minTotalDepth || "number" === typeof input3.minTotalDepth) && (void 0 === input3.minAltAlleleCount || "number" === typeof input3.minAltAlleleCount);
|
|
285
|
+
return "object" === typeof input2 && null !== input2 && $io0(input2);
|
|
286
|
+
};
|
|
287
|
+
if (false === __is(input)) {
|
|
288
|
+
const $report = import_typia.createValidate.report(errors);
|
|
289
|
+
((input2, _path, _exceptionable = true) => {
|
|
290
|
+
const $join = import_typia.createValidate.join;
|
|
291
|
+
const $vo0 = (input3, _path2, _exceptionable2 = true) => [("object" === typeof input3.caseFiles && null !== input3.caseFiles && false === Array.isArray(input3.caseFiles) || $report(_exceptionable2, {
|
|
292
|
+
path: _path2 + ".caseFiles",
|
|
293
|
+
expected: "__type",
|
|
294
|
+
value: input3.caseFiles
|
|
295
|
+
})) && $vo1(input3.caseFiles, _path2 + ".caseFiles", _exceptionable2) || $report(_exceptionable2, {
|
|
296
|
+
path: _path2 + ".caseFiles",
|
|
297
|
+
expected: "__type",
|
|
298
|
+
value: input3.caseFiles
|
|
299
|
+
}), void 0 === input3.mafOptions || ("object" === typeof input3.mafOptions && null !== input3.mafOptions && false === Array.isArray(input3.mafOptions) || $report(_exceptionable2, {
|
|
300
|
+
path: _path2 + ".mafOptions",
|
|
301
|
+
expected: "(__type.o2 | undefined)",
|
|
302
|
+
value: input3.mafOptions
|
|
303
|
+
})) && $vo3(input3.mafOptions, _path2 + ".mafOptions", _exceptionable2) || $report(_exceptionable2, {
|
|
304
|
+
path: _path2 + ".mafOptions",
|
|
305
|
+
expected: "(__type.o2 | undefined)",
|
|
306
|
+
value: input3.mafOptions
|
|
307
|
+
})].every((flag) => flag);
|
|
308
|
+
const $vo1 = (input3, _path2, _exceptionable2 = true) => [false === _exceptionable2 || Object.keys(input3).map((key) => {
|
|
309
|
+
const value = input3[key];
|
|
310
|
+
if (void 0 === value)
|
|
311
|
+
return true;
|
|
312
|
+
if (RegExp(/(.*)/).test(key))
|
|
313
|
+
return ("object" === typeof value && null !== value && false === Array.isArray(value) || $report(_exceptionable2, {
|
|
314
|
+
path: _path2 + $join(key),
|
|
315
|
+
expected: "__type.o1",
|
|
316
|
+
value
|
|
317
|
+
})) && $vo2(value, _path2 + $join(key), _exceptionable2) || $report(_exceptionable2, {
|
|
318
|
+
path: _path2 + $join(key),
|
|
319
|
+
expected: "__type.o1",
|
|
320
|
+
value
|
|
321
|
+
});
|
|
322
|
+
return true;
|
|
323
|
+
}).every((flag) => flag)].every((flag) => flag);
|
|
324
|
+
const $vo2 = (input3, _path2, _exceptionable2 = true) => [void 0 === input3.maf || "string" === typeof input3.maf || $report(_exceptionable2, {
|
|
325
|
+
path: _path2 + ".maf",
|
|
326
|
+
expected: "(string | undefined)",
|
|
327
|
+
value: input3.maf
|
|
328
|
+
})].every((flag) => flag);
|
|
329
|
+
const $vo3 = (input3, _path2, _exceptionable2 = true) => [void 0 === input3.minTotalDepth || "number" === typeof input3.minTotalDepth || $report(_exceptionable2, {
|
|
330
|
+
path: _path2 + ".minTotalDepth",
|
|
331
|
+
expected: "(number | undefined)",
|
|
332
|
+
value: input3.minTotalDepth
|
|
333
|
+
}), void 0 === input3.minAltAlleleCount || "number" === typeof input3.minAltAlleleCount || $report(_exceptionable2, {
|
|
334
|
+
path: _path2 + ".minAltAlleleCount",
|
|
335
|
+
expected: "(number | undefined)",
|
|
336
|
+
value: input3.minAltAlleleCount
|
|
337
|
+
})].every((flag) => flag);
|
|
338
|
+
return ("object" === typeof input2 && null !== input2 || $report(true, {
|
|
339
|
+
path: _path + "",
|
|
340
|
+
expected: "RunGRIN2Request",
|
|
341
|
+
value: input2
|
|
342
|
+
})) && $vo0(input2, _path + "", true) || $report(true, {
|
|
343
|
+
path: _path + "",
|
|
344
|
+
expected: "RunGRIN2Request",
|
|
345
|
+
value: input2
|
|
346
|
+
});
|
|
347
|
+
})(input, "$input", true);
|
|
348
|
+
}
|
|
349
|
+
const success = 0 === errors.length;
|
|
350
|
+
return {
|
|
351
|
+
success,
|
|
352
|
+
errors,
|
|
353
|
+
data: success ? input : void 0
|
|
354
|
+
};
|
|
355
|
+
};
|
|
356
|
+
var validRunGRIN2Response = (input) => {
|
|
357
|
+
const errors = [];
|
|
358
|
+
const __is = (input2) => {
|
|
359
|
+
const $io0 = (input3) => ("success" === input3.status || "error" === input3.status) && (void 0 === input3.error || "string" === typeof input3.error) && (void 0 === input3.pngImg || "string" === typeof input3.pngImg) && true && true && (void 0 === input3.rustResult || "object" === typeof input3.rustResult && null !== input3.rustResult && $io1(input3.rustResult));
|
|
360
|
+
const $io1 = (input3) => Array.isArray(input3.successful_data) && input3.successful_data.every((elem) => Array.isArray(elem) && elem.every((elem2) => "string" === typeof elem2)) && (Array.isArray(input3.failed_files) && input3.failed_files.every((elem) => "object" === typeof elem && null !== elem && $io2(elem))) && ("object" === typeof input3.summary && null !== input3.summary && ("number" === typeof input3.summary.total_files && "number" === typeof input3.summary.successful_files && "number" === typeof input3.summary.failed_files));
|
|
361
|
+
const $io2 = (input3) => "string" === typeof input3.case_id && "string" === typeof input3.data_type && "string" === typeof input3.error_type && "string" === typeof input3.error_details && "number" === typeof input3.attempts_made;
|
|
362
|
+
return "object" === typeof input2 && null !== input2 && $io0(input2);
|
|
363
|
+
};
|
|
364
|
+
if (false === __is(input)) {
|
|
365
|
+
const $report = import_typia.createValidate.report(errors);
|
|
366
|
+
((input2, _path, _exceptionable = true) => {
|
|
367
|
+
const $vo0 = (input3, _path2, _exceptionable2 = true) => ["success" === input3.status || "error" === input3.status || $report(_exceptionable2, {
|
|
368
|
+
path: _path2 + ".status",
|
|
369
|
+
expected: '("error" | "success")',
|
|
370
|
+
value: input3.status
|
|
371
|
+
}), void 0 === input3.error || "string" === typeof input3.error || $report(_exceptionable2, {
|
|
372
|
+
path: _path2 + ".error",
|
|
373
|
+
expected: "(string | undefined)",
|
|
374
|
+
value: input3.error
|
|
375
|
+
}), void 0 === input3.pngImg || "string" === typeof input3.pngImg || $report(_exceptionable2, {
|
|
376
|
+
path: _path2 + ".pngImg",
|
|
377
|
+
expected: "(string | undefined)",
|
|
378
|
+
value: input3.pngImg
|
|
379
|
+
}), true, true, void 0 === input3.rustResult || ("object" === typeof input3.rustResult && null !== input3.rustResult || $report(_exceptionable2, {
|
|
380
|
+
path: _path2 + ".rustResult",
|
|
381
|
+
expected: "(RustGRIN2Result | undefined)",
|
|
382
|
+
value: input3.rustResult
|
|
383
|
+
})) && $vo1(input3.rustResult, _path2 + ".rustResult", _exceptionable2) || $report(_exceptionable2, {
|
|
384
|
+
path: _path2 + ".rustResult",
|
|
385
|
+
expected: "(RustGRIN2Result | undefined)",
|
|
386
|
+
value: input3.rustResult
|
|
387
|
+
})].every((flag) => flag);
|
|
388
|
+
const $vo1 = (input3, _path2, _exceptionable2 = true) => [(Array.isArray(input3.successful_data) || $report(_exceptionable2, {
|
|
389
|
+
path: _path2 + ".successful_data",
|
|
390
|
+
expected: "Array<Array<string>>",
|
|
391
|
+
value: input3.successful_data
|
|
392
|
+
})) && input3.successful_data.map((elem, _index1) => (Array.isArray(elem) || $report(_exceptionable2, {
|
|
393
|
+
path: _path2 + ".successful_data[" + _index1 + "]",
|
|
394
|
+
expected: "Array<string>",
|
|
395
|
+
value: elem
|
|
396
|
+
})) && elem.map((elem2, _index2) => "string" === typeof elem2 || $report(_exceptionable2, {
|
|
397
|
+
path: _path2 + ".successful_data[" + _index1 + "][" + _index2 + "]",
|
|
398
|
+
expected: "string",
|
|
399
|
+
value: elem2
|
|
400
|
+
})).every((flag) => flag) || $report(_exceptionable2, {
|
|
401
|
+
path: _path2 + ".successful_data[" + _index1 + "]",
|
|
402
|
+
expected: "Array<string>",
|
|
403
|
+
value: elem
|
|
404
|
+
})).every((flag) => flag) || $report(_exceptionable2, {
|
|
405
|
+
path: _path2 + ".successful_data",
|
|
406
|
+
expected: "Array<Array<string>>",
|
|
407
|
+
value: input3.successful_data
|
|
408
|
+
}), (Array.isArray(input3.failed_files) || $report(_exceptionable2, {
|
|
409
|
+
path: _path2 + ".failed_files",
|
|
410
|
+
expected: "Array<RustErrorEntry>",
|
|
411
|
+
value: input3.failed_files
|
|
412
|
+
})) && input3.failed_files.map((elem, _index3) => ("object" === typeof elem && null !== elem || $report(_exceptionable2, {
|
|
413
|
+
path: _path2 + ".failed_files[" + _index3 + "]",
|
|
414
|
+
expected: "RustErrorEntry",
|
|
415
|
+
value: elem
|
|
416
|
+
})) && $vo2(elem, _path2 + ".failed_files[" + _index3 + "]", _exceptionable2) || $report(_exceptionable2, {
|
|
417
|
+
path: _path2 + ".failed_files[" + _index3 + "]",
|
|
418
|
+
expected: "RustErrorEntry",
|
|
419
|
+
value: elem
|
|
420
|
+
})).every((flag) => flag) || $report(_exceptionable2, {
|
|
421
|
+
path: _path2 + ".failed_files",
|
|
422
|
+
expected: "Array<RustErrorEntry>",
|
|
423
|
+
value: input3.failed_files
|
|
424
|
+
}), ("object" === typeof input3.summary && null !== input3.summary || $report(_exceptionable2, {
|
|
425
|
+
path: _path2 + ".summary",
|
|
426
|
+
expected: "RustSummary",
|
|
427
|
+
value: input3.summary
|
|
428
|
+
})) && $vo3(input3.summary, _path2 + ".summary", _exceptionable2) || $report(_exceptionable2, {
|
|
429
|
+
path: _path2 + ".summary",
|
|
430
|
+
expected: "RustSummary",
|
|
431
|
+
value: input3.summary
|
|
432
|
+
})].every((flag) => flag);
|
|
433
|
+
const $vo2 = (input3, _path2, _exceptionable2 = true) => ["string" === typeof input3.case_id || $report(_exceptionable2, {
|
|
434
|
+
path: _path2 + ".case_id",
|
|
435
|
+
expected: "string",
|
|
436
|
+
value: input3.case_id
|
|
437
|
+
}), "string" === typeof input3.data_type || $report(_exceptionable2, {
|
|
438
|
+
path: _path2 + ".data_type",
|
|
439
|
+
expected: "string",
|
|
440
|
+
value: input3.data_type
|
|
441
|
+
}), "string" === typeof input3.error_type || $report(_exceptionable2, {
|
|
442
|
+
path: _path2 + ".error_type",
|
|
443
|
+
expected: "string",
|
|
444
|
+
value: input3.error_type
|
|
445
|
+
}), "string" === typeof input3.error_details || $report(_exceptionable2, {
|
|
446
|
+
path: _path2 + ".error_details",
|
|
447
|
+
expected: "string",
|
|
448
|
+
value: input3.error_details
|
|
449
|
+
}), "number" === typeof input3.attempts_made || $report(_exceptionable2, {
|
|
450
|
+
path: _path2 + ".attempts_made",
|
|
451
|
+
expected: "number",
|
|
452
|
+
value: input3.attempts_made
|
|
453
|
+
})].every((flag) => flag);
|
|
454
|
+
const $vo3 = (input3, _path2, _exceptionable2 = true) => ["number" === typeof input3.total_files || $report(_exceptionable2, {
|
|
455
|
+
path: _path2 + ".total_files",
|
|
456
|
+
expected: "number",
|
|
457
|
+
value: input3.total_files
|
|
458
|
+
}), "number" === typeof input3.successful_files || $report(_exceptionable2, {
|
|
459
|
+
path: _path2 + ".successful_files",
|
|
460
|
+
expected: "number",
|
|
461
|
+
value: input3.successful_files
|
|
462
|
+
}), "number" === typeof input3.failed_files || $report(_exceptionable2, {
|
|
463
|
+
path: _path2 + ".failed_files",
|
|
464
|
+
expected: "number",
|
|
465
|
+
value: input3.failed_files
|
|
466
|
+
})].every((flag) => flag);
|
|
467
|
+
return ("object" === typeof input2 && null !== input2 || $report(true, {
|
|
468
|
+
path: _path + "",
|
|
469
|
+
expected: "RunGRIN2Response",
|
|
470
|
+
value: input2
|
|
471
|
+
})) && $vo0(input2, _path + "", true) || $report(true, {
|
|
472
|
+
path: _path + "",
|
|
473
|
+
expected: "RunGRIN2Response",
|
|
474
|
+
value: input2
|
|
475
|
+
});
|
|
476
|
+
})(input, "$input", true);
|
|
477
|
+
}
|
|
478
|
+
const success = 0 === errors.length;
|
|
479
|
+
return {
|
|
480
|
+
success,
|
|
481
|
+
errors,
|
|
482
|
+
data: success ? input : void 0
|
|
483
|
+
};
|
|
484
|
+
};
|
|
485
|
+
|
|
486
|
+
export {
|
|
487
|
+
gdcGRIN2listPayload,
|
|
488
|
+
runGRIN2Payload,
|
|
489
|
+
validGdcGRIN2listRequest,
|
|
490
|
+
validGdcGRIN2listResponse,
|
|
491
|
+
validRunGRIN2Request,
|
|
492
|
+
validRunGRIN2Response
|
|
493
|
+
};
|
package/dist/gdc.grin2.js
CHANGED
package/dist/index.js
CHANGED
package/package.json
CHANGED
package/src/dataset.ts
CHANGED
|
@@ -1495,41 +1495,51 @@ type MutationSet = {
|
|
|
1495
1495
|
fusion: string
|
|
1496
1496
|
}
|
|
1497
1497
|
|
|
1498
|
-
|
|
1498
|
+
/** different methods to return samples with assay availability info */
|
|
1499
|
+
type DtAssayAvailability = DtAssayAvailabilityGetter | DtAssayAvailabilityTerm
|
|
1500
|
+
|
|
1501
|
+
/** using ds-supplied getter */
|
|
1502
|
+
type DtAssayAvailabilityGetter = {
|
|
1503
|
+
get: (q: any) => any
|
|
1504
|
+
}
|
|
1505
|
+
/** using dictionary term */
|
|
1506
|
+
type DtAssayAvailabilityTerm = {
|
|
1507
|
+
/** id of this assay term for this dt */
|
|
1499
1508
|
term_id: string
|
|
1509
|
+
/** optional label */
|
|
1510
|
+
label?: string
|
|
1511
|
+
/** categories meaning the sample has this assay */
|
|
1500
1512
|
yes: { value: string[] }
|
|
1513
|
+
/** categories meaning the sample doesn't have this assay */
|
|
1501
1514
|
no: { value: string[] }
|
|
1502
|
-
label?: string
|
|
1503
|
-
}
|
|
1504
|
-
|
|
1505
|
-
type SNVByOrigin = {
|
|
1506
|
-
[index: string]: BaseDtEntry
|
|
1507
|
-
}
|
|
1508
|
-
|
|
1509
|
-
type DtEntrySNV = {
|
|
1510
|
-
byOrigin: SNVByOrigin
|
|
1511
|
-
}
|
|
1512
|
-
|
|
1513
|
-
type ByDt = {
|
|
1514
|
-
/** SNVs differentiate by sample origin. Non-SNV, no differentiation*/
|
|
1515
|
-
[index: number]: DtEntrySNV | BaseDtEntry
|
|
1516
1515
|
}
|
|
1517
1516
|
|
|
1518
|
-
type
|
|
1519
|
-
|
|
1517
|
+
type DtAssayAvailabilityByOrigin = {
|
|
1518
|
+
byOrigin: {
|
|
1519
|
+
/** each key is an origin value or category */
|
|
1520
|
+
[index: string]: DtAssayAvailability
|
|
1521
|
+
}
|
|
1520
1522
|
}
|
|
1521
1523
|
|
|
1522
|
-
type
|
|
1523
|
-
|
|
1524
|
-
|
|
1525
|
-
|
|
1526
|
-
|
|
1524
|
+
type Mds3AssayAvailability = {
|
|
1525
|
+
/** object of key-value pairs. keys are dt values */
|
|
1526
|
+
byDt: {
|
|
1527
|
+
/** each index is a dt value */
|
|
1528
|
+
[index: number]: DtAssayAvailabilityByOrigin | DtAssayAvailability
|
|
1529
|
+
}
|
|
1527
1530
|
}
|
|
1528
1531
|
|
|
1529
|
-
|
|
1530
|
-
|
|
1532
|
+
// mds legacy; delete when all are migrated to mds3
|
|
1533
|
+
type LegacyAssayAvailability = {
|
|
1531
1534
|
file?: string
|
|
1532
|
-
assays?:
|
|
1535
|
+
assays?: {
|
|
1536
|
+
id: string
|
|
1537
|
+
name: string
|
|
1538
|
+
type: string
|
|
1539
|
+
values?: {
|
|
1540
|
+
[index: string]: { label: string; color: string }
|
|
1541
|
+
}
|
|
1542
|
+
}[]
|
|
1533
1543
|
}
|
|
1534
1544
|
|
|
1535
1545
|
export type CumBurdenData = {
|
|
@@ -1887,7 +1897,7 @@ type ViewMode = {
|
|
|
1887
1897
|
/*** types supporting Mds Dataset types ***/
|
|
1888
1898
|
type BaseMds = {
|
|
1889
1899
|
genome?: string //Not declared in TermdbTest
|
|
1890
|
-
assayAvailability?:
|
|
1900
|
+
assayAvailability?: Mds3AssayAvailability | LegacyAssayAvailability
|
|
1891
1901
|
}
|
|
1892
1902
|
|
|
1893
1903
|
export type Mds = BaseMds & {
|
|
@@ -1965,6 +1975,14 @@ export type isSupportedChartCallbacks = {
|
|
|
1965
1975
|
}
|
|
1966
1976
|
|
|
1967
1977
|
export type Mds3 = BaseMds & {
|
|
1978
|
+
/** set in initGenomesDs.js during launch, should use .genomename instead of .genome */
|
|
1979
|
+
genomename?: string // use this
|
|
1980
|
+
genome?: string // avoid using it
|
|
1981
|
+
/** server-side genome obj to which this ds belongs to is attached here in initGenomesDs.js during launch,
|
|
1982
|
+
so this obj can be conveniently available to server side functions without having to introduce extra param
|
|
1983
|
+
TODO apply Genome type
|
|
1984
|
+
*/
|
|
1985
|
+
genomeObj?: any
|
|
1968
1986
|
label?: Title
|
|
1969
1987
|
isMds3: boolean
|
|
1970
1988
|
loadWithoutBlocking?: boolean
|
package/src/routes/gdc.grin2.ts
CHANGED
|
@@ -62,13 +62,67 @@ export type GdcGRIN2listResponse = {
|
|
|
62
62
|
appliedFilters?: {
|
|
63
63
|
experimentalStrategy?: ExperimentalStrategy
|
|
64
64
|
}
|
|
65
|
+
/** Deduplication stats */
|
|
66
|
+
deduplicationStats?: {
|
|
67
|
+
originalFileCount: number
|
|
68
|
+
deduplicatedFileCount: number
|
|
69
|
+
duplicatesRemoved: number
|
|
70
|
+
caseDetails?: Array<{ caseName: string; fileCount: number; keptFileSize: number }>
|
|
71
|
+
filteredFiles: Array<{ fileId: string; fileSize: number; reason: string }>
|
|
72
|
+
}
|
|
65
73
|
}
|
|
66
74
|
|
|
67
75
|
/**
|
|
68
76
|
* Parameters for running GRIN2 analysis
|
|
69
77
|
*/
|
|
78
|
+
|
|
70
79
|
export type RunGRIN2Request = {
|
|
71
|
-
|
|
80
|
+
/** Case files to analyze - maps case ID to file information */
|
|
81
|
+
caseFiles: {
|
|
82
|
+
[caseId: string]: {
|
|
83
|
+
maf?: string
|
|
84
|
+
}
|
|
85
|
+
}
|
|
86
|
+
/** Options for filtering MAF file content */
|
|
87
|
+
mafOptions?: {
|
|
88
|
+
/** Minimum total depth of returned MAF files */
|
|
89
|
+
minTotalDepth?: number // Default: 10
|
|
90
|
+
/** Minimum alternate allele count of returned MAF files */
|
|
91
|
+
minAltAlleleCount?: number // Default: 2
|
|
92
|
+
}
|
|
93
|
+
/** Options for CNV file retrieval (will be added later)
|
|
94
|
+
cnvOptions?: {
|
|
95
|
+
* lossThreshold?: number // Default: -0.5
|
|
96
|
+
* gainThreshold?: number // Default: 0.5
|
|
97
|
+
* segLength?: number // Default: 2000000
|
|
98
|
+
*}
|
|
99
|
+
*/
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
/** Error entry from failed file downloads */
|
|
103
|
+
export type RustErrorEntry = {
|
|
104
|
+
case_id: string
|
|
105
|
+
data_type: string
|
|
106
|
+
error_type: string
|
|
107
|
+
error_details: string
|
|
108
|
+
attempts_made: number
|
|
109
|
+
}
|
|
110
|
+
|
|
111
|
+
/** Summary information from Rust processing */
|
|
112
|
+
export type RustSummary = {
|
|
113
|
+
total_files: number
|
|
114
|
+
successful_files: number
|
|
115
|
+
failed_files: number
|
|
116
|
+
}
|
|
117
|
+
|
|
118
|
+
/** Structured output from Rust GRIN2 processing */
|
|
119
|
+
export type RustGRIN2Result = {
|
|
120
|
+
/** Array of successful file data arrays */
|
|
121
|
+
successful_data: string[][]
|
|
122
|
+
/** Array of failed file information */
|
|
123
|
+
failed_files: RustErrorEntry[]
|
|
124
|
+
/** Summary statistics */
|
|
125
|
+
summary: RustSummary
|
|
72
126
|
}
|
|
73
127
|
|
|
74
128
|
/**
|
|
@@ -84,7 +138,9 @@ export type RunGRIN2Response = {
|
|
|
84
138
|
/** Download status */
|
|
85
139
|
download?: any
|
|
86
140
|
/** Table of top genes indentified by analysis */
|
|
87
|
-
|
|
141
|
+
topGeneTable?: any
|
|
142
|
+
/** Data from Rust for making the failed files div */
|
|
143
|
+
rustResult?: RustGRIN2Result
|
|
88
144
|
}
|
|
89
145
|
/**
|
|
90
146
|
* Route payload definitions for type checking
|
package/dist/chunk-DJ5QE625.js
DELETED
|
@@ -1,294 +0,0 @@
|
|
|
1
|
-
import {
|
|
2
|
-
__toESM,
|
|
3
|
-
require_lib
|
|
4
|
-
} from "./chunk-CNSSF43V.js";
|
|
5
|
-
|
|
6
|
-
// dist/gdc.grin2.ts
|
|
7
|
-
var import_typia = __toESM(require_lib(), 1);
|
|
8
|
-
|
|
9
|
-
// src/routes/gdc.grin2.ts
|
|
10
|
-
var gdcGRIN2listPayload = {
|
|
11
|
-
request: {
|
|
12
|
-
typeId: "GdcGRIN2listRequest"
|
|
13
|
-
},
|
|
14
|
-
response: {
|
|
15
|
-
typeId: "GdcGRIN2listResponse"
|
|
16
|
-
}
|
|
17
|
-
};
|
|
18
|
-
var runGRIN2Payload = {
|
|
19
|
-
request: {
|
|
20
|
-
typeId: "RunGRIN2Request"
|
|
21
|
-
},
|
|
22
|
-
response: {
|
|
23
|
-
typeId: "RunGRIN2Response"
|
|
24
|
-
}
|
|
25
|
-
};
|
|
26
|
-
|
|
27
|
-
// dist/gdc.grin2.ts
|
|
28
|
-
var validGdcGRIN2listRequest = (input) => {
|
|
29
|
-
const errors = [];
|
|
30
|
-
const __is = (input2) => {
|
|
31
|
-
const $io0 = (input3) => (void 0 === input3.mafOptions || "object" === typeof input3.mafOptions && null !== input3.mafOptions && $io1(input3.mafOptions)) && true && true;
|
|
32
|
-
const $io1 = (input3) => "WXS" === input3.experimentalStrategy;
|
|
33
|
-
return "object" === typeof input2 && null !== input2 && false === Array.isArray(input2) && $io0(input2);
|
|
34
|
-
};
|
|
35
|
-
if (false === __is(input)) {
|
|
36
|
-
const $report = import_typia.createValidate.report(errors);
|
|
37
|
-
((input2, _path, _exceptionable = true) => {
|
|
38
|
-
const $vo0 = (input3, _path2, _exceptionable2 = true) => [true, void 0 === input3.mafOptions || ("object" === typeof input3.mafOptions && null !== input3.mafOptions || $report(_exceptionable2, {
|
|
39
|
-
path: _path2 + ".mafOptions",
|
|
40
|
-
expected: "(__type | undefined)",
|
|
41
|
-
value: input3.mafOptions
|
|
42
|
-
})) && $vo1(input3.mafOptions, _path2 + ".mafOptions", _exceptionable2) || $report(_exceptionable2, {
|
|
43
|
-
path: _path2 + ".mafOptions",
|
|
44
|
-
expected: "(__type | undefined)",
|
|
45
|
-
value: input3.mafOptions
|
|
46
|
-
}), true, true].every((flag) => flag);
|
|
47
|
-
const $vo1 = (input3, _path2, _exceptionable2 = true) => ["WXS" === input3.experimentalStrategy || $report(_exceptionable2, {
|
|
48
|
-
path: _path2 + ".experimentalStrategy",
|
|
49
|
-
expected: '"WXS"',
|
|
50
|
-
value: input3.experimentalStrategy
|
|
51
|
-
})].every((flag) => flag);
|
|
52
|
-
return ("object" === typeof input2 && null !== input2 && false === Array.isArray(input2) || $report(true, {
|
|
53
|
-
path: _path + "",
|
|
54
|
-
expected: "GdcGRIN2listRequest",
|
|
55
|
-
value: input2
|
|
56
|
-
})) && $vo0(input2, _path + "", true) || $report(true, {
|
|
57
|
-
path: _path + "",
|
|
58
|
-
expected: "GdcGRIN2listRequest",
|
|
59
|
-
value: input2
|
|
60
|
-
});
|
|
61
|
-
})(input, "$input", true);
|
|
62
|
-
}
|
|
63
|
-
const success = 0 === errors.length;
|
|
64
|
-
return {
|
|
65
|
-
success,
|
|
66
|
-
errors,
|
|
67
|
-
data: success ? input : void 0
|
|
68
|
-
};
|
|
69
|
-
};
|
|
70
|
-
var validGdcGRIN2listResponse = (input) => {
|
|
71
|
-
const errors = [];
|
|
72
|
-
const __is = (input2) => {
|
|
73
|
-
const $io0 = (input3) => Array.isArray(input3.files) && input3.files.every((elem) => "object" === typeof elem && null !== elem && $io1(elem)) && "number" === typeof input3.filesTotal && "number" === typeof input3.maxTotalSizeCompressed && (void 0 === input3.fileCounts || "object" === typeof input3.fileCounts && null !== input3.fileCounts && $io2(input3.fileCounts)) && (void 0 === input3.appliedFilters || "object" === typeof input3.appliedFilters && null !== input3.appliedFilters && false === Array.isArray(input3.appliedFilters) && $io3(input3.appliedFilters));
|
|
74
|
-
const $io1 = (input3) => "string" === typeof input3.id && "string" === typeof input3.case_submitter_id && "string" === typeof input3.case_uuid && "number" === typeof input3.file_size && (Array.isArray(input3.sample_types) && input3.sample_types.every((elem) => "string" === typeof elem)) && "string" === typeof input3.project_id && (void 0 === input3.file_format || "MAF" === input3.file_format);
|
|
75
|
-
const $io2 = (input3) => "number" === typeof input3.maf;
|
|
76
|
-
const $io3 = (input3) => void 0 === input3.experimentalStrategy || "WXS" === input3.experimentalStrategy;
|
|
77
|
-
return "object" === typeof input2 && null !== input2 && $io0(input2);
|
|
78
|
-
};
|
|
79
|
-
if (false === __is(input)) {
|
|
80
|
-
const $report = import_typia.createValidate.report(errors);
|
|
81
|
-
((input2, _path, _exceptionable = true) => {
|
|
82
|
-
const $vo0 = (input3, _path2, _exceptionable2 = true) => [(Array.isArray(input3.files) || $report(_exceptionable2, {
|
|
83
|
-
path: _path2 + ".files",
|
|
84
|
-
expected: "Array<GdcGRIN2File>",
|
|
85
|
-
value: input3.files
|
|
86
|
-
})) && input3.files.map((elem, _index1) => ("object" === typeof elem && null !== elem || $report(_exceptionable2, {
|
|
87
|
-
path: _path2 + ".files[" + _index1 + "]",
|
|
88
|
-
expected: "GdcGRIN2File",
|
|
89
|
-
value: elem
|
|
90
|
-
})) && $vo1(elem, _path2 + ".files[" + _index1 + "]", _exceptionable2) || $report(_exceptionable2, {
|
|
91
|
-
path: _path2 + ".files[" + _index1 + "]",
|
|
92
|
-
expected: "GdcGRIN2File",
|
|
93
|
-
value: elem
|
|
94
|
-
})).every((flag) => flag) || $report(_exceptionable2, {
|
|
95
|
-
path: _path2 + ".files",
|
|
96
|
-
expected: "Array<GdcGRIN2File>",
|
|
97
|
-
value: input3.files
|
|
98
|
-
}), "number" === typeof input3.filesTotal || $report(_exceptionable2, {
|
|
99
|
-
path: _path2 + ".filesTotal",
|
|
100
|
-
expected: "number",
|
|
101
|
-
value: input3.filesTotal
|
|
102
|
-
}), "number" === typeof input3.maxTotalSizeCompressed || $report(_exceptionable2, {
|
|
103
|
-
path: _path2 + ".maxTotalSizeCompressed",
|
|
104
|
-
expected: "number",
|
|
105
|
-
value: input3.maxTotalSizeCompressed
|
|
106
|
-
}), void 0 === input3.fileCounts || ("object" === typeof input3.fileCounts && null !== input3.fileCounts || $report(_exceptionable2, {
|
|
107
|
-
path: _path2 + ".fileCounts",
|
|
108
|
-
expected: "(__type | undefined)",
|
|
109
|
-
value: input3.fileCounts
|
|
110
|
-
})) && $vo2(input3.fileCounts, _path2 + ".fileCounts", _exceptionable2) || $report(_exceptionable2, {
|
|
111
|
-
path: _path2 + ".fileCounts",
|
|
112
|
-
expected: "(__type | undefined)",
|
|
113
|
-
value: input3.fileCounts
|
|
114
|
-
}), void 0 === input3.appliedFilters || ("object" === typeof input3.appliedFilters && null !== input3.appliedFilters && false === Array.isArray(input3.appliedFilters) || $report(_exceptionable2, {
|
|
115
|
-
path: _path2 + ".appliedFilters",
|
|
116
|
-
expected: "(__type.o1 | undefined)",
|
|
117
|
-
value: input3.appliedFilters
|
|
118
|
-
})) && $vo3(input3.appliedFilters, _path2 + ".appliedFilters", _exceptionable2) || $report(_exceptionable2, {
|
|
119
|
-
path: _path2 + ".appliedFilters",
|
|
120
|
-
expected: "(__type.o1 | undefined)",
|
|
121
|
-
value: input3.appliedFilters
|
|
122
|
-
})].every((flag) => flag);
|
|
123
|
-
const $vo1 = (input3, _path2, _exceptionable2 = true) => ["string" === typeof input3.id || $report(_exceptionable2, {
|
|
124
|
-
path: _path2 + ".id",
|
|
125
|
-
expected: "string",
|
|
126
|
-
value: input3.id
|
|
127
|
-
}), "string" === typeof input3.case_submitter_id || $report(_exceptionable2, {
|
|
128
|
-
path: _path2 + ".case_submitter_id",
|
|
129
|
-
expected: "string",
|
|
130
|
-
value: input3.case_submitter_id
|
|
131
|
-
}), "string" === typeof input3.case_uuid || $report(_exceptionable2, {
|
|
132
|
-
path: _path2 + ".case_uuid",
|
|
133
|
-
expected: "string",
|
|
134
|
-
value: input3.case_uuid
|
|
135
|
-
}), "number" === typeof input3.file_size || $report(_exceptionable2, {
|
|
136
|
-
path: _path2 + ".file_size",
|
|
137
|
-
expected: "number",
|
|
138
|
-
value: input3.file_size
|
|
139
|
-
}), (Array.isArray(input3.sample_types) || $report(_exceptionable2, {
|
|
140
|
-
path: _path2 + ".sample_types",
|
|
141
|
-
expected: "Array<string>",
|
|
142
|
-
value: input3.sample_types
|
|
143
|
-
})) && input3.sample_types.map((elem, _index2) => "string" === typeof elem || $report(_exceptionable2, {
|
|
144
|
-
path: _path2 + ".sample_types[" + _index2 + "]",
|
|
145
|
-
expected: "string",
|
|
146
|
-
value: elem
|
|
147
|
-
})).every((flag) => flag) || $report(_exceptionable2, {
|
|
148
|
-
path: _path2 + ".sample_types",
|
|
149
|
-
expected: "Array<string>",
|
|
150
|
-
value: input3.sample_types
|
|
151
|
-
}), "string" === typeof input3.project_id || $report(_exceptionable2, {
|
|
152
|
-
path: _path2 + ".project_id",
|
|
153
|
-
expected: "string",
|
|
154
|
-
value: input3.project_id
|
|
155
|
-
}), void 0 === input3.file_format || "MAF" === input3.file_format || $report(_exceptionable2, {
|
|
156
|
-
path: _path2 + ".file_format",
|
|
157
|
-
expected: '("MAF" | undefined)',
|
|
158
|
-
value: input3.file_format
|
|
159
|
-
})].every((flag) => flag);
|
|
160
|
-
const $vo2 = (input3, _path2, _exceptionable2 = true) => ["number" === typeof input3.maf || $report(_exceptionable2, {
|
|
161
|
-
path: _path2 + ".maf",
|
|
162
|
-
expected: "number",
|
|
163
|
-
value: input3.maf
|
|
164
|
-
})].every((flag) => flag);
|
|
165
|
-
const $vo3 = (input3, _path2, _exceptionable2 = true) => [void 0 === input3.experimentalStrategy || "WXS" === input3.experimentalStrategy || $report(_exceptionable2, {
|
|
166
|
-
path: _path2 + ".experimentalStrategy",
|
|
167
|
-
expected: '("WXS" | undefined)',
|
|
168
|
-
value: input3.experimentalStrategy
|
|
169
|
-
})].every((flag) => flag);
|
|
170
|
-
return ("object" === typeof input2 && null !== input2 || $report(true, {
|
|
171
|
-
path: _path + "",
|
|
172
|
-
expected: "GdcGRIN2listResponse",
|
|
173
|
-
value: input2
|
|
174
|
-
})) && $vo0(input2, _path + "", true) || $report(true, {
|
|
175
|
-
path: _path + "",
|
|
176
|
-
expected: "GdcGRIN2listResponse",
|
|
177
|
-
value: input2
|
|
178
|
-
});
|
|
179
|
-
})(input, "$input", true);
|
|
180
|
-
}
|
|
181
|
-
const success = 0 === errors.length;
|
|
182
|
-
return {
|
|
183
|
-
success,
|
|
184
|
-
errors,
|
|
185
|
-
data: success ? input : void 0
|
|
186
|
-
};
|
|
187
|
-
};
|
|
188
|
-
var validRunGRIN2Request = (input) => {
|
|
189
|
-
const errors = [];
|
|
190
|
-
const __is = (input2) => {
|
|
191
|
-
const $join = import_typia.createValidate.join;
|
|
192
|
-
const $io0 = (input3) => Object.keys(input3).every((key) => {
|
|
193
|
-
const value = input3[key];
|
|
194
|
-
if (void 0 === value)
|
|
195
|
-
return true;
|
|
196
|
-
if (RegExp(/(.*)/).test(key))
|
|
197
|
-
return "object" === typeof value && null !== value && false === Array.isArray(value) && $io1(value);
|
|
198
|
-
return true;
|
|
199
|
-
});
|
|
200
|
-
const $io1 = (input3) => void 0 === input3.maf || "string" === typeof input3.maf;
|
|
201
|
-
return "object" === typeof input2 && null !== input2 && false === Array.isArray(input2) && $io0(input2);
|
|
202
|
-
};
|
|
203
|
-
if (false === __is(input)) {
|
|
204
|
-
const $report = import_typia.createValidate.report(errors);
|
|
205
|
-
((input2, _path, _exceptionable = true) => {
|
|
206
|
-
const $join = import_typia.createValidate.join;
|
|
207
|
-
const $vo0 = (input3, _path2, _exceptionable2 = true) => [false === _exceptionable2 || Object.keys(input3).map((key) => {
|
|
208
|
-
const value = input3[key];
|
|
209
|
-
if (void 0 === value)
|
|
210
|
-
return true;
|
|
211
|
-
if (RegExp(/(.*)/).test(key))
|
|
212
|
-
return ("object" === typeof value && null !== value && false === Array.isArray(value) || $report(_exceptionable2, {
|
|
213
|
-
path: _path2 + $join(key),
|
|
214
|
-
expected: "__type",
|
|
215
|
-
value
|
|
216
|
-
})) && $vo1(value, _path2 + $join(key), _exceptionable2) || $report(_exceptionable2, {
|
|
217
|
-
path: _path2 + $join(key),
|
|
218
|
-
expected: "__type",
|
|
219
|
-
value
|
|
220
|
-
});
|
|
221
|
-
return true;
|
|
222
|
-
}).every((flag) => flag)].every((flag) => flag);
|
|
223
|
-
const $vo1 = (input3, _path2, _exceptionable2 = true) => [void 0 === input3.maf || "string" === typeof input3.maf || $report(_exceptionable2, {
|
|
224
|
-
path: _path2 + ".maf",
|
|
225
|
-
expected: "(string | undefined)",
|
|
226
|
-
value: input3.maf
|
|
227
|
-
})].every((flag) => flag);
|
|
228
|
-
return ("object" === typeof input2 && null !== input2 && false === Array.isArray(input2) || $report(true, {
|
|
229
|
-
path: _path + "",
|
|
230
|
-
expected: "RunGRIN2Request",
|
|
231
|
-
value: input2
|
|
232
|
-
})) && $vo0(input2, _path + "", true) || $report(true, {
|
|
233
|
-
path: _path + "",
|
|
234
|
-
expected: "RunGRIN2Request",
|
|
235
|
-
value: input2
|
|
236
|
-
});
|
|
237
|
-
})(input, "$input", true);
|
|
238
|
-
}
|
|
239
|
-
const success = 0 === errors.length;
|
|
240
|
-
return {
|
|
241
|
-
success,
|
|
242
|
-
errors,
|
|
243
|
-
data: success ? input : void 0
|
|
244
|
-
};
|
|
245
|
-
};
|
|
246
|
-
var validRunGRIN2Response = (input) => {
|
|
247
|
-
const errors = [];
|
|
248
|
-
const __is = (input2) => {
|
|
249
|
-
const $io0 = (input3) => ("success" === input3.status || "error" === input3.status) && (void 0 === input3.error || "string" === typeof input3.error) && (void 0 === input3.pngImg || "string" === typeof input3.pngImg) && true && true;
|
|
250
|
-
return "object" === typeof input2 && null !== input2 && $io0(input2);
|
|
251
|
-
};
|
|
252
|
-
if (false === __is(input)) {
|
|
253
|
-
const $report = import_typia.createValidate.report(errors);
|
|
254
|
-
((input2, _path, _exceptionable = true) => {
|
|
255
|
-
const $vo0 = (input3, _path2, _exceptionable2 = true) => ["success" === input3.status || "error" === input3.status || $report(_exceptionable2, {
|
|
256
|
-
path: _path2 + ".status",
|
|
257
|
-
expected: '("error" | "success")',
|
|
258
|
-
value: input3.status
|
|
259
|
-
}), void 0 === input3.error || "string" === typeof input3.error || $report(_exceptionable2, {
|
|
260
|
-
path: _path2 + ".error",
|
|
261
|
-
expected: "(string | undefined)",
|
|
262
|
-
value: input3.error
|
|
263
|
-
}), void 0 === input3.pngImg || "string" === typeof input3.pngImg || $report(_exceptionable2, {
|
|
264
|
-
path: _path2 + ".pngImg",
|
|
265
|
-
expected: "(string | undefined)",
|
|
266
|
-
value: input3.pngImg
|
|
267
|
-
}), true, true].every((flag) => flag);
|
|
268
|
-
return ("object" === typeof input2 && null !== input2 || $report(true, {
|
|
269
|
-
path: _path + "",
|
|
270
|
-
expected: "RunGRIN2Response",
|
|
271
|
-
value: input2
|
|
272
|
-
})) && $vo0(input2, _path + "", true) || $report(true, {
|
|
273
|
-
path: _path + "",
|
|
274
|
-
expected: "RunGRIN2Response",
|
|
275
|
-
value: input2
|
|
276
|
-
});
|
|
277
|
-
})(input, "$input", true);
|
|
278
|
-
}
|
|
279
|
-
const success = 0 === errors.length;
|
|
280
|
-
return {
|
|
281
|
-
success,
|
|
282
|
-
errors,
|
|
283
|
-
data: success ? input : void 0
|
|
284
|
-
};
|
|
285
|
-
};
|
|
286
|
-
|
|
287
|
-
export {
|
|
288
|
-
gdcGRIN2listPayload,
|
|
289
|
-
runGRIN2Payload,
|
|
290
|
-
validGdcGRIN2listRequest,
|
|
291
|
-
validGdcGRIN2listResponse,
|
|
292
|
-
validRunGRIN2Request,
|
|
293
|
-
validRunGRIN2Response
|
|
294
|
-
};
|