@aws-sdk/client-omics 3.476.0 → 3.477.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.
Files changed (3) hide show
  1. package/dist-cjs/protocols/Aws_restJson1.js +565 -1096
  2. package/dist-es/protocols/Aws_restJson1.js +567 -1098
  3. package/package.json +5 -4
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,16 +1,16 @@
1
1
  import { awsExpectUnion as __expectUnion } from "@aws-sdk/core";
2
- import { HttpRequest as __HttpRequest, isValidHostname as __isValidHostname, } from "@smithy/protocol-http";
3
- import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, resolvedPath as __resolvedPath, take, withBaseException, } from "@smithy/smithy-client";
2
+ import { requestBuilder as rb } from "@smithy/core";
3
+ import { isValidHostname as __isValidHostname, } from "@smithy/protocol-http";
4
+ import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, take, withBaseException, } from "@smithy/smithy-client";
4
5
  import { v4 as generateIdempotencyToken } from "uuid";
5
6
  import { AccessDeniedException, ConflictException, InternalServerException, NotSupportedOperationException, RangeNotSatisfiableException, RequestTimeoutException, ResourceNotFoundException, ServiceQuotaExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
6
7
  import { OmicsServiceException as __BaseException } from "../models/OmicsServiceException";
7
8
  export const se_AbortMultipartReadSetUploadCommand = async (input, context) => {
8
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
9
+ const b = rb(input, context);
9
10
  const headers = {};
10
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
11
- "/sequencestore/{sequenceStoreId}/upload/{uploadId}/abort";
12
- resolvedPath = __resolvedPath(resolvedPath, input, "sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
13
- resolvedPath = __resolvedPath(resolvedPath, input, "uploadId", () => input.uploadId, "{uploadId}", false);
11
+ b.bp("/sequencestore/{sequenceStoreId}/upload/{uploadId}/abort");
12
+ b.p("sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
13
+ b.p("uploadId", () => input.uploadId, "{uploadId}", false);
14
14
  let body;
15
15
  let { hostname: resolvedHostname } = await context.endpoint();
16
16
  if (context.disableHostPrefix !== true) {
@@ -19,21 +19,15 @@ export const se_AbortMultipartReadSetUploadCommand = async (input, context) => {
19
19
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
20
20
  }
21
21
  }
22
- return new __HttpRequest({
23
- protocol,
24
- hostname: resolvedHostname,
25
- port,
26
- method: "DELETE",
27
- headers,
28
- path: resolvedPath,
29
- body,
30
- });
22
+ b.hn(resolvedHostname);
23
+ b.m("DELETE").h(headers).b(body);
24
+ return b.build();
31
25
  };
32
26
  export const se_AcceptShareCommand = async (input, context) => {
33
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
27
+ const b = rb(input, context);
34
28
  const headers = {};
35
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/share/{shareId}";
36
- resolvedPath = __resolvedPath(resolvedPath, input, "shareId", () => input.shareId, "{shareId}", false);
29
+ b.bp("/share/{shareId}");
30
+ b.p("shareId", () => input.shareId, "{shareId}", false);
37
31
  let body;
38
32
  let { hostname: resolvedHostname } = await context.endpoint();
39
33
  if (context.disableHostPrefix !== true) {
@@ -42,24 +36,17 @@ export const se_AcceptShareCommand = async (input, context) => {
42
36
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
43
37
  }
44
38
  }
45
- return new __HttpRequest({
46
- protocol,
47
- hostname: resolvedHostname,
48
- port,
49
- method: "POST",
50
- headers,
51
- path: resolvedPath,
52
- body,
53
- });
39
+ b.hn(resolvedHostname);
40
+ b.m("POST").h(headers).b(body);
41
+ return b.build();
54
42
  };
55
43
  export const se_BatchDeleteReadSetCommand = async (input, context) => {
56
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
44
+ const b = rb(input, context);
57
45
  const headers = {
58
46
  "content-type": "application/json",
59
47
  };
60
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
61
- "/sequencestore/{sequenceStoreId}/readset/batch/delete";
62
- resolvedPath = __resolvedPath(resolvedPath, input, "sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
48
+ b.bp("/sequencestore/{sequenceStoreId}/readset/batch/delete");
49
+ b.p("sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
63
50
  let body;
64
51
  body = JSON.stringify(take(input, {
65
52
  ids: (_) => _json(_),
@@ -71,21 +58,15 @@ export const se_BatchDeleteReadSetCommand = async (input, context) => {
71
58
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
72
59
  }
73
60
  }
74
- return new __HttpRequest({
75
- protocol,
76
- hostname: resolvedHostname,
77
- port,
78
- method: "POST",
79
- headers,
80
- path: resolvedPath,
81
- body,
82
- });
61
+ b.hn(resolvedHostname);
62
+ b.m("POST").h(headers).b(body);
63
+ return b.build();
83
64
  };
84
65
  export const se_CancelAnnotationImportJobCommand = async (input, context) => {
85
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
66
+ const b = rb(input, context);
86
67
  const headers = {};
87
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/import/annotation/{jobId}";
88
- resolvedPath = __resolvedPath(resolvedPath, input, "jobId", () => input.jobId, "{jobId}", false);
68
+ b.bp("/import/annotation/{jobId}");
69
+ b.p("jobId", () => input.jobId, "{jobId}", false);
89
70
  let body;
90
71
  let { hostname: resolvedHostname } = await context.endpoint();
91
72
  if (context.disableHostPrefix !== true) {
@@ -94,21 +75,15 @@ export const se_CancelAnnotationImportJobCommand = async (input, context) => {
94
75
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
95
76
  }
96
77
  }
97
- return new __HttpRequest({
98
- protocol,
99
- hostname: resolvedHostname,
100
- port,
101
- method: "DELETE",
102
- headers,
103
- path: resolvedPath,
104
- body,
105
- });
78
+ b.hn(resolvedHostname);
79
+ b.m("DELETE").h(headers).b(body);
80
+ return b.build();
106
81
  };
107
82
  export const se_CancelRunCommand = async (input, context) => {
108
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
83
+ const b = rb(input, context);
109
84
  const headers = {};
110
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/run/{id}/cancel";
111
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
85
+ b.bp("/run/{id}/cancel");
86
+ b.p("id", () => input.id, "{id}", false);
112
87
  let body;
113
88
  let { hostname: resolvedHostname } = await context.endpoint();
114
89
  if (context.disableHostPrefix !== true) {
@@ -117,21 +92,15 @@ export const se_CancelRunCommand = async (input, context) => {
117
92
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
118
93
  }
119
94
  }
120
- return new __HttpRequest({
121
- protocol,
122
- hostname: resolvedHostname,
123
- port,
124
- method: "POST",
125
- headers,
126
- path: resolvedPath,
127
- body,
128
- });
95
+ b.hn(resolvedHostname);
96
+ b.m("POST").h(headers).b(body);
97
+ return b.build();
129
98
  };
130
99
  export const se_CancelVariantImportJobCommand = async (input, context) => {
131
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
100
+ const b = rb(input, context);
132
101
  const headers = {};
133
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/import/variant/{jobId}";
134
- resolvedPath = __resolvedPath(resolvedPath, input, "jobId", () => input.jobId, "{jobId}", false);
102
+ b.bp("/import/variant/{jobId}");
103
+ b.p("jobId", () => input.jobId, "{jobId}", false);
135
104
  let body;
136
105
  let { hostname: resolvedHostname } = await context.endpoint();
137
106
  if (context.disableHostPrefix !== true) {
@@ -140,25 +109,18 @@ export const se_CancelVariantImportJobCommand = async (input, context) => {
140
109
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
141
110
  }
142
111
  }
143
- return new __HttpRequest({
144
- protocol,
145
- hostname: resolvedHostname,
146
- port,
147
- method: "DELETE",
148
- headers,
149
- path: resolvedPath,
150
- body,
151
- });
112
+ b.hn(resolvedHostname);
113
+ b.m("DELETE").h(headers).b(body);
114
+ return b.build();
152
115
  };
153
116
  export const se_CompleteMultipartReadSetUploadCommand = async (input, context) => {
154
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
117
+ const b = rb(input, context);
155
118
  const headers = {
156
119
  "content-type": "application/json",
157
120
  };
158
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
159
- "/sequencestore/{sequenceStoreId}/upload/{uploadId}/complete";
160
- resolvedPath = __resolvedPath(resolvedPath, input, "sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
161
- resolvedPath = __resolvedPath(resolvedPath, input, "uploadId", () => input.uploadId, "{uploadId}", false);
121
+ b.bp("/sequencestore/{sequenceStoreId}/upload/{uploadId}/complete");
122
+ b.p("sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
123
+ b.p("uploadId", () => input.uploadId, "{uploadId}", false);
162
124
  let body;
163
125
  body = JSON.stringify(take(input, {
164
126
  parts: (_) => _json(_),
@@ -170,22 +132,16 @@ export const se_CompleteMultipartReadSetUploadCommand = async (input, context) =
170
132
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
171
133
  }
172
134
  }
173
- return new __HttpRequest({
174
- protocol,
175
- hostname: resolvedHostname,
176
- port,
177
- method: "POST",
178
- headers,
179
- path: resolvedPath,
180
- body,
181
- });
135
+ b.hn(resolvedHostname);
136
+ b.m("POST").h(headers).b(body);
137
+ return b.build();
182
138
  };
183
139
  export const se_CreateAnnotationStoreCommand = async (input, context) => {
184
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
140
+ const b = rb(input, context);
185
141
  const headers = {
186
142
  "content-type": "application/json",
187
143
  };
188
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/annotationStore";
144
+ b.bp("/annotationStore");
189
145
  let body;
190
146
  body = JSON.stringify(take(input, {
191
147
  description: [],
@@ -204,23 +160,17 @@ export const se_CreateAnnotationStoreCommand = async (input, context) => {
204
160
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
205
161
  }
206
162
  }
207
- return new __HttpRequest({
208
- protocol,
209
- hostname: resolvedHostname,
210
- port,
211
- method: "POST",
212
- headers,
213
- path: resolvedPath,
214
- body,
215
- });
163
+ b.hn(resolvedHostname);
164
+ b.m("POST").h(headers).b(body);
165
+ return b.build();
216
166
  };
217
167
  export const se_CreateAnnotationStoreVersionCommand = async (input, context) => {
218
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
168
+ const b = rb(input, context);
219
169
  const headers = {
220
170
  "content-type": "application/json",
221
171
  };
222
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/annotationStore/{name}/version";
223
- resolvedPath = __resolvedPath(resolvedPath, input, "name", () => input.name, "{name}", false);
172
+ b.bp("/annotationStore/{name}/version");
173
+ b.p("name", () => input.name, "{name}", false);
224
174
  let body;
225
175
  body = JSON.stringify(take(input, {
226
176
  description: [],
@@ -235,23 +185,17 @@ export const se_CreateAnnotationStoreVersionCommand = async (input, context) =>
235
185
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
236
186
  }
237
187
  }
238
- return new __HttpRequest({
239
- protocol,
240
- hostname: resolvedHostname,
241
- port,
242
- method: "POST",
243
- headers,
244
- path: resolvedPath,
245
- body,
246
- });
188
+ b.hn(resolvedHostname);
189
+ b.m("POST").h(headers).b(body);
190
+ return b.build();
247
191
  };
248
192
  export const se_CreateMultipartReadSetUploadCommand = async (input, context) => {
249
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
193
+ const b = rb(input, context);
250
194
  const headers = {
251
195
  "content-type": "application/json",
252
196
  };
253
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sequencestore/{sequenceStoreId}/upload";
254
- resolvedPath = __resolvedPath(resolvedPath, input, "sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
197
+ b.bp("/sequencestore/{sequenceStoreId}/upload");
198
+ b.p("sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
255
199
  let body;
256
200
  body = JSON.stringify(take(input, {
257
201
  clientToken: [],
@@ -271,22 +215,16 @@ export const se_CreateMultipartReadSetUploadCommand = async (input, context) =>
271
215
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
272
216
  }
273
217
  }
274
- return new __HttpRequest({
275
- protocol,
276
- hostname: resolvedHostname,
277
- port,
278
- method: "POST",
279
- headers,
280
- path: resolvedPath,
281
- body,
282
- });
218
+ b.hn(resolvedHostname);
219
+ b.m("POST").h(headers).b(body);
220
+ return b.build();
283
221
  };
284
222
  export const se_CreateReferenceStoreCommand = async (input, context) => {
285
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
223
+ const b = rb(input, context);
286
224
  const headers = {
287
225
  "content-type": "application/json",
288
226
  };
289
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/referencestore";
227
+ b.bp("/referencestore");
290
228
  let body;
291
229
  body = JSON.stringify(take(input, {
292
230
  clientToken: [],
@@ -302,22 +240,16 @@ export const se_CreateReferenceStoreCommand = async (input, context) => {
302
240
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
303
241
  }
304
242
  }
305
- return new __HttpRequest({
306
- protocol,
307
- hostname: resolvedHostname,
308
- port,
309
- method: "POST",
310
- headers,
311
- path: resolvedPath,
312
- body,
313
- });
243
+ b.hn(resolvedHostname);
244
+ b.m("POST").h(headers).b(body);
245
+ return b.build();
314
246
  };
315
247
  export const se_CreateRunGroupCommand = async (input, context) => {
316
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
248
+ const b = rb(input, context);
317
249
  const headers = {
318
250
  "content-type": "application/json",
319
251
  };
320
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/runGroup";
252
+ b.bp("/runGroup");
321
253
  let body;
322
254
  body = JSON.stringify(take(input, {
323
255
  maxCpus: [],
@@ -335,22 +267,16 @@ export const se_CreateRunGroupCommand = async (input, context) => {
335
267
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
336
268
  }
337
269
  }
338
- return new __HttpRequest({
339
- protocol,
340
- hostname: resolvedHostname,
341
- port,
342
- method: "POST",
343
- headers,
344
- path: resolvedPath,
345
- body,
346
- });
270
+ b.hn(resolvedHostname);
271
+ b.m("POST").h(headers).b(body);
272
+ return b.build();
347
273
  };
348
274
  export const se_CreateSequenceStoreCommand = async (input, context) => {
349
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
275
+ const b = rb(input, context);
350
276
  const headers = {
351
277
  "content-type": "application/json",
352
278
  };
353
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sequencestore";
279
+ b.bp("/sequencestore");
354
280
  let body;
355
281
  body = JSON.stringify(take(input, {
356
282
  clientToken: [],
@@ -367,22 +293,16 @@ export const se_CreateSequenceStoreCommand = async (input, context) => {
367
293
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
368
294
  }
369
295
  }
370
- return new __HttpRequest({
371
- protocol,
372
- hostname: resolvedHostname,
373
- port,
374
- method: "POST",
375
- headers,
376
- path: resolvedPath,
377
- body,
378
- });
296
+ b.hn(resolvedHostname);
297
+ b.m("POST").h(headers).b(body);
298
+ return b.build();
379
299
  };
380
300
  export const se_CreateShareCommand = async (input, context) => {
381
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
301
+ const b = rb(input, context);
382
302
  const headers = {
383
303
  "content-type": "application/json",
384
304
  };
385
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/share";
305
+ b.bp("/share");
386
306
  let body;
387
307
  body = JSON.stringify(take(input, {
388
308
  principalSubscriber: [],
@@ -396,22 +316,16 @@ export const se_CreateShareCommand = async (input, context) => {
396
316
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
397
317
  }
398
318
  }
399
- return new __HttpRequest({
400
- protocol,
401
- hostname: resolvedHostname,
402
- port,
403
- method: "POST",
404
- headers,
405
- path: resolvedPath,
406
- body,
407
- });
319
+ b.hn(resolvedHostname);
320
+ b.m("POST").h(headers).b(body);
321
+ return b.build();
408
322
  };
409
323
  export const se_CreateVariantStoreCommand = async (input, context) => {
410
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
324
+ const b = rb(input, context);
411
325
  const headers = {
412
326
  "content-type": "application/json",
413
327
  };
414
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/variantStore";
328
+ b.bp("/variantStore");
415
329
  let body;
416
330
  body = JSON.stringify(take(input, {
417
331
  description: [],
@@ -427,22 +341,16 @@ export const se_CreateVariantStoreCommand = async (input, context) => {
427
341
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
428
342
  }
429
343
  }
430
- return new __HttpRequest({
431
- protocol,
432
- hostname: resolvedHostname,
433
- port,
434
- method: "POST",
435
- headers,
436
- path: resolvedPath,
437
- body,
438
- });
344
+ b.hn(resolvedHostname);
345
+ b.m("POST").h(headers).b(body);
346
+ return b.build();
439
347
  };
440
348
  export const se_CreateWorkflowCommand = async (input, context) => {
441
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
349
+ const b = rb(input, context);
442
350
  const headers = {
443
351
  "content-type": "application/json",
444
352
  };
445
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/workflow";
353
+ b.bp("/workflow");
446
354
  let body;
447
355
  body = JSON.stringify(take(input, {
448
356
  accelerators: [],
@@ -464,23 +372,17 @@ export const se_CreateWorkflowCommand = async (input, context) => {
464
372
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
465
373
  }
466
374
  }
467
- return new __HttpRequest({
468
- protocol,
469
- hostname: resolvedHostname,
470
- port,
471
- method: "POST",
472
- headers,
473
- path: resolvedPath,
474
- body,
475
- });
375
+ b.hn(resolvedHostname);
376
+ b.m("POST").h(headers).b(body);
377
+ return b.build();
476
378
  };
477
379
  export const se_DeleteAnnotationStoreCommand = async (input, context) => {
478
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
380
+ const b = rb(input, context);
479
381
  const headers = {};
480
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/annotationStore/{name}";
481
- resolvedPath = __resolvedPath(resolvedPath, input, "name", () => input.name, "{name}", false);
382
+ b.bp("/annotationStore/{name}");
383
+ b.p("name", () => input.name, "{name}", false);
482
384
  const query = map({
483
- force: [() => input.force !== void 0, () => input.force.toString()],
385
+ [_f]: [() => input.force !== void 0, () => input[_f].toString()],
484
386
  });
485
387
  let body;
486
388
  let { hostname: resolvedHostname } = await context.endpoint();
@@ -490,26 +392,19 @@ export const se_DeleteAnnotationStoreCommand = async (input, context) => {
490
392
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
491
393
  }
492
394
  }
493
- return new __HttpRequest({
494
- protocol,
495
- hostname: resolvedHostname,
496
- port,
497
- method: "DELETE",
498
- headers,
499
- path: resolvedPath,
500
- query,
501
- body,
502
- });
395
+ b.hn(resolvedHostname);
396
+ b.m("DELETE").h(headers).q(query).b(body);
397
+ return b.build();
503
398
  };
504
399
  export const se_DeleteAnnotationStoreVersionsCommand = async (input, context) => {
505
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
400
+ const b = rb(input, context);
506
401
  const headers = {
507
402
  "content-type": "application/json",
508
403
  };
509
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/annotationStore/{name}/versions/delete";
510
- resolvedPath = __resolvedPath(resolvedPath, input, "name", () => input.name, "{name}", false);
404
+ b.bp("/annotationStore/{name}/versions/delete");
405
+ b.p("name", () => input.name, "{name}", false);
511
406
  const query = map({
512
- force: [() => input.force !== void 0, () => input.force.toString()],
407
+ [_f]: [() => input.force !== void 0, () => input[_f].toString()],
513
408
  });
514
409
  let body;
515
410
  body = JSON.stringify(take(input, {
@@ -522,24 +417,16 @@ export const se_DeleteAnnotationStoreVersionsCommand = async (input, context) =>
522
417
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
523
418
  }
524
419
  }
525
- return new __HttpRequest({
526
- protocol,
527
- hostname: resolvedHostname,
528
- port,
529
- method: "POST",
530
- headers,
531
- path: resolvedPath,
532
- query,
533
- body,
534
- });
420
+ b.hn(resolvedHostname);
421
+ b.m("POST").h(headers).q(query).b(body);
422
+ return b.build();
535
423
  };
536
424
  export const se_DeleteReferenceCommand = async (input, context) => {
537
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
425
+ const b = rb(input, context);
538
426
  const headers = {};
539
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
540
- "/referencestore/{referenceStoreId}/reference/{id}";
541
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
542
- resolvedPath = __resolvedPath(resolvedPath, input, "referenceStoreId", () => input.referenceStoreId, "{referenceStoreId}", false);
427
+ b.bp("/referencestore/{referenceStoreId}/reference/{id}");
428
+ b.p("id", () => input.id, "{id}", false);
429
+ b.p("referenceStoreId", () => input.referenceStoreId, "{referenceStoreId}", false);
543
430
  let body;
544
431
  let { hostname: resolvedHostname } = await context.endpoint();
545
432
  if (context.disableHostPrefix !== true) {
@@ -548,21 +435,15 @@ export const se_DeleteReferenceCommand = async (input, context) => {
548
435
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
549
436
  }
550
437
  }
551
- return new __HttpRequest({
552
- protocol,
553
- hostname: resolvedHostname,
554
- port,
555
- method: "DELETE",
556
- headers,
557
- path: resolvedPath,
558
- body,
559
- });
438
+ b.hn(resolvedHostname);
439
+ b.m("DELETE").h(headers).b(body);
440
+ return b.build();
560
441
  };
561
442
  export const se_DeleteReferenceStoreCommand = async (input, context) => {
562
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
443
+ const b = rb(input, context);
563
444
  const headers = {};
564
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/referencestore/{id}";
565
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
445
+ b.bp("/referencestore/{id}");
446
+ b.p("id", () => input.id, "{id}", false);
566
447
  let body;
567
448
  let { hostname: resolvedHostname } = await context.endpoint();
568
449
  if (context.disableHostPrefix !== true) {
@@ -571,21 +452,15 @@ export const se_DeleteReferenceStoreCommand = async (input, context) => {
571
452
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
572
453
  }
573
454
  }
574
- return new __HttpRequest({
575
- protocol,
576
- hostname: resolvedHostname,
577
- port,
578
- method: "DELETE",
579
- headers,
580
- path: resolvedPath,
581
- body,
582
- });
455
+ b.hn(resolvedHostname);
456
+ b.m("DELETE").h(headers).b(body);
457
+ return b.build();
583
458
  };
584
459
  export const se_DeleteRunCommand = async (input, context) => {
585
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
460
+ const b = rb(input, context);
586
461
  const headers = {};
587
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/run/{id}";
588
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
462
+ b.bp("/run/{id}");
463
+ b.p("id", () => input.id, "{id}", false);
589
464
  let body;
590
465
  let { hostname: resolvedHostname } = await context.endpoint();
591
466
  if (context.disableHostPrefix !== true) {
@@ -594,21 +469,15 @@ export const se_DeleteRunCommand = async (input, context) => {
594
469
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
595
470
  }
596
471
  }
597
- return new __HttpRequest({
598
- protocol,
599
- hostname: resolvedHostname,
600
- port,
601
- method: "DELETE",
602
- headers,
603
- path: resolvedPath,
604
- body,
605
- });
472
+ b.hn(resolvedHostname);
473
+ b.m("DELETE").h(headers).b(body);
474
+ return b.build();
606
475
  };
607
476
  export const se_DeleteRunGroupCommand = async (input, context) => {
608
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
477
+ const b = rb(input, context);
609
478
  const headers = {};
610
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/runGroup/{id}";
611
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
479
+ b.bp("/runGroup/{id}");
480
+ b.p("id", () => input.id, "{id}", false);
612
481
  let body;
613
482
  let { hostname: resolvedHostname } = await context.endpoint();
614
483
  if (context.disableHostPrefix !== true) {
@@ -617,21 +486,15 @@ export const se_DeleteRunGroupCommand = async (input, context) => {
617
486
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
618
487
  }
619
488
  }
620
- return new __HttpRequest({
621
- protocol,
622
- hostname: resolvedHostname,
623
- port,
624
- method: "DELETE",
625
- headers,
626
- path: resolvedPath,
627
- body,
628
- });
489
+ b.hn(resolvedHostname);
490
+ b.m("DELETE").h(headers).b(body);
491
+ return b.build();
629
492
  };
630
493
  export const se_DeleteSequenceStoreCommand = async (input, context) => {
631
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
494
+ const b = rb(input, context);
632
495
  const headers = {};
633
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sequencestore/{id}";
634
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
496
+ b.bp("/sequencestore/{id}");
497
+ b.p("id", () => input.id, "{id}", false);
635
498
  let body;
636
499
  let { hostname: resolvedHostname } = await context.endpoint();
637
500
  if (context.disableHostPrefix !== true) {
@@ -640,21 +503,15 @@ export const se_DeleteSequenceStoreCommand = async (input, context) => {
640
503
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
641
504
  }
642
505
  }
643
- return new __HttpRequest({
644
- protocol,
645
- hostname: resolvedHostname,
646
- port,
647
- method: "DELETE",
648
- headers,
649
- path: resolvedPath,
650
- body,
651
- });
506
+ b.hn(resolvedHostname);
507
+ b.m("DELETE").h(headers).b(body);
508
+ return b.build();
652
509
  };
653
510
  export const se_DeleteShareCommand = async (input, context) => {
654
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
511
+ const b = rb(input, context);
655
512
  const headers = {};
656
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/share/{shareId}";
657
- resolvedPath = __resolvedPath(resolvedPath, input, "shareId", () => input.shareId, "{shareId}", false);
513
+ b.bp("/share/{shareId}");
514
+ b.p("shareId", () => input.shareId, "{shareId}", false);
658
515
  let body;
659
516
  let { hostname: resolvedHostname } = await context.endpoint();
660
517
  if (context.disableHostPrefix !== true) {
@@ -663,23 +520,17 @@ export const se_DeleteShareCommand = async (input, context) => {
663
520
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
664
521
  }
665
522
  }
666
- return new __HttpRequest({
667
- protocol,
668
- hostname: resolvedHostname,
669
- port,
670
- method: "DELETE",
671
- headers,
672
- path: resolvedPath,
673
- body,
674
- });
523
+ b.hn(resolvedHostname);
524
+ b.m("DELETE").h(headers).b(body);
525
+ return b.build();
675
526
  };
676
527
  export const se_DeleteVariantStoreCommand = async (input, context) => {
677
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
528
+ const b = rb(input, context);
678
529
  const headers = {};
679
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/variantStore/{name}";
680
- resolvedPath = __resolvedPath(resolvedPath, input, "name", () => input.name, "{name}", false);
530
+ b.bp("/variantStore/{name}");
531
+ b.p("name", () => input.name, "{name}", false);
681
532
  const query = map({
682
- force: [() => input.force !== void 0, () => input.force.toString()],
533
+ [_f]: [() => input.force !== void 0, () => input[_f].toString()],
683
534
  });
684
535
  let body;
685
536
  let { hostname: resolvedHostname } = await context.endpoint();
@@ -689,22 +540,15 @@ export const se_DeleteVariantStoreCommand = async (input, context) => {
689
540
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
690
541
  }
691
542
  }
692
- return new __HttpRequest({
693
- protocol,
694
- hostname: resolvedHostname,
695
- port,
696
- method: "DELETE",
697
- headers,
698
- path: resolvedPath,
699
- query,
700
- body,
701
- });
543
+ b.hn(resolvedHostname);
544
+ b.m("DELETE").h(headers).q(query).b(body);
545
+ return b.build();
702
546
  };
703
547
  export const se_DeleteWorkflowCommand = async (input, context) => {
704
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
548
+ const b = rb(input, context);
705
549
  const headers = {};
706
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/workflow/{id}";
707
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
550
+ b.bp("/workflow/{id}");
551
+ b.p("id", () => input.id, "{id}", false);
708
552
  let body;
709
553
  let { hostname: resolvedHostname } = await context.endpoint();
710
554
  if (context.disableHostPrefix !== true) {
@@ -713,21 +557,15 @@ export const se_DeleteWorkflowCommand = async (input, context) => {
713
557
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
714
558
  }
715
559
  }
716
- return new __HttpRequest({
717
- protocol,
718
- hostname: resolvedHostname,
719
- port,
720
- method: "DELETE",
721
- headers,
722
- path: resolvedPath,
723
- body,
724
- });
560
+ b.hn(resolvedHostname);
561
+ b.m("DELETE").h(headers).b(body);
562
+ return b.build();
725
563
  };
726
564
  export const se_GetAnnotationImportJobCommand = async (input, context) => {
727
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
565
+ const b = rb(input, context);
728
566
  const headers = {};
729
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/import/annotation/{jobId}";
730
- resolvedPath = __resolvedPath(resolvedPath, input, "jobId", () => input.jobId, "{jobId}", false);
567
+ b.bp("/import/annotation/{jobId}");
568
+ b.p("jobId", () => input.jobId, "{jobId}", false);
731
569
  let body;
732
570
  let { hostname: resolvedHostname } = await context.endpoint();
733
571
  if (context.disableHostPrefix !== true) {
@@ -736,21 +574,15 @@ export const se_GetAnnotationImportJobCommand = async (input, context) => {
736
574
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
737
575
  }
738
576
  }
739
- return new __HttpRequest({
740
- protocol,
741
- hostname: resolvedHostname,
742
- port,
743
- method: "GET",
744
- headers,
745
- path: resolvedPath,
746
- body,
747
- });
577
+ b.hn(resolvedHostname);
578
+ b.m("GET").h(headers).b(body);
579
+ return b.build();
748
580
  };
749
581
  export const se_GetAnnotationStoreCommand = async (input, context) => {
750
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
582
+ const b = rb(input, context);
751
583
  const headers = {};
752
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/annotationStore/{name}";
753
- resolvedPath = __resolvedPath(resolvedPath, input, "name", () => input.name, "{name}", false);
584
+ b.bp("/annotationStore/{name}");
585
+ b.p("name", () => input.name, "{name}", false);
754
586
  let body;
755
587
  let { hostname: resolvedHostname } = await context.endpoint();
756
588
  if (context.disableHostPrefix !== true) {
@@ -759,23 +591,16 @@ export const se_GetAnnotationStoreCommand = async (input, context) => {
759
591
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
760
592
  }
761
593
  }
762
- return new __HttpRequest({
763
- protocol,
764
- hostname: resolvedHostname,
765
- port,
766
- method: "GET",
767
- headers,
768
- path: resolvedPath,
769
- body,
770
- });
594
+ b.hn(resolvedHostname);
595
+ b.m("GET").h(headers).b(body);
596
+ return b.build();
771
597
  };
772
598
  export const se_GetAnnotationStoreVersionCommand = async (input, context) => {
773
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
599
+ const b = rb(input, context);
774
600
  const headers = {};
775
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
776
- "/annotationStore/{name}/version/{versionName}";
777
- resolvedPath = __resolvedPath(resolvedPath, input, "name", () => input.name, "{name}", false);
778
- resolvedPath = __resolvedPath(resolvedPath, input, "versionName", () => input.versionName, "{versionName}", false);
601
+ b.bp("/annotationStore/{name}/version/{versionName}");
602
+ b.p("name", () => input.name, "{name}", false);
603
+ b.p("versionName", () => input.versionName, "{versionName}", false);
779
604
  let body;
780
605
  let { hostname: resolvedHostname } = await context.endpoint();
781
606
  if (context.disableHostPrefix !== true) {
@@ -784,26 +609,19 @@ export const se_GetAnnotationStoreVersionCommand = async (input, context) => {
784
609
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
785
610
  }
786
611
  }
787
- return new __HttpRequest({
788
- protocol,
789
- hostname: resolvedHostname,
790
- port,
791
- method: "GET",
792
- headers,
793
- path: resolvedPath,
794
- body,
795
- });
612
+ b.hn(resolvedHostname);
613
+ b.m("GET").h(headers).b(body);
614
+ return b.build();
796
615
  };
797
616
  export const se_GetReadSetCommand = async (input, context) => {
798
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
617
+ const b = rb(input, context);
799
618
  const headers = {};
800
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
801
- "/sequencestore/{sequenceStoreId}/readset/{id}";
802
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
803
- resolvedPath = __resolvedPath(resolvedPath, input, "sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
619
+ b.bp("/sequencestore/{sequenceStoreId}/readset/{id}");
620
+ b.p("id", () => input.id, "{id}", false);
621
+ b.p("sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
804
622
  const query = map({
805
- file: [, input.file],
806
- partNumber: [__expectNonNull(input.partNumber, `partNumber`) != null, () => input.partNumber.toString()],
623
+ [_fi]: [, input[_fi]],
624
+ [_pN]: [__expectNonNull(input.partNumber, `partNumber`) != null, () => input[_pN].toString()],
807
625
  });
808
626
  let body;
809
627
  let { hostname: resolvedHostname } = await context.endpoint();
@@ -813,24 +631,16 @@ export const se_GetReadSetCommand = async (input, context) => {
813
631
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
814
632
  }
815
633
  }
816
- return new __HttpRequest({
817
- protocol,
818
- hostname: resolvedHostname,
819
- port,
820
- method: "GET",
821
- headers,
822
- path: resolvedPath,
823
- query,
824
- body,
825
- });
634
+ b.hn(resolvedHostname);
635
+ b.m("GET").h(headers).q(query).b(body);
636
+ return b.build();
826
637
  };
827
638
  export const se_GetReadSetActivationJobCommand = async (input, context) => {
828
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
639
+ const b = rb(input, context);
829
640
  const headers = {};
830
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
831
- "/sequencestore/{sequenceStoreId}/activationjob/{id}";
832
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
833
- resolvedPath = __resolvedPath(resolvedPath, input, "sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
641
+ b.bp("/sequencestore/{sequenceStoreId}/activationjob/{id}");
642
+ b.p("id", () => input.id, "{id}", false);
643
+ b.p("sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
834
644
  let body;
835
645
  let { hostname: resolvedHostname } = await context.endpoint();
836
646
  if (context.disableHostPrefix !== true) {
@@ -839,23 +649,16 @@ export const se_GetReadSetActivationJobCommand = async (input, context) => {
839
649
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
840
650
  }
841
651
  }
842
- return new __HttpRequest({
843
- protocol,
844
- hostname: resolvedHostname,
845
- port,
846
- method: "GET",
847
- headers,
848
- path: resolvedPath,
849
- body,
850
- });
652
+ b.hn(resolvedHostname);
653
+ b.m("GET").h(headers).b(body);
654
+ return b.build();
851
655
  };
852
656
  export const se_GetReadSetExportJobCommand = async (input, context) => {
853
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
657
+ const b = rb(input, context);
854
658
  const headers = {};
855
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
856
- "/sequencestore/{sequenceStoreId}/exportjob/{id}";
857
- resolvedPath = __resolvedPath(resolvedPath, input, "sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
858
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
659
+ b.bp("/sequencestore/{sequenceStoreId}/exportjob/{id}");
660
+ b.p("sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
661
+ b.p("id", () => input.id, "{id}", false);
859
662
  let body;
860
663
  let { hostname: resolvedHostname } = await context.endpoint();
861
664
  if (context.disableHostPrefix !== true) {
@@ -864,23 +667,16 @@ export const se_GetReadSetExportJobCommand = async (input, context) => {
864
667
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
865
668
  }
866
669
  }
867
- return new __HttpRequest({
868
- protocol,
869
- hostname: resolvedHostname,
870
- port,
871
- method: "GET",
872
- headers,
873
- path: resolvedPath,
874
- body,
875
- });
670
+ b.hn(resolvedHostname);
671
+ b.m("GET").h(headers).b(body);
672
+ return b.build();
876
673
  };
877
674
  export const se_GetReadSetImportJobCommand = async (input, context) => {
878
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
675
+ const b = rb(input, context);
879
676
  const headers = {};
880
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
881
- "/sequencestore/{sequenceStoreId}/importjob/{id}";
882
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
883
- resolvedPath = __resolvedPath(resolvedPath, input, "sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
677
+ b.bp("/sequencestore/{sequenceStoreId}/importjob/{id}");
678
+ b.p("id", () => input.id, "{id}", false);
679
+ b.p("sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
884
680
  let body;
885
681
  let { hostname: resolvedHostname } = await context.endpoint();
886
682
  if (context.disableHostPrefix !== true) {
@@ -889,23 +685,16 @@ export const se_GetReadSetImportJobCommand = async (input, context) => {
889
685
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
890
686
  }
891
687
  }
892
- return new __HttpRequest({
893
- protocol,
894
- hostname: resolvedHostname,
895
- port,
896
- method: "GET",
897
- headers,
898
- path: resolvedPath,
899
- body,
900
- });
688
+ b.hn(resolvedHostname);
689
+ b.m("GET").h(headers).b(body);
690
+ return b.build();
901
691
  };
902
692
  export const se_GetReadSetMetadataCommand = async (input, context) => {
903
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
693
+ const b = rb(input, context);
904
694
  const headers = {};
905
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
906
- "/sequencestore/{sequenceStoreId}/readset/{id}/metadata";
907
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
908
- resolvedPath = __resolvedPath(resolvedPath, input, "sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
695
+ b.bp("/sequencestore/{sequenceStoreId}/readset/{id}/metadata");
696
+ b.p("id", () => input.id, "{id}", false);
697
+ b.p("sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
909
698
  let body;
910
699
  let { hostname: resolvedHostname } = await context.endpoint();
911
700
  if (context.disableHostPrefix !== true) {
@@ -914,28 +703,21 @@ export const se_GetReadSetMetadataCommand = async (input, context) => {
914
703
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
915
704
  }
916
705
  }
917
- return new __HttpRequest({
918
- protocol,
919
- hostname: resolvedHostname,
920
- port,
921
- method: "GET",
922
- headers,
923
- path: resolvedPath,
924
- body,
925
- });
706
+ b.hn(resolvedHostname);
707
+ b.m("GET").h(headers).b(body);
708
+ return b.build();
926
709
  };
927
710
  export const se_GetReferenceCommand = async (input, context) => {
928
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
711
+ const b = rb(input, context);
929
712
  const headers = map({}, isSerializableHeaderValue, {
930
- range: input.range,
713
+ [_r]: input[_r],
931
714
  });
932
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
933
- "/referencestore/{referenceStoreId}/reference/{id}";
934
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
935
- resolvedPath = __resolvedPath(resolvedPath, input, "referenceStoreId", () => input.referenceStoreId, "{referenceStoreId}", false);
715
+ b.bp("/referencestore/{referenceStoreId}/reference/{id}");
716
+ b.p("id", () => input.id, "{id}", false);
717
+ b.p("referenceStoreId", () => input.referenceStoreId, "{referenceStoreId}", false);
936
718
  const query = map({
937
- partNumber: [__expectNonNull(input.partNumber, `partNumber`) != null, () => input.partNumber.toString()],
938
- file: [, input.file],
719
+ [_pN]: [__expectNonNull(input.partNumber, `partNumber`) != null, () => input[_pN].toString()],
720
+ [_fi]: [, input[_fi]],
939
721
  });
940
722
  let body;
941
723
  let { hostname: resolvedHostname } = await context.endpoint();
@@ -945,24 +727,16 @@ export const se_GetReferenceCommand = async (input, context) => {
945
727
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
946
728
  }
947
729
  }
948
- return new __HttpRequest({
949
- protocol,
950
- hostname: resolvedHostname,
951
- port,
952
- method: "GET",
953
- headers,
954
- path: resolvedPath,
955
- query,
956
- body,
957
- });
730
+ b.hn(resolvedHostname);
731
+ b.m("GET").h(headers).q(query).b(body);
732
+ return b.build();
958
733
  };
959
734
  export const se_GetReferenceImportJobCommand = async (input, context) => {
960
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
735
+ const b = rb(input, context);
961
736
  const headers = {};
962
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
963
- "/referencestore/{referenceStoreId}/importjob/{id}";
964
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
965
- resolvedPath = __resolvedPath(resolvedPath, input, "referenceStoreId", () => input.referenceStoreId, "{referenceStoreId}", false);
737
+ b.bp("/referencestore/{referenceStoreId}/importjob/{id}");
738
+ b.p("id", () => input.id, "{id}", false);
739
+ b.p("referenceStoreId", () => input.referenceStoreId, "{referenceStoreId}", false);
966
740
  let body;
967
741
  let { hostname: resolvedHostname } = await context.endpoint();
968
742
  if (context.disableHostPrefix !== true) {
@@ -971,23 +745,16 @@ export const se_GetReferenceImportJobCommand = async (input, context) => {
971
745
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
972
746
  }
973
747
  }
974
- return new __HttpRequest({
975
- protocol,
976
- hostname: resolvedHostname,
977
- port,
978
- method: "GET",
979
- headers,
980
- path: resolvedPath,
981
- body,
982
- });
748
+ b.hn(resolvedHostname);
749
+ b.m("GET").h(headers).b(body);
750
+ return b.build();
983
751
  };
984
752
  export const se_GetReferenceMetadataCommand = async (input, context) => {
985
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
753
+ const b = rb(input, context);
986
754
  const headers = {};
987
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
988
- "/referencestore/{referenceStoreId}/reference/{id}/metadata";
989
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
990
- resolvedPath = __resolvedPath(resolvedPath, input, "referenceStoreId", () => input.referenceStoreId, "{referenceStoreId}", false);
755
+ b.bp("/referencestore/{referenceStoreId}/reference/{id}/metadata");
756
+ b.p("id", () => input.id, "{id}", false);
757
+ b.p("referenceStoreId", () => input.referenceStoreId, "{referenceStoreId}", false);
991
758
  let body;
992
759
  let { hostname: resolvedHostname } = await context.endpoint();
993
760
  if (context.disableHostPrefix !== true) {
@@ -996,21 +763,15 @@ export const se_GetReferenceMetadataCommand = async (input, context) => {
996
763
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
997
764
  }
998
765
  }
999
- return new __HttpRequest({
1000
- protocol,
1001
- hostname: resolvedHostname,
1002
- port,
1003
- method: "GET",
1004
- headers,
1005
- path: resolvedPath,
1006
- body,
1007
- });
766
+ b.hn(resolvedHostname);
767
+ b.m("GET").h(headers).b(body);
768
+ return b.build();
1008
769
  };
1009
770
  export const se_GetReferenceStoreCommand = async (input, context) => {
1010
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
771
+ const b = rb(input, context);
1011
772
  const headers = {};
1012
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/referencestore/{id}";
1013
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
773
+ b.bp("/referencestore/{id}");
774
+ b.p("id", () => input.id, "{id}", false);
1014
775
  let body;
1015
776
  let { hostname: resolvedHostname } = await context.endpoint();
1016
777
  if (context.disableHostPrefix !== true) {
@@ -1019,23 +780,17 @@ export const se_GetReferenceStoreCommand = async (input, context) => {
1019
780
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1020
781
  }
1021
782
  }
1022
- return new __HttpRequest({
1023
- protocol,
1024
- hostname: resolvedHostname,
1025
- port,
1026
- method: "GET",
1027
- headers,
1028
- path: resolvedPath,
1029
- body,
1030
- });
783
+ b.hn(resolvedHostname);
784
+ b.m("GET").h(headers).b(body);
785
+ return b.build();
1031
786
  };
1032
787
  export const se_GetRunCommand = async (input, context) => {
1033
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
788
+ const b = rb(input, context);
1034
789
  const headers = {};
1035
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/run/{id}";
1036
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
790
+ b.bp("/run/{id}");
791
+ b.p("id", () => input.id, "{id}", false);
1037
792
  const query = map({
1038
- export: [() => input.export !== void 0, () => (input.export || []).map((_entry) => _entry)],
793
+ [_e]: [() => input.export !== void 0, () => (input[_e] || []).map((_entry) => _entry)],
1039
794
  });
1040
795
  let body;
1041
796
  let { hostname: resolvedHostname } = await context.endpoint();
@@ -1045,22 +800,15 @@ export const se_GetRunCommand = async (input, context) => {
1045
800
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1046
801
  }
1047
802
  }
1048
- return new __HttpRequest({
1049
- protocol,
1050
- hostname: resolvedHostname,
1051
- port,
1052
- method: "GET",
1053
- headers,
1054
- path: resolvedPath,
1055
- query,
1056
- body,
1057
- });
803
+ b.hn(resolvedHostname);
804
+ b.m("GET").h(headers).q(query).b(body);
805
+ return b.build();
1058
806
  };
1059
807
  export const se_GetRunGroupCommand = async (input, context) => {
1060
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
808
+ const b = rb(input, context);
1061
809
  const headers = {};
1062
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/runGroup/{id}";
1063
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
810
+ b.bp("/runGroup/{id}");
811
+ b.p("id", () => input.id, "{id}", false);
1064
812
  let body;
1065
813
  let { hostname: resolvedHostname } = await context.endpoint();
1066
814
  if (context.disableHostPrefix !== true) {
@@ -1069,22 +817,16 @@ export const se_GetRunGroupCommand = async (input, context) => {
1069
817
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1070
818
  }
1071
819
  }
1072
- return new __HttpRequest({
1073
- protocol,
1074
- hostname: resolvedHostname,
1075
- port,
1076
- method: "GET",
1077
- headers,
1078
- path: resolvedPath,
1079
- body,
1080
- });
820
+ b.hn(resolvedHostname);
821
+ b.m("GET").h(headers).b(body);
822
+ return b.build();
1081
823
  };
1082
824
  export const se_GetRunTaskCommand = async (input, context) => {
1083
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
825
+ const b = rb(input, context);
1084
826
  const headers = {};
1085
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/run/{id}/task/{taskId}";
1086
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
1087
- resolvedPath = __resolvedPath(resolvedPath, input, "taskId", () => input.taskId, "{taskId}", false);
827
+ b.bp("/run/{id}/task/{taskId}");
828
+ b.p("id", () => input.id, "{id}", false);
829
+ b.p("taskId", () => input.taskId, "{taskId}", false);
1088
830
  let body;
1089
831
  let { hostname: resolvedHostname } = await context.endpoint();
1090
832
  if (context.disableHostPrefix !== true) {
@@ -1093,21 +835,15 @@ export const se_GetRunTaskCommand = async (input, context) => {
1093
835
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1094
836
  }
1095
837
  }
1096
- return new __HttpRequest({
1097
- protocol,
1098
- hostname: resolvedHostname,
1099
- port,
1100
- method: "GET",
1101
- headers,
1102
- path: resolvedPath,
1103
- body,
1104
- });
838
+ b.hn(resolvedHostname);
839
+ b.m("GET").h(headers).b(body);
840
+ return b.build();
1105
841
  };
1106
842
  export const se_GetSequenceStoreCommand = async (input, context) => {
1107
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
843
+ const b = rb(input, context);
1108
844
  const headers = {};
1109
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sequencestore/{id}";
1110
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
845
+ b.bp("/sequencestore/{id}");
846
+ b.p("id", () => input.id, "{id}", false);
1111
847
  let body;
1112
848
  let { hostname: resolvedHostname } = await context.endpoint();
1113
849
  if (context.disableHostPrefix !== true) {
@@ -1116,21 +852,15 @@ export const se_GetSequenceStoreCommand = async (input, context) => {
1116
852
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1117
853
  }
1118
854
  }
1119
- return new __HttpRequest({
1120
- protocol,
1121
- hostname: resolvedHostname,
1122
- port,
1123
- method: "GET",
1124
- headers,
1125
- path: resolvedPath,
1126
- body,
1127
- });
855
+ b.hn(resolvedHostname);
856
+ b.m("GET").h(headers).b(body);
857
+ return b.build();
1128
858
  };
1129
859
  export const se_GetShareCommand = async (input, context) => {
1130
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
860
+ const b = rb(input, context);
1131
861
  const headers = {};
1132
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/share/{shareId}";
1133
- resolvedPath = __resolvedPath(resolvedPath, input, "shareId", () => input.shareId, "{shareId}", false);
862
+ b.bp("/share/{shareId}");
863
+ b.p("shareId", () => input.shareId, "{shareId}", false);
1134
864
  let body;
1135
865
  let { hostname: resolvedHostname } = await context.endpoint();
1136
866
  if (context.disableHostPrefix !== true) {
@@ -1139,21 +869,15 @@ export const se_GetShareCommand = async (input, context) => {
1139
869
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1140
870
  }
1141
871
  }
1142
- return new __HttpRequest({
1143
- protocol,
1144
- hostname: resolvedHostname,
1145
- port,
1146
- method: "GET",
1147
- headers,
1148
- path: resolvedPath,
1149
- body,
1150
- });
872
+ b.hn(resolvedHostname);
873
+ b.m("GET").h(headers).b(body);
874
+ return b.build();
1151
875
  };
1152
876
  export const se_GetVariantImportJobCommand = async (input, context) => {
1153
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
877
+ const b = rb(input, context);
1154
878
  const headers = {};
1155
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/import/variant/{jobId}";
1156
- resolvedPath = __resolvedPath(resolvedPath, input, "jobId", () => input.jobId, "{jobId}", false);
879
+ b.bp("/import/variant/{jobId}");
880
+ b.p("jobId", () => input.jobId, "{jobId}", false);
1157
881
  let body;
1158
882
  let { hostname: resolvedHostname } = await context.endpoint();
1159
883
  if (context.disableHostPrefix !== true) {
@@ -1162,21 +886,15 @@ export const se_GetVariantImportJobCommand = async (input, context) => {
1162
886
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1163
887
  }
1164
888
  }
1165
- return new __HttpRequest({
1166
- protocol,
1167
- hostname: resolvedHostname,
1168
- port,
1169
- method: "GET",
1170
- headers,
1171
- path: resolvedPath,
1172
- body,
1173
- });
889
+ b.hn(resolvedHostname);
890
+ b.m("GET").h(headers).b(body);
891
+ return b.build();
1174
892
  };
1175
893
  export const se_GetVariantStoreCommand = async (input, context) => {
1176
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
894
+ const b = rb(input, context);
1177
895
  const headers = {};
1178
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/variantStore/{name}";
1179
- resolvedPath = __resolvedPath(resolvedPath, input, "name", () => input.name, "{name}", false);
896
+ b.bp("/variantStore/{name}");
897
+ b.p("name", () => input.name, "{name}", false);
1180
898
  let body;
1181
899
  let { hostname: resolvedHostname } = await context.endpoint();
1182
900
  if (context.disableHostPrefix !== true) {
@@ -1185,24 +903,18 @@ export const se_GetVariantStoreCommand = async (input, context) => {
1185
903
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1186
904
  }
1187
905
  }
1188
- return new __HttpRequest({
1189
- protocol,
1190
- hostname: resolvedHostname,
1191
- port,
1192
- method: "GET",
1193
- headers,
1194
- path: resolvedPath,
1195
- body,
1196
- });
906
+ b.hn(resolvedHostname);
907
+ b.m("GET").h(headers).b(body);
908
+ return b.build();
1197
909
  };
1198
910
  export const se_GetWorkflowCommand = async (input, context) => {
1199
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
911
+ const b = rb(input, context);
1200
912
  const headers = {};
1201
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/workflow/{id}";
1202
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
913
+ b.bp("/workflow/{id}");
914
+ b.p("id", () => input.id, "{id}", false);
1203
915
  const query = map({
1204
- type: [, input.type],
1205
- export: [() => input.export !== void 0, () => (input.export || []).map((_entry) => _entry)],
916
+ [_t]: [, input[_t]],
917
+ [_e]: [() => input.export !== void 0, () => (input[_e] || []).map((_entry) => _entry)],
1206
918
  });
1207
919
  let body;
1208
920
  let { hostname: resolvedHostname } = await context.endpoint();
@@ -1212,26 +924,19 @@ export const se_GetWorkflowCommand = async (input, context) => {
1212
924
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1213
925
  }
1214
926
  }
1215
- return new __HttpRequest({
1216
- protocol,
1217
- hostname: resolvedHostname,
1218
- port,
1219
- method: "GET",
1220
- headers,
1221
- path: resolvedPath,
1222
- query,
1223
- body,
1224
- });
927
+ b.hn(resolvedHostname);
928
+ b.m("GET").h(headers).q(query).b(body);
929
+ return b.build();
1225
930
  };
1226
931
  export const se_ListAnnotationImportJobsCommand = async (input, context) => {
1227
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
932
+ const b = rb(input, context);
1228
933
  const headers = {
1229
934
  "content-type": "application/json",
1230
935
  };
1231
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/import/annotations";
936
+ b.bp("/import/annotations");
1232
937
  const query = map({
1233
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1234
- nextToken: [, input.nextToken],
938
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
939
+ [_nT]: [, input[_nT]],
1235
940
  });
1236
941
  let body;
1237
942
  body = JSON.stringify(take(input, {
@@ -1245,26 +950,19 @@ export const se_ListAnnotationImportJobsCommand = async (input, context) => {
1245
950
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1246
951
  }
1247
952
  }
1248
- return new __HttpRequest({
1249
- protocol,
1250
- hostname: resolvedHostname,
1251
- port,
1252
- method: "POST",
1253
- headers,
1254
- path: resolvedPath,
1255
- query,
1256
- body,
1257
- });
953
+ b.hn(resolvedHostname);
954
+ b.m("POST").h(headers).q(query).b(body);
955
+ return b.build();
1258
956
  };
1259
957
  export const se_ListAnnotationStoresCommand = async (input, context) => {
1260
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
958
+ const b = rb(input, context);
1261
959
  const headers = {
1262
960
  "content-type": "application/json",
1263
961
  };
1264
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/annotationStores";
962
+ b.bp("/annotationStores");
1265
963
  const query = map({
1266
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1267
- nextToken: [, input.nextToken],
964
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
965
+ [_nT]: [, input[_nT]],
1268
966
  });
1269
967
  let body;
1270
968
  body = JSON.stringify(take(input, {
@@ -1278,27 +976,20 @@ export const se_ListAnnotationStoresCommand = async (input, context) => {
1278
976
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1279
977
  }
1280
978
  }
1281
- return new __HttpRequest({
1282
- protocol,
1283
- hostname: resolvedHostname,
1284
- port,
1285
- method: "POST",
1286
- headers,
1287
- path: resolvedPath,
1288
- query,
1289
- body,
1290
- });
979
+ b.hn(resolvedHostname);
980
+ b.m("POST").h(headers).q(query).b(body);
981
+ return b.build();
1291
982
  };
1292
983
  export const se_ListAnnotationStoreVersionsCommand = async (input, context) => {
1293
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
984
+ const b = rb(input, context);
1294
985
  const headers = {
1295
986
  "content-type": "application/json",
1296
987
  };
1297
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/annotationStore/{name}/versions";
1298
- resolvedPath = __resolvedPath(resolvedPath, input, "name", () => input.name, "{name}", false);
988
+ b.bp("/annotationStore/{name}/versions");
989
+ b.p("name", () => input.name, "{name}", false);
1299
990
  const query = map({
1300
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1301
- nextToken: [, input.nextToken],
991
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
992
+ [_nT]: [, input[_nT]],
1302
993
  });
1303
994
  let body;
1304
995
  body = JSON.stringify(take(input, {
@@ -1311,25 +1002,18 @@ export const se_ListAnnotationStoreVersionsCommand = async (input, context) => {
1311
1002
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1312
1003
  }
1313
1004
  }
1314
- return new __HttpRequest({
1315
- protocol,
1316
- hostname: resolvedHostname,
1317
- port,
1318
- method: "POST",
1319
- headers,
1320
- path: resolvedPath,
1321
- query,
1322
- body,
1323
- });
1005
+ b.hn(resolvedHostname);
1006
+ b.m("POST").h(headers).q(query).b(body);
1007
+ return b.build();
1324
1008
  };
1325
1009
  export const se_ListMultipartReadSetUploadsCommand = async (input, context) => {
1326
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1010
+ const b = rb(input, context);
1327
1011
  const headers = {};
1328
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sequencestore/{sequenceStoreId}/uploads";
1329
- resolvedPath = __resolvedPath(resolvedPath, input, "sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
1012
+ b.bp("/sequencestore/{sequenceStoreId}/uploads");
1013
+ b.p("sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
1330
1014
  const query = map({
1331
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1332
- nextToken: [, input.nextToken],
1015
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
1016
+ [_nT]: [, input[_nT]],
1333
1017
  });
1334
1018
  let body;
1335
1019
  let { hostname: resolvedHostname } = await context.endpoint();
@@ -1339,28 +1023,20 @@ export const se_ListMultipartReadSetUploadsCommand = async (input, context) => {
1339
1023
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1340
1024
  }
1341
1025
  }
1342
- return new __HttpRequest({
1343
- protocol,
1344
- hostname: resolvedHostname,
1345
- port,
1346
- method: "POST",
1347
- headers,
1348
- path: resolvedPath,
1349
- query,
1350
- body,
1351
- });
1026
+ b.hn(resolvedHostname);
1027
+ b.m("POST").h(headers).q(query).b(body);
1028
+ return b.build();
1352
1029
  };
1353
1030
  export const se_ListReadSetActivationJobsCommand = async (input, context) => {
1354
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1031
+ const b = rb(input, context);
1355
1032
  const headers = {
1356
1033
  "content-type": "application/json",
1357
1034
  };
1358
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1359
- "/sequencestore/{sequenceStoreId}/activationjobs";
1360
- resolvedPath = __resolvedPath(resolvedPath, input, "sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
1035
+ b.bp("/sequencestore/{sequenceStoreId}/activationjobs");
1036
+ b.p("sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
1361
1037
  const query = map({
1362
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1363
- nextToken: [, input.nextToken],
1038
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
1039
+ [_nT]: [, input[_nT]],
1364
1040
  });
1365
1041
  let body;
1366
1042
  body = JSON.stringify(take(input, {
@@ -1373,28 +1049,20 @@ export const se_ListReadSetActivationJobsCommand = async (input, context) => {
1373
1049
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1374
1050
  }
1375
1051
  }
1376
- return new __HttpRequest({
1377
- protocol,
1378
- hostname: resolvedHostname,
1379
- port,
1380
- method: "POST",
1381
- headers,
1382
- path: resolvedPath,
1383
- query,
1384
- body,
1385
- });
1052
+ b.hn(resolvedHostname);
1053
+ b.m("POST").h(headers).q(query).b(body);
1054
+ return b.build();
1386
1055
  };
1387
1056
  export const se_ListReadSetExportJobsCommand = async (input, context) => {
1388
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1057
+ const b = rb(input, context);
1389
1058
  const headers = {
1390
1059
  "content-type": "application/json",
1391
1060
  };
1392
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1393
- "/sequencestore/{sequenceStoreId}/exportjobs";
1394
- resolvedPath = __resolvedPath(resolvedPath, input, "sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
1061
+ b.bp("/sequencestore/{sequenceStoreId}/exportjobs");
1062
+ b.p("sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
1395
1063
  const query = map({
1396
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1397
- nextToken: [, input.nextToken],
1064
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
1065
+ [_nT]: [, input[_nT]],
1398
1066
  });
1399
1067
  let body;
1400
1068
  body = JSON.stringify(take(input, {
@@ -1407,28 +1075,20 @@ export const se_ListReadSetExportJobsCommand = async (input, context) => {
1407
1075
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1408
1076
  }
1409
1077
  }
1410
- return new __HttpRequest({
1411
- protocol,
1412
- hostname: resolvedHostname,
1413
- port,
1414
- method: "POST",
1415
- headers,
1416
- path: resolvedPath,
1417
- query,
1418
- body,
1419
- });
1078
+ b.hn(resolvedHostname);
1079
+ b.m("POST").h(headers).q(query).b(body);
1080
+ return b.build();
1420
1081
  };
1421
1082
  export const se_ListReadSetImportJobsCommand = async (input, context) => {
1422
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1083
+ const b = rb(input, context);
1423
1084
  const headers = {
1424
1085
  "content-type": "application/json",
1425
1086
  };
1426
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1427
- "/sequencestore/{sequenceStoreId}/importjobs";
1428
- resolvedPath = __resolvedPath(resolvedPath, input, "sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
1087
+ b.bp("/sequencestore/{sequenceStoreId}/importjobs");
1088
+ b.p("sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
1429
1089
  const query = map({
1430
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1431
- nextToken: [, input.nextToken],
1090
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
1091
+ [_nT]: [, input[_nT]],
1432
1092
  });
1433
1093
  let body;
1434
1094
  body = JSON.stringify(take(input, {
@@ -1441,27 +1101,20 @@ export const se_ListReadSetImportJobsCommand = async (input, context) => {
1441
1101
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1442
1102
  }
1443
1103
  }
1444
- return new __HttpRequest({
1445
- protocol,
1446
- hostname: resolvedHostname,
1447
- port,
1448
- method: "POST",
1449
- headers,
1450
- path: resolvedPath,
1451
- query,
1452
- body,
1453
- });
1104
+ b.hn(resolvedHostname);
1105
+ b.m("POST").h(headers).q(query).b(body);
1106
+ return b.build();
1454
1107
  };
1455
1108
  export const se_ListReadSetsCommand = async (input, context) => {
1456
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1109
+ const b = rb(input, context);
1457
1110
  const headers = {
1458
1111
  "content-type": "application/json",
1459
1112
  };
1460
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sequencestore/{sequenceStoreId}/readsets";
1461
- resolvedPath = __resolvedPath(resolvedPath, input, "sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
1113
+ b.bp("/sequencestore/{sequenceStoreId}/readsets");
1114
+ b.p("sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
1462
1115
  const query = map({
1463
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1464
- nextToken: [, input.nextToken],
1116
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
1117
+ [_nT]: [, input[_nT]],
1465
1118
  });
1466
1119
  let body;
1467
1120
  body = JSON.stringify(take(input, {
@@ -1474,29 +1127,21 @@ export const se_ListReadSetsCommand = async (input, context) => {
1474
1127
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1475
1128
  }
1476
1129
  }
1477
- return new __HttpRequest({
1478
- protocol,
1479
- hostname: resolvedHostname,
1480
- port,
1481
- method: "POST",
1482
- headers,
1483
- path: resolvedPath,
1484
- query,
1485
- body,
1486
- });
1130
+ b.hn(resolvedHostname);
1131
+ b.m("POST").h(headers).q(query).b(body);
1132
+ return b.build();
1487
1133
  };
1488
1134
  export const se_ListReadSetUploadPartsCommand = async (input, context) => {
1489
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1135
+ const b = rb(input, context);
1490
1136
  const headers = {
1491
1137
  "content-type": "application/json",
1492
1138
  };
1493
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1494
- "/sequencestore/{sequenceStoreId}/upload/{uploadId}/parts";
1495
- resolvedPath = __resolvedPath(resolvedPath, input, "sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
1496
- resolvedPath = __resolvedPath(resolvedPath, input, "uploadId", () => input.uploadId, "{uploadId}", false);
1139
+ b.bp("/sequencestore/{sequenceStoreId}/upload/{uploadId}/parts");
1140
+ b.p("sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
1141
+ b.p("uploadId", () => input.uploadId, "{uploadId}", false);
1497
1142
  const query = map({
1498
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1499
- nextToken: [, input.nextToken],
1143
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
1144
+ [_nT]: [, input[_nT]],
1500
1145
  });
1501
1146
  let body;
1502
1147
  body = JSON.stringify(take(input, {
@@ -1510,28 +1155,20 @@ export const se_ListReadSetUploadPartsCommand = async (input, context) => {
1510
1155
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1511
1156
  }
1512
1157
  }
1513
- return new __HttpRequest({
1514
- protocol,
1515
- hostname: resolvedHostname,
1516
- port,
1517
- method: "POST",
1518
- headers,
1519
- path: resolvedPath,
1520
- query,
1521
- body,
1522
- });
1158
+ b.hn(resolvedHostname);
1159
+ b.m("POST").h(headers).q(query).b(body);
1160
+ return b.build();
1523
1161
  };
1524
1162
  export const se_ListReferenceImportJobsCommand = async (input, context) => {
1525
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1163
+ const b = rb(input, context);
1526
1164
  const headers = {
1527
1165
  "content-type": "application/json",
1528
1166
  };
1529
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1530
- "/referencestore/{referenceStoreId}/importjobs";
1531
- resolvedPath = __resolvedPath(resolvedPath, input, "referenceStoreId", () => input.referenceStoreId, "{referenceStoreId}", false);
1167
+ b.bp("/referencestore/{referenceStoreId}/importjobs");
1168
+ b.p("referenceStoreId", () => input.referenceStoreId, "{referenceStoreId}", false);
1532
1169
  const query = map({
1533
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1534
- nextToken: [, input.nextToken],
1170
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
1171
+ [_nT]: [, input[_nT]],
1535
1172
  });
1536
1173
  let body;
1537
1174
  body = JSON.stringify(take(input, {
@@ -1544,28 +1181,20 @@ export const se_ListReferenceImportJobsCommand = async (input, context) => {
1544
1181
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1545
1182
  }
1546
1183
  }
1547
- return new __HttpRequest({
1548
- protocol,
1549
- hostname: resolvedHostname,
1550
- port,
1551
- method: "POST",
1552
- headers,
1553
- path: resolvedPath,
1554
- query,
1555
- body,
1556
- });
1184
+ b.hn(resolvedHostname);
1185
+ b.m("POST").h(headers).q(query).b(body);
1186
+ return b.build();
1557
1187
  };
1558
1188
  export const se_ListReferencesCommand = async (input, context) => {
1559
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1189
+ const b = rb(input, context);
1560
1190
  const headers = {
1561
1191
  "content-type": "application/json",
1562
1192
  };
1563
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1564
- "/referencestore/{referenceStoreId}/references";
1565
- resolvedPath = __resolvedPath(resolvedPath, input, "referenceStoreId", () => input.referenceStoreId, "{referenceStoreId}", false);
1193
+ b.bp("/referencestore/{referenceStoreId}/references");
1194
+ b.p("referenceStoreId", () => input.referenceStoreId, "{referenceStoreId}", false);
1566
1195
  const query = map({
1567
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1568
- nextToken: [, input.nextToken],
1196
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
1197
+ [_nT]: [, input[_nT]],
1569
1198
  });
1570
1199
  let body;
1571
1200
  body = JSON.stringify(take(input, {
@@ -1578,26 +1207,19 @@ export const se_ListReferencesCommand = async (input, context) => {
1578
1207
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1579
1208
  }
1580
1209
  }
1581
- return new __HttpRequest({
1582
- protocol,
1583
- hostname: resolvedHostname,
1584
- port,
1585
- method: "POST",
1586
- headers,
1587
- path: resolvedPath,
1588
- query,
1589
- body,
1590
- });
1210
+ b.hn(resolvedHostname);
1211
+ b.m("POST").h(headers).q(query).b(body);
1212
+ return b.build();
1591
1213
  };
1592
1214
  export const se_ListReferenceStoresCommand = async (input, context) => {
1593
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1215
+ const b = rb(input, context);
1594
1216
  const headers = {
1595
1217
  "content-type": "application/json",
1596
1218
  };
1597
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/referencestores";
1219
+ b.bp("/referencestores");
1598
1220
  const query = map({
1599
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1600
- nextToken: [, input.nextToken],
1221
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
1222
+ [_nT]: [, input[_nT]],
1601
1223
  });
1602
1224
  let body;
1603
1225
  body = JSON.stringify(take(input, {
@@ -1610,25 +1232,18 @@ export const se_ListReferenceStoresCommand = async (input, context) => {
1610
1232
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1611
1233
  }
1612
1234
  }
1613
- return new __HttpRequest({
1614
- protocol,
1615
- hostname: resolvedHostname,
1616
- port,
1617
- method: "POST",
1618
- headers,
1619
- path: resolvedPath,
1620
- query,
1621
- body,
1622
- });
1235
+ b.hn(resolvedHostname);
1236
+ b.m("POST").h(headers).q(query).b(body);
1237
+ return b.build();
1623
1238
  };
1624
1239
  export const se_ListRunGroupsCommand = async (input, context) => {
1625
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1240
+ const b = rb(input, context);
1626
1241
  const headers = {};
1627
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/runGroup";
1242
+ b.bp("/runGroup");
1628
1243
  const query = map({
1629
- name: [, input.name],
1630
- startingToken: [, input.startingToken],
1631
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1244
+ [_n]: [, input[_n]],
1245
+ [_sT]: [, input[_sT]],
1246
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
1632
1247
  });
1633
1248
  let body;
1634
1249
  let { hostname: resolvedHostname } = await context.endpoint();
@@ -1638,27 +1253,20 @@ export const se_ListRunGroupsCommand = async (input, context) => {
1638
1253
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1639
1254
  }
1640
1255
  }
1641
- return new __HttpRequest({
1642
- protocol,
1643
- hostname: resolvedHostname,
1644
- port,
1645
- method: "GET",
1646
- headers,
1647
- path: resolvedPath,
1648
- query,
1649
- body,
1650
- });
1256
+ b.hn(resolvedHostname);
1257
+ b.m("GET").h(headers).q(query).b(body);
1258
+ return b.build();
1651
1259
  };
1652
1260
  export const se_ListRunsCommand = async (input, context) => {
1653
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1261
+ const b = rb(input, context);
1654
1262
  const headers = {};
1655
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/run";
1263
+ b.bp("/run");
1656
1264
  const query = map({
1657
- name: [, input.name],
1658
- runGroupId: [, input.runGroupId],
1659
- startingToken: [, input.startingToken],
1660
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1661
- status: [, input.status],
1265
+ [_n]: [, input[_n]],
1266
+ [_rGI]: [, input[_rGI]],
1267
+ [_sT]: [, input[_sT]],
1268
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
1269
+ [_s]: [, input[_s]],
1662
1270
  });
1663
1271
  let body;
1664
1272
  let { hostname: resolvedHostname } = await context.endpoint();
@@ -1668,26 +1276,19 @@ export const se_ListRunsCommand = async (input, context) => {
1668
1276
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1669
1277
  }
1670
1278
  }
1671
- return new __HttpRequest({
1672
- protocol,
1673
- hostname: resolvedHostname,
1674
- port,
1675
- method: "GET",
1676
- headers,
1677
- path: resolvedPath,
1678
- query,
1679
- body,
1680
- });
1279
+ b.hn(resolvedHostname);
1280
+ b.m("GET").h(headers).q(query).b(body);
1281
+ return b.build();
1681
1282
  };
1682
1283
  export const se_ListRunTasksCommand = async (input, context) => {
1683
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1284
+ const b = rb(input, context);
1684
1285
  const headers = {};
1685
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/run/{id}/task";
1686
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
1286
+ b.bp("/run/{id}/task");
1287
+ b.p("id", () => input.id, "{id}", false);
1687
1288
  const query = map({
1688
- status: [, input.status],
1689
- startingToken: [, input.startingToken],
1690
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1289
+ [_s]: [, input[_s]],
1290
+ [_sT]: [, input[_sT]],
1291
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
1691
1292
  });
1692
1293
  let body;
1693
1294
  let { hostname: resolvedHostname } = await context.endpoint();
@@ -1697,26 +1298,19 @@ export const se_ListRunTasksCommand = async (input, context) => {
1697
1298
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1698
1299
  }
1699
1300
  }
1700
- return new __HttpRequest({
1701
- protocol,
1702
- hostname: resolvedHostname,
1703
- port,
1704
- method: "GET",
1705
- headers,
1706
- path: resolvedPath,
1707
- query,
1708
- body,
1709
- });
1301
+ b.hn(resolvedHostname);
1302
+ b.m("GET").h(headers).q(query).b(body);
1303
+ return b.build();
1710
1304
  };
1711
1305
  export const se_ListSequenceStoresCommand = async (input, context) => {
1712
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1306
+ const b = rb(input, context);
1713
1307
  const headers = {
1714
1308
  "content-type": "application/json",
1715
1309
  };
1716
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sequencestores";
1310
+ b.bp("/sequencestores");
1717
1311
  const query = map({
1718
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1719
- nextToken: [, input.nextToken],
1312
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
1313
+ [_nT]: [, input[_nT]],
1720
1314
  });
1721
1315
  let body;
1722
1316
  body = JSON.stringify(take(input, {
@@ -1729,26 +1323,19 @@ export const se_ListSequenceStoresCommand = async (input, context) => {
1729
1323
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1730
1324
  }
1731
1325
  }
1732
- return new __HttpRequest({
1733
- protocol,
1734
- hostname: resolvedHostname,
1735
- port,
1736
- method: "POST",
1737
- headers,
1738
- path: resolvedPath,
1739
- query,
1740
- body,
1741
- });
1326
+ b.hn(resolvedHostname);
1327
+ b.m("POST").h(headers).q(query).b(body);
1328
+ return b.build();
1742
1329
  };
1743
1330
  export const se_ListSharesCommand = async (input, context) => {
1744
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1331
+ const b = rb(input, context);
1745
1332
  const headers = {
1746
1333
  "content-type": "application/json",
1747
1334
  };
1748
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/shares";
1335
+ b.bp("/shares");
1749
1336
  const query = map({
1750
- nextToken: [, input.nextToken],
1751
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1337
+ [_nT]: [, input[_nT]],
1338
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
1752
1339
  });
1753
1340
  let body;
1754
1341
  body = JSON.stringify(take(input, {
@@ -1762,22 +1349,15 @@ export const se_ListSharesCommand = async (input, context) => {
1762
1349
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1763
1350
  }
1764
1351
  }
1765
- return new __HttpRequest({
1766
- protocol,
1767
- hostname: resolvedHostname,
1768
- port,
1769
- method: "POST",
1770
- headers,
1771
- path: resolvedPath,
1772
- query,
1773
- body,
1774
- });
1352
+ b.hn(resolvedHostname);
1353
+ b.m("POST").h(headers).q(query).b(body);
1354
+ return b.build();
1775
1355
  };
1776
1356
  export const se_ListTagsForResourceCommand = async (input, context) => {
1777
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1357
+ const b = rb(input, context);
1778
1358
  const headers = {};
1779
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
1780
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
1359
+ b.bp("/tags/{resourceArn}");
1360
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
1781
1361
  let body;
1782
1362
  let { hostname: resolvedHostname } = await context.endpoint();
1783
1363
  if (context.disableHostPrefix !== true) {
@@ -1786,25 +1366,19 @@ export const se_ListTagsForResourceCommand = async (input, context) => {
1786
1366
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1787
1367
  }
1788
1368
  }
1789
- return new __HttpRequest({
1790
- protocol,
1791
- hostname: resolvedHostname,
1792
- port,
1793
- method: "GET",
1794
- headers,
1795
- path: resolvedPath,
1796
- body,
1797
- });
1369
+ b.hn(resolvedHostname);
1370
+ b.m("GET").h(headers).b(body);
1371
+ return b.build();
1798
1372
  };
1799
1373
  export const se_ListVariantImportJobsCommand = async (input, context) => {
1800
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1374
+ const b = rb(input, context);
1801
1375
  const headers = {
1802
1376
  "content-type": "application/json",
1803
1377
  };
1804
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/import/variants";
1378
+ b.bp("/import/variants");
1805
1379
  const query = map({
1806
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1807
- nextToken: [, input.nextToken],
1380
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
1381
+ [_nT]: [, input[_nT]],
1808
1382
  });
1809
1383
  let body;
1810
1384
  body = JSON.stringify(take(input, {
@@ -1818,26 +1392,19 @@ export const se_ListVariantImportJobsCommand = async (input, context) => {
1818
1392
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1819
1393
  }
1820
1394
  }
1821
- return new __HttpRequest({
1822
- protocol,
1823
- hostname: resolvedHostname,
1824
- port,
1825
- method: "POST",
1826
- headers,
1827
- path: resolvedPath,
1828
- query,
1829
- body,
1830
- });
1395
+ b.hn(resolvedHostname);
1396
+ b.m("POST").h(headers).q(query).b(body);
1397
+ return b.build();
1831
1398
  };
1832
1399
  export const se_ListVariantStoresCommand = async (input, context) => {
1833
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1400
+ const b = rb(input, context);
1834
1401
  const headers = {
1835
1402
  "content-type": "application/json",
1836
1403
  };
1837
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/variantStores";
1404
+ b.bp("/variantStores");
1838
1405
  const query = map({
1839
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1840
- nextToken: [, input.nextToken],
1406
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
1407
+ [_nT]: [, input[_nT]],
1841
1408
  });
1842
1409
  let body;
1843
1410
  body = JSON.stringify(take(input, {
@@ -1851,26 +1418,19 @@ export const se_ListVariantStoresCommand = async (input, context) => {
1851
1418
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1852
1419
  }
1853
1420
  }
1854
- return new __HttpRequest({
1855
- protocol,
1856
- hostname: resolvedHostname,
1857
- port,
1858
- method: "POST",
1859
- headers,
1860
- path: resolvedPath,
1861
- query,
1862
- body,
1863
- });
1421
+ b.hn(resolvedHostname);
1422
+ b.m("POST").h(headers).q(query).b(body);
1423
+ return b.build();
1864
1424
  };
1865
1425
  export const se_ListWorkflowsCommand = async (input, context) => {
1866
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1426
+ const b = rb(input, context);
1867
1427
  const headers = {};
1868
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/workflow";
1428
+ b.bp("/workflow");
1869
1429
  const query = map({
1870
- type: [, input.type],
1871
- name: [, input.name],
1872
- startingToken: [, input.startingToken],
1873
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1430
+ [_t]: [, input[_t]],
1431
+ [_n]: [, input[_n]],
1432
+ [_sT]: [, input[_sT]],
1433
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
1874
1434
  });
1875
1435
  let body;
1876
1436
  let { hostname: resolvedHostname } = await context.endpoint();
@@ -1880,23 +1440,16 @@ export const se_ListWorkflowsCommand = async (input, context) => {
1880
1440
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1881
1441
  }
1882
1442
  }
1883
- return new __HttpRequest({
1884
- protocol,
1885
- hostname: resolvedHostname,
1886
- port,
1887
- method: "GET",
1888
- headers,
1889
- path: resolvedPath,
1890
- query,
1891
- body,
1892
- });
1443
+ b.hn(resolvedHostname);
1444
+ b.m("GET").h(headers).q(query).b(body);
1445
+ return b.build();
1893
1446
  };
1894
1447
  export const se_StartAnnotationImportJobCommand = async (input, context) => {
1895
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1448
+ const b = rb(input, context);
1896
1449
  const headers = {
1897
1450
  "content-type": "application/json",
1898
1451
  };
1899
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/import/annotation";
1452
+ b.bp("/import/annotation");
1900
1453
  let body;
1901
1454
  body = JSON.stringify(take(input, {
1902
1455
  annotationFields: (_) => _json(_),
@@ -1914,24 +1467,17 @@ export const se_StartAnnotationImportJobCommand = async (input, context) => {
1914
1467
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1915
1468
  }
1916
1469
  }
1917
- return new __HttpRequest({
1918
- protocol,
1919
- hostname: resolvedHostname,
1920
- port,
1921
- method: "POST",
1922
- headers,
1923
- path: resolvedPath,
1924
- body,
1925
- });
1470
+ b.hn(resolvedHostname);
1471
+ b.m("POST").h(headers).b(body);
1472
+ return b.build();
1926
1473
  };
1927
1474
  export const se_StartReadSetActivationJobCommand = async (input, context) => {
1928
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1475
+ const b = rb(input, context);
1929
1476
  const headers = {
1930
1477
  "content-type": "application/json",
1931
1478
  };
1932
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1933
- "/sequencestore/{sequenceStoreId}/activationjob";
1934
- resolvedPath = __resolvedPath(resolvedPath, input, "sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
1479
+ b.bp("/sequencestore/{sequenceStoreId}/activationjob");
1480
+ b.p("sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
1935
1481
  let body;
1936
1482
  body = JSON.stringify(take(input, {
1937
1483
  clientToken: [],
@@ -1944,24 +1490,17 @@ export const se_StartReadSetActivationJobCommand = async (input, context) => {
1944
1490
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1945
1491
  }
1946
1492
  }
1947
- return new __HttpRequest({
1948
- protocol,
1949
- hostname: resolvedHostname,
1950
- port,
1951
- method: "POST",
1952
- headers,
1953
- path: resolvedPath,
1954
- body,
1955
- });
1493
+ b.hn(resolvedHostname);
1494
+ b.m("POST").h(headers).b(body);
1495
+ return b.build();
1956
1496
  };
1957
1497
  export const se_StartReadSetExportJobCommand = async (input, context) => {
1958
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1498
+ const b = rb(input, context);
1959
1499
  const headers = {
1960
1500
  "content-type": "application/json",
1961
1501
  };
1962
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1963
- "/sequencestore/{sequenceStoreId}/exportjob";
1964
- resolvedPath = __resolvedPath(resolvedPath, input, "sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
1502
+ b.bp("/sequencestore/{sequenceStoreId}/exportjob");
1503
+ b.p("sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
1965
1504
  let body;
1966
1505
  body = JSON.stringify(take(input, {
1967
1506
  clientToken: [],
@@ -1976,24 +1515,17 @@ export const se_StartReadSetExportJobCommand = async (input, context) => {
1976
1515
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1977
1516
  }
1978
1517
  }
1979
- return new __HttpRequest({
1980
- protocol,
1981
- hostname: resolvedHostname,
1982
- port,
1983
- method: "POST",
1984
- headers,
1985
- path: resolvedPath,
1986
- body,
1987
- });
1518
+ b.hn(resolvedHostname);
1519
+ b.m("POST").h(headers).b(body);
1520
+ return b.build();
1988
1521
  };
1989
1522
  export const se_StartReadSetImportJobCommand = async (input, context) => {
1990
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1523
+ const b = rb(input, context);
1991
1524
  const headers = {
1992
1525
  "content-type": "application/json",
1993
1526
  };
1994
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1995
- "/sequencestore/{sequenceStoreId}/importjob";
1996
- resolvedPath = __resolvedPath(resolvedPath, input, "sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
1527
+ b.bp("/sequencestore/{sequenceStoreId}/importjob");
1528
+ b.p("sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
1997
1529
  let body;
1998
1530
  body = JSON.stringify(take(input, {
1999
1531
  clientToken: [],
@@ -2007,24 +1539,17 @@ export const se_StartReadSetImportJobCommand = async (input, context) => {
2007
1539
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2008
1540
  }
2009
1541
  }
2010
- return new __HttpRequest({
2011
- protocol,
2012
- hostname: resolvedHostname,
2013
- port,
2014
- method: "POST",
2015
- headers,
2016
- path: resolvedPath,
2017
- body,
2018
- });
1542
+ b.hn(resolvedHostname);
1543
+ b.m("POST").h(headers).b(body);
1544
+ return b.build();
2019
1545
  };
2020
1546
  export const se_StartReferenceImportJobCommand = async (input, context) => {
2021
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1547
+ const b = rb(input, context);
2022
1548
  const headers = {
2023
1549
  "content-type": "application/json",
2024
1550
  };
2025
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2026
- "/referencestore/{referenceStoreId}/importjob";
2027
- resolvedPath = __resolvedPath(resolvedPath, input, "referenceStoreId", () => input.referenceStoreId, "{referenceStoreId}", false);
1551
+ b.bp("/referencestore/{referenceStoreId}/importjob");
1552
+ b.p("referenceStoreId", () => input.referenceStoreId, "{referenceStoreId}", false);
2028
1553
  let body;
2029
1554
  body = JSON.stringify(take(input, {
2030
1555
  clientToken: [],
@@ -2038,22 +1563,16 @@ export const se_StartReferenceImportJobCommand = async (input, context) => {
2038
1563
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2039
1564
  }
2040
1565
  }
2041
- return new __HttpRequest({
2042
- protocol,
2043
- hostname: resolvedHostname,
2044
- port,
2045
- method: "POST",
2046
- headers,
2047
- path: resolvedPath,
2048
- body,
2049
- });
1566
+ b.hn(resolvedHostname);
1567
+ b.m("POST").h(headers).b(body);
1568
+ return b.build();
2050
1569
  };
2051
1570
  export const se_StartRunCommand = async (input, context) => {
2052
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1571
+ const b = rb(input, context);
2053
1572
  const headers = {
2054
1573
  "content-type": "application/json",
2055
1574
  };
2056
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/run";
1575
+ b.bp("/run");
2057
1576
  let body;
2058
1577
  body = JSON.stringify(take(input, {
2059
1578
  logLevel: [],
@@ -2078,22 +1597,16 @@ export const se_StartRunCommand = async (input, context) => {
2078
1597
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2079
1598
  }
2080
1599
  }
2081
- return new __HttpRequest({
2082
- protocol,
2083
- hostname: resolvedHostname,
2084
- port,
2085
- method: "POST",
2086
- headers,
2087
- path: resolvedPath,
2088
- body,
2089
- });
1600
+ b.hn(resolvedHostname);
1601
+ b.m("POST").h(headers).b(body);
1602
+ return b.build();
2090
1603
  };
2091
1604
  export const se_StartVariantImportJobCommand = async (input, context) => {
2092
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1605
+ const b = rb(input, context);
2093
1606
  const headers = {
2094
1607
  "content-type": "application/json",
2095
1608
  };
2096
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/import/variant";
1609
+ b.bp("/import/variant");
2097
1610
  let body;
2098
1611
  body = JSON.stringify(take(input, {
2099
1612
  annotationFields: (_) => _json(_),
@@ -2109,23 +1622,17 @@ export const se_StartVariantImportJobCommand = async (input, context) => {
2109
1622
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2110
1623
  }
2111
1624
  }
2112
- return new __HttpRequest({
2113
- protocol,
2114
- hostname: resolvedHostname,
2115
- port,
2116
- method: "POST",
2117
- headers,
2118
- path: resolvedPath,
2119
- body,
2120
- });
1625
+ b.hn(resolvedHostname);
1626
+ b.m("POST").h(headers).b(body);
1627
+ return b.build();
2121
1628
  };
2122
1629
  export const se_TagResourceCommand = async (input, context) => {
2123
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1630
+ const b = rb(input, context);
2124
1631
  const headers = {
2125
1632
  "content-type": "application/json",
2126
1633
  };
2127
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
2128
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
1634
+ b.bp("/tags/{resourceArn}");
1635
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
2129
1636
  let body;
2130
1637
  body = JSON.stringify(take(input, {
2131
1638
  tags: (_) => _json(_),
@@ -2137,25 +1644,19 @@ export const se_TagResourceCommand = async (input, context) => {
2137
1644
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2138
1645
  }
2139
1646
  }
2140
- return new __HttpRequest({
2141
- protocol,
2142
- hostname: resolvedHostname,
2143
- port,
2144
- method: "POST",
2145
- headers,
2146
- path: resolvedPath,
2147
- body,
2148
- });
1647
+ b.hn(resolvedHostname);
1648
+ b.m("POST").h(headers).b(body);
1649
+ return b.build();
2149
1650
  };
2150
1651
  export const se_UntagResourceCommand = async (input, context) => {
2151
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1652
+ const b = rb(input, context);
2152
1653
  const headers = {};
2153
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
2154
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
1654
+ b.bp("/tags/{resourceArn}");
1655
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
2155
1656
  const query = map({
2156
- tagKeys: [
1657
+ [_tK]: [
2157
1658
  __expectNonNull(input.tagKeys, `tagKeys`) != null,
2158
- () => (input.tagKeys || []).map((_entry) => _entry),
1659
+ () => (input[_tK] || []).map((_entry) => _entry),
2159
1660
  ],
2160
1661
  });
2161
1662
  let body;
@@ -2166,24 +1667,17 @@ export const se_UntagResourceCommand = async (input, context) => {
2166
1667
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2167
1668
  }
2168
1669
  }
2169
- return new __HttpRequest({
2170
- protocol,
2171
- hostname: resolvedHostname,
2172
- port,
2173
- method: "DELETE",
2174
- headers,
2175
- path: resolvedPath,
2176
- query,
2177
- body,
2178
- });
1670
+ b.hn(resolvedHostname);
1671
+ b.m("DELETE").h(headers).q(query).b(body);
1672
+ return b.build();
2179
1673
  };
2180
1674
  export const se_UpdateAnnotationStoreCommand = async (input, context) => {
2181
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1675
+ const b = rb(input, context);
2182
1676
  const headers = {
2183
1677
  "content-type": "application/json",
2184
1678
  };
2185
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/annotationStore/{name}";
2186
- resolvedPath = __resolvedPath(resolvedPath, input, "name", () => input.name, "{name}", false);
1679
+ b.bp("/annotationStore/{name}");
1680
+ b.p("name", () => input.name, "{name}", false);
2187
1681
  let body;
2188
1682
  body = JSON.stringify(take(input, {
2189
1683
  description: [],
@@ -2195,25 +1689,18 @@ export const se_UpdateAnnotationStoreCommand = async (input, context) => {
2195
1689
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2196
1690
  }
2197
1691
  }
2198
- return new __HttpRequest({
2199
- protocol,
2200
- hostname: resolvedHostname,
2201
- port,
2202
- method: "POST",
2203
- headers,
2204
- path: resolvedPath,
2205
- body,
2206
- });
1692
+ b.hn(resolvedHostname);
1693
+ b.m("POST").h(headers).b(body);
1694
+ return b.build();
2207
1695
  };
2208
1696
  export const se_UpdateAnnotationStoreVersionCommand = async (input, context) => {
2209
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1697
+ const b = rb(input, context);
2210
1698
  const headers = {
2211
1699
  "content-type": "application/json",
2212
1700
  };
2213
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2214
- "/annotationStore/{name}/version/{versionName}";
2215
- resolvedPath = __resolvedPath(resolvedPath, input, "name", () => input.name, "{name}", false);
2216
- resolvedPath = __resolvedPath(resolvedPath, input, "versionName", () => input.versionName, "{versionName}", false);
1701
+ b.bp("/annotationStore/{name}/version/{versionName}");
1702
+ b.p("name", () => input.name, "{name}", false);
1703
+ b.p("versionName", () => input.versionName, "{versionName}", false);
2217
1704
  let body;
2218
1705
  body = JSON.stringify(take(input, {
2219
1706
  description: [],
@@ -2225,23 +1712,17 @@ export const se_UpdateAnnotationStoreVersionCommand = async (input, context) =>
2225
1712
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2226
1713
  }
2227
1714
  }
2228
- return new __HttpRequest({
2229
- protocol,
2230
- hostname: resolvedHostname,
2231
- port,
2232
- method: "POST",
2233
- headers,
2234
- path: resolvedPath,
2235
- body,
2236
- });
1715
+ b.hn(resolvedHostname);
1716
+ b.m("POST").h(headers).b(body);
1717
+ return b.build();
2237
1718
  };
2238
1719
  export const se_UpdateRunGroupCommand = async (input, context) => {
2239
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1720
+ const b = rb(input, context);
2240
1721
  const headers = {
2241
1722
  "content-type": "application/json",
2242
1723
  };
2243
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/runGroup/{id}";
2244
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
1724
+ b.bp("/runGroup/{id}");
1725
+ b.p("id", () => input.id, "{id}", false);
2245
1726
  let body;
2246
1727
  body = JSON.stringify(take(input, {
2247
1728
  maxCpus: [],
@@ -2257,23 +1738,17 @@ export const se_UpdateRunGroupCommand = async (input, context) => {
2257
1738
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2258
1739
  }
2259
1740
  }
2260
- return new __HttpRequest({
2261
- protocol,
2262
- hostname: resolvedHostname,
2263
- port,
2264
- method: "POST",
2265
- headers,
2266
- path: resolvedPath,
2267
- body,
2268
- });
1741
+ b.hn(resolvedHostname);
1742
+ b.m("POST").h(headers).b(body);
1743
+ return b.build();
2269
1744
  };
2270
1745
  export const se_UpdateVariantStoreCommand = async (input, context) => {
2271
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1746
+ const b = rb(input, context);
2272
1747
  const headers = {
2273
1748
  "content-type": "application/json",
2274
1749
  };
2275
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/variantStore/{name}";
2276
- resolvedPath = __resolvedPath(resolvedPath, input, "name", () => input.name, "{name}", false);
1750
+ b.bp("/variantStore/{name}");
1751
+ b.p("name", () => input.name, "{name}", false);
2277
1752
  let body;
2278
1753
  body = JSON.stringify(take(input, {
2279
1754
  description: [],
@@ -2285,23 +1760,17 @@ export const se_UpdateVariantStoreCommand = async (input, context) => {
2285
1760
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2286
1761
  }
2287
1762
  }
2288
- return new __HttpRequest({
2289
- protocol,
2290
- hostname: resolvedHostname,
2291
- port,
2292
- method: "POST",
2293
- headers,
2294
- path: resolvedPath,
2295
- body,
2296
- });
1763
+ b.hn(resolvedHostname);
1764
+ b.m("POST").h(headers).b(body);
1765
+ return b.build();
2297
1766
  };
2298
1767
  export const se_UpdateWorkflowCommand = async (input, context) => {
2299
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1768
+ const b = rb(input, context);
2300
1769
  const headers = {
2301
1770
  "content-type": "application/json",
2302
1771
  };
2303
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/workflow/{id}";
2304
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
1772
+ b.bp("/workflow/{id}");
1773
+ b.p("id", () => input.id, "{id}", false);
2305
1774
  let body;
2306
1775
  body = JSON.stringify(take(input, {
2307
1776
  description: [],
@@ -2314,29 +1783,22 @@ export const se_UpdateWorkflowCommand = async (input, context) => {
2314
1783
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2315
1784
  }
2316
1785
  }
2317
- return new __HttpRequest({
2318
- protocol,
2319
- hostname: resolvedHostname,
2320
- port,
2321
- method: "POST",
2322
- headers,
2323
- path: resolvedPath,
2324
- body,
2325
- });
1786
+ b.hn(resolvedHostname);
1787
+ b.m("POST").h(headers).b(body);
1788
+ return b.build();
2326
1789
  };
2327
1790
  export const se_UploadReadSetPartCommand = async (input, context) => {
2328
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1791
+ const b = rb(input, context);
2329
1792
  const headers = {
2330
1793
  "x-amz-content-sha256": "UNSIGNED-PAYLOAD",
2331
1794
  "content-type": "application/octet-stream",
2332
1795
  };
2333
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2334
- "/sequencestore/{sequenceStoreId}/upload/{uploadId}/part";
2335
- resolvedPath = __resolvedPath(resolvedPath, input, "sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
2336
- resolvedPath = __resolvedPath(resolvedPath, input, "uploadId", () => input.uploadId, "{uploadId}", false);
1796
+ b.bp("/sequencestore/{sequenceStoreId}/upload/{uploadId}/part");
1797
+ b.p("sequenceStoreId", () => input.sequenceStoreId, "{sequenceStoreId}", false);
1798
+ b.p("uploadId", () => input.uploadId, "{uploadId}", false);
2337
1799
  const query = map({
2338
- partSource: [, __expectNonNull(input.partSource, `partSource`)],
2339
- partNumber: [__expectNonNull(input.partNumber, `partNumber`) != null, () => input.partNumber.toString()],
1800
+ [_pS]: [, __expectNonNull(input[_pS], `partSource`)],
1801
+ [_pN]: [__expectNonNull(input.partNumber, `partNumber`) != null, () => input[_pN].toString()],
2340
1802
  });
2341
1803
  let body;
2342
1804
  if (input.payload !== undefined) {
@@ -2349,16 +1811,9 @@ export const se_UploadReadSetPartCommand = async (input, context) => {
2349
1811
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2350
1812
  }
2351
1813
  }
2352
- return new __HttpRequest({
2353
- protocol,
2354
- hostname: resolvedHostname,
2355
- port,
2356
- method: "PUT",
2357
- headers,
2358
- path: resolvedPath,
2359
- query,
2360
- body,
2361
- });
1814
+ b.hn(resolvedHostname);
1815
+ b.m("PUT").h(headers).q(query).b(body);
1816
+ return b.build();
2362
1817
  };
2363
1818
  export const de_AbortMultipartReadSetUploadCommand = async (output, context) => {
2364
1819
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -7319,6 +6774,20 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
7319
6774
  value !== "" &&
7320
6775
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
7321
6776
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
6777
+ const _e = "export";
6778
+ const _f = "force";
6779
+ const _fi = "file";
6780
+ const _mR = "maxResults";
6781
+ const _n = "name";
6782
+ const _nT = "nextToken";
6783
+ const _pN = "partNumber";
6784
+ const _pS = "partSource";
6785
+ const _r = "range";
6786
+ const _rGI = "runGroupId";
6787
+ const _s = "status";
6788
+ const _sT = "startingToken";
6789
+ const _t = "type";
6790
+ const _tK = "tagKeys";
7322
6791
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
7323
6792
  if (encoded.length) {
7324
6793
  return JSON.parse(encoded);