@aws-sdk/client-imagebuilder 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 +338 -872
  2. package/dist-es/protocols/Aws_restJson1.js +339 -873
  3. package/package.json +5 -4
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,56 +1,42 @@
1
- import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
2
- import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, take, withBaseException, } from "@smithy/smithy-client";
1
+ import { requestBuilder as rb } from "@smithy/core";
2
+ import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseEpochTimestamp as __parseEpochTimestamp, take, withBaseException, } from "@smithy/smithy-client";
3
3
  import { v4 as generateIdempotencyToken } from "uuid";
4
4
  import { ImagebuilderServiceException as __BaseException } from "../models/ImagebuilderServiceException";
5
5
  import { CallRateLimitExceededException, ClientException, ForbiddenException, IdempotentParameterMismatchException, InvalidPaginationTokenException, InvalidParameterCombinationException, InvalidParameterException, InvalidParameterValueException, InvalidRequestException, InvalidVersionNumberException, ResourceAlreadyExistsException, ResourceDependencyException, ResourceInUseException, ResourceNotFoundException, ServiceException, ServiceQuotaExceededException, ServiceUnavailableException, } from "../models/models_0";
6
6
  export const se_CancelImageCreationCommand = async (input, context) => {
7
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
7
+ const b = rb(input, context);
8
8
  const headers = {
9
9
  "content-type": "application/json",
10
10
  };
11
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/CancelImageCreation";
11
+ b.bp("/CancelImageCreation");
12
12
  let body;
13
13
  body = JSON.stringify(take(input, {
14
14
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
15
15
  imageBuildVersionArn: [],
16
16
  }));
17
- return new __HttpRequest({
18
- protocol,
19
- hostname,
20
- port,
21
- method: "PUT",
22
- headers,
23
- path: resolvedPath,
24
- body,
25
- });
17
+ b.m("PUT").h(headers).b(body);
18
+ return b.build();
26
19
  };
27
20
  export const se_CancelLifecycleExecutionCommand = async (input, context) => {
28
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
21
+ const b = rb(input, context);
29
22
  const headers = {
30
23
  "content-type": "application/json",
31
24
  };
32
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/CancelLifecycleExecution";
25
+ b.bp("/CancelLifecycleExecution");
33
26
  let body;
34
27
  body = JSON.stringify(take(input, {
35
28
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
36
29
  lifecycleExecutionId: [],
37
30
  }));
38
- return new __HttpRequest({
39
- protocol,
40
- hostname,
41
- port,
42
- method: "PUT",
43
- headers,
44
- path: resolvedPath,
45
- body,
46
- });
31
+ b.m("PUT").h(headers).b(body);
32
+ return b.build();
47
33
  };
48
34
  export const se_CreateComponentCommand = async (input, context) => {
49
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
35
+ const b = rb(input, context);
50
36
  const headers = {
51
37
  "content-type": "application/json",
52
38
  };
53
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/CreateComponent";
39
+ b.bp("/CreateComponent");
54
40
  let body;
55
41
  body = JSON.stringify(take(input, {
56
42
  changeDescription: [],
@@ -65,22 +51,15 @@ export const se_CreateComponentCommand = async (input, context) => {
65
51
  tags: (_) => _json(_),
66
52
  uri: [],
67
53
  }));
68
- return new __HttpRequest({
69
- protocol,
70
- hostname,
71
- port,
72
- method: "PUT",
73
- headers,
74
- path: resolvedPath,
75
- body,
76
- });
54
+ b.m("PUT").h(headers).b(body);
55
+ return b.build();
77
56
  };
78
57
  export const se_CreateContainerRecipeCommand = async (input, context) => {
79
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
58
+ const b = rb(input, context);
80
59
  const headers = {
81
60
  "content-type": "application/json",
82
61
  };
83
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/CreateContainerRecipe";
62
+ b.bp("/CreateContainerRecipe");
84
63
  let body;
85
64
  body = JSON.stringify(take(input, {
86
65
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -100,22 +79,15 @@ export const se_CreateContainerRecipeCommand = async (input, context) => {
100
79
  targetRepository: (_) => _json(_),
101
80
  workingDirectory: [],
102
81
  }));
103
- return new __HttpRequest({
104
- protocol,
105
- hostname,
106
- port,
107
- method: "PUT",
108
- headers,
109
- path: resolvedPath,
110
- body,
111
- });
82
+ b.m("PUT").h(headers).b(body);
83
+ return b.build();
112
84
  };
113
85
  export const se_CreateDistributionConfigurationCommand = async (input, context) => {
114
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
86
+ const b = rb(input, context);
115
87
  const headers = {
116
88
  "content-type": "application/json",
117
89
  };
118
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/CreateDistributionConfiguration";
90
+ b.bp("/CreateDistributionConfiguration");
119
91
  let body;
120
92
  body = JSON.stringify(take(input, {
121
93
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -124,22 +96,15 @@ export const se_CreateDistributionConfigurationCommand = async (input, context)
124
96
  name: [],
125
97
  tags: (_) => _json(_),
126
98
  }));
127
- return new __HttpRequest({
128
- protocol,
129
- hostname,
130
- port,
131
- method: "PUT",
132
- headers,
133
- path: resolvedPath,
134
- body,
135
- });
99
+ b.m("PUT").h(headers).b(body);
100
+ return b.build();
136
101
  };
137
102
  export const se_CreateImageCommand = async (input, context) => {
138
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
103
+ const b = rb(input, context);
139
104
  const headers = {
140
105
  "content-type": "application/json",
141
106
  };
142
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/CreateImage";
107
+ b.bp("/CreateImage");
143
108
  let body;
144
109
  body = JSON.stringify(take(input, {
145
110
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -154,22 +119,15 @@ export const se_CreateImageCommand = async (input, context) => {
154
119
  tags: (_) => _json(_),
155
120
  workflows: (_) => _json(_),
156
121
  }));
157
- return new __HttpRequest({
158
- protocol,
159
- hostname,
160
- port,
161
- method: "PUT",
162
- headers,
163
- path: resolvedPath,
164
- body,
165
- });
122
+ b.m("PUT").h(headers).b(body);
123
+ return b.build();
166
124
  };
167
125
  export const se_CreateImagePipelineCommand = async (input, context) => {
168
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
126
+ const b = rb(input, context);
169
127
  const headers = {
170
128
  "content-type": "application/json",
171
129
  };
172
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/CreateImagePipeline";
130
+ b.bp("/CreateImagePipeline");
173
131
  let body;
174
132
  body = JSON.stringify(take(input, {
175
133
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -188,22 +146,15 @@ export const se_CreateImagePipelineCommand = async (input, context) => {
188
146
  tags: (_) => _json(_),
189
147
  workflows: (_) => _json(_),
190
148
  }));
191
- return new __HttpRequest({
192
- protocol,
193
- hostname,
194
- port,
195
- method: "PUT",
196
- headers,
197
- path: resolvedPath,
198
- body,
199
- });
149
+ b.m("PUT").h(headers).b(body);
150
+ return b.build();
200
151
  };
201
152
  export const se_CreateImageRecipeCommand = async (input, context) => {
202
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
153
+ const b = rb(input, context);
203
154
  const headers = {
204
155
  "content-type": "application/json",
205
156
  };
206
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/CreateImageRecipe";
157
+ b.bp("/CreateImageRecipe");
207
158
  let body;
208
159
  body = JSON.stringify(take(input, {
209
160
  additionalInstanceConfiguration: (_) => _json(_),
@@ -217,22 +168,15 @@ export const se_CreateImageRecipeCommand = async (input, context) => {
217
168
  tags: (_) => _json(_),
218
169
  workingDirectory: [],
219
170
  }));
220
- return new __HttpRequest({
221
- protocol,
222
- hostname,
223
- port,
224
- method: "PUT",
225
- headers,
226
- path: resolvedPath,
227
- body,
228
- });
171
+ b.m("PUT").h(headers).b(body);
172
+ return b.build();
229
173
  };
230
174
  export const se_CreateInfrastructureConfigurationCommand = async (input, context) => {
231
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
175
+ const b = rb(input, context);
232
176
  const headers = {
233
177
  "content-type": "application/json",
234
178
  };
235
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/CreateInfrastructureConfiguration";
179
+ b.bp("/CreateInfrastructureConfiguration");
236
180
  let body;
237
181
  body = JSON.stringify(take(input, {
238
182
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -250,22 +194,15 @@ export const se_CreateInfrastructureConfigurationCommand = async (input, context
250
194
  tags: (_) => _json(_),
251
195
  terminateInstanceOnFailure: [],
252
196
  }));
253
- return new __HttpRequest({
254
- protocol,
255
- hostname,
256
- port,
257
- method: "PUT",
258
- headers,
259
- path: resolvedPath,
260
- body,
261
- });
197
+ b.m("PUT").h(headers).b(body);
198
+ return b.build();
262
199
  };
263
200
  export const se_CreateLifecyclePolicyCommand = async (input, context) => {
264
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
201
+ const b = rb(input, context);
265
202
  const headers = {
266
203
  "content-type": "application/json",
267
204
  };
268
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/CreateLifecyclePolicy";
205
+ b.bp("/CreateLifecyclePolicy");
269
206
  let body;
270
207
  body = JSON.stringify(take(input, {
271
208
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -278,22 +215,15 @@ export const se_CreateLifecyclePolicyCommand = async (input, context) => {
278
215
  status: [],
279
216
  tags: (_) => _json(_),
280
217
  }));
281
- return new __HttpRequest({
282
- protocol,
283
- hostname,
284
- port,
285
- method: "PUT",
286
- headers,
287
- path: resolvedPath,
288
- body,
289
- });
218
+ b.m("PUT").h(headers).b(body);
219
+ return b.build();
290
220
  };
291
221
  export const se_CreateWorkflowCommand = async (input, context) => {
292
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
222
+ const b = rb(input, context);
293
223
  const headers = {
294
224
  "content-type": "application/json",
295
225
  };
296
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/CreateWorkflow";
226
+ b.bp("/CreateWorkflow");
297
227
  let body;
298
228
  body = JSON.stringify(take(input, {
299
229
  changeDescription: [],
@@ -307,509 +237,290 @@ export const se_CreateWorkflowCommand = async (input, context) => {
307
237
  type: [],
308
238
  uri: [],
309
239
  }));
310
- return new __HttpRequest({
311
- protocol,
312
- hostname,
313
- port,
314
- method: "PUT",
315
- headers,
316
- path: resolvedPath,
317
- body,
318
- });
240
+ b.m("PUT").h(headers).b(body);
241
+ return b.build();
319
242
  };
320
243
  export const se_DeleteComponentCommand = async (input, context) => {
321
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
244
+ const b = rb(input, context);
322
245
  const headers = {};
323
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/DeleteComponent";
246
+ b.bp("/DeleteComponent");
324
247
  const query = map({
325
- componentBuildVersionArn: [, __expectNonNull(input.componentBuildVersionArn, `componentBuildVersionArn`)],
248
+ [_cBVA]: [, __expectNonNull(input[_cBVA], `componentBuildVersionArn`)],
326
249
  });
327
250
  let body;
328
- return new __HttpRequest({
329
- protocol,
330
- hostname,
331
- port,
332
- method: "DELETE",
333
- headers,
334
- path: resolvedPath,
335
- query,
336
- body,
337
- });
251
+ b.m("DELETE").h(headers).q(query).b(body);
252
+ return b.build();
338
253
  };
339
254
  export const se_DeleteContainerRecipeCommand = async (input, context) => {
340
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
255
+ const b = rb(input, context);
341
256
  const headers = {};
342
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/DeleteContainerRecipe";
257
+ b.bp("/DeleteContainerRecipe");
343
258
  const query = map({
344
- containerRecipeArn: [, __expectNonNull(input.containerRecipeArn, `containerRecipeArn`)],
259
+ [_cRA]: [, __expectNonNull(input[_cRA], `containerRecipeArn`)],
345
260
  });
346
261
  let body;
347
- return new __HttpRequest({
348
- protocol,
349
- hostname,
350
- port,
351
- method: "DELETE",
352
- headers,
353
- path: resolvedPath,
354
- query,
355
- body,
356
- });
262
+ b.m("DELETE").h(headers).q(query).b(body);
263
+ return b.build();
357
264
  };
358
265
  export const se_DeleteDistributionConfigurationCommand = async (input, context) => {
359
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
266
+ const b = rb(input, context);
360
267
  const headers = {};
361
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/DeleteDistributionConfiguration";
268
+ b.bp("/DeleteDistributionConfiguration");
362
269
  const query = map({
363
- distributionConfigurationArn: [
364
- ,
365
- __expectNonNull(input.distributionConfigurationArn, `distributionConfigurationArn`),
366
- ],
270
+ [_dCA]: [, __expectNonNull(input[_dCA], `distributionConfigurationArn`)],
367
271
  });
368
272
  let body;
369
- return new __HttpRequest({
370
- protocol,
371
- hostname,
372
- port,
373
- method: "DELETE",
374
- headers,
375
- path: resolvedPath,
376
- query,
377
- body,
378
- });
273
+ b.m("DELETE").h(headers).q(query).b(body);
274
+ return b.build();
379
275
  };
380
276
  export const se_DeleteImageCommand = async (input, context) => {
381
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
277
+ const b = rb(input, context);
382
278
  const headers = {};
383
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/DeleteImage";
279
+ b.bp("/DeleteImage");
384
280
  const query = map({
385
- imageBuildVersionArn: [, __expectNonNull(input.imageBuildVersionArn, `imageBuildVersionArn`)],
281
+ [_iBVA]: [, __expectNonNull(input[_iBVA], `imageBuildVersionArn`)],
386
282
  });
387
283
  let body;
388
- return new __HttpRequest({
389
- protocol,
390
- hostname,
391
- port,
392
- method: "DELETE",
393
- headers,
394
- path: resolvedPath,
395
- query,
396
- body,
397
- });
284
+ b.m("DELETE").h(headers).q(query).b(body);
285
+ return b.build();
398
286
  };
399
287
  export const se_DeleteImagePipelineCommand = async (input, context) => {
400
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
288
+ const b = rb(input, context);
401
289
  const headers = {};
402
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/DeleteImagePipeline";
290
+ b.bp("/DeleteImagePipeline");
403
291
  const query = map({
404
- imagePipelineArn: [, __expectNonNull(input.imagePipelineArn, `imagePipelineArn`)],
292
+ [_iPA]: [, __expectNonNull(input[_iPA], `imagePipelineArn`)],
405
293
  });
406
294
  let body;
407
- return new __HttpRequest({
408
- protocol,
409
- hostname,
410
- port,
411
- method: "DELETE",
412
- headers,
413
- path: resolvedPath,
414
- query,
415
- body,
416
- });
295
+ b.m("DELETE").h(headers).q(query).b(body);
296
+ return b.build();
417
297
  };
418
298
  export const se_DeleteImageRecipeCommand = async (input, context) => {
419
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
299
+ const b = rb(input, context);
420
300
  const headers = {};
421
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/DeleteImageRecipe";
301
+ b.bp("/DeleteImageRecipe");
422
302
  const query = map({
423
- imageRecipeArn: [, __expectNonNull(input.imageRecipeArn, `imageRecipeArn`)],
303
+ [_iRA]: [, __expectNonNull(input[_iRA], `imageRecipeArn`)],
424
304
  });
425
305
  let body;
426
- return new __HttpRequest({
427
- protocol,
428
- hostname,
429
- port,
430
- method: "DELETE",
431
- headers,
432
- path: resolvedPath,
433
- query,
434
- body,
435
- });
306
+ b.m("DELETE").h(headers).q(query).b(body);
307
+ return b.build();
436
308
  };
437
309
  export const se_DeleteInfrastructureConfigurationCommand = async (input, context) => {
438
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
310
+ const b = rb(input, context);
439
311
  const headers = {};
440
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/DeleteInfrastructureConfiguration";
312
+ b.bp("/DeleteInfrastructureConfiguration");
441
313
  const query = map({
442
- infrastructureConfigurationArn: [
443
- ,
444
- __expectNonNull(input.infrastructureConfigurationArn, `infrastructureConfigurationArn`),
445
- ],
314
+ [_iCA]: [, __expectNonNull(input[_iCA], `infrastructureConfigurationArn`)],
446
315
  });
447
316
  let body;
448
- return new __HttpRequest({
449
- protocol,
450
- hostname,
451
- port,
452
- method: "DELETE",
453
- headers,
454
- path: resolvedPath,
455
- query,
456
- body,
457
- });
317
+ b.m("DELETE").h(headers).q(query).b(body);
318
+ return b.build();
458
319
  };
459
320
  export const se_DeleteLifecyclePolicyCommand = async (input, context) => {
460
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
321
+ const b = rb(input, context);
461
322
  const headers = {};
462
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/DeleteLifecyclePolicy";
323
+ b.bp("/DeleteLifecyclePolicy");
463
324
  const query = map({
464
- lifecyclePolicyArn: [, __expectNonNull(input.lifecyclePolicyArn, `lifecyclePolicyArn`)],
325
+ [_lPA]: [, __expectNonNull(input[_lPA], `lifecyclePolicyArn`)],
465
326
  });
466
327
  let body;
467
- return new __HttpRequest({
468
- protocol,
469
- hostname,
470
- port,
471
- method: "DELETE",
472
- headers,
473
- path: resolvedPath,
474
- query,
475
- body,
476
- });
328
+ b.m("DELETE").h(headers).q(query).b(body);
329
+ return b.build();
477
330
  };
478
331
  export const se_DeleteWorkflowCommand = async (input, context) => {
479
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
332
+ const b = rb(input, context);
480
333
  const headers = {};
481
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/DeleteWorkflow";
334
+ b.bp("/DeleteWorkflow");
482
335
  const query = map({
483
- workflowBuildVersionArn: [, __expectNonNull(input.workflowBuildVersionArn, `workflowBuildVersionArn`)],
336
+ [_wBVA]: [, __expectNonNull(input[_wBVA], `workflowBuildVersionArn`)],
484
337
  });
485
338
  let body;
486
- return new __HttpRequest({
487
- protocol,
488
- hostname,
489
- port,
490
- method: "DELETE",
491
- headers,
492
- path: resolvedPath,
493
- query,
494
- body,
495
- });
339
+ b.m("DELETE").h(headers).q(query).b(body);
340
+ return b.build();
496
341
  };
497
342
  export const se_GetComponentCommand = async (input, context) => {
498
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
343
+ const b = rb(input, context);
499
344
  const headers = {};
500
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/GetComponent";
345
+ b.bp("/GetComponent");
501
346
  const query = map({
502
- componentBuildVersionArn: [, __expectNonNull(input.componentBuildVersionArn, `componentBuildVersionArn`)],
347
+ [_cBVA]: [, __expectNonNull(input[_cBVA], `componentBuildVersionArn`)],
503
348
  });
504
349
  let body;
505
- return new __HttpRequest({
506
- protocol,
507
- hostname,
508
- port,
509
- method: "GET",
510
- headers,
511
- path: resolvedPath,
512
- query,
513
- body,
514
- });
350
+ b.m("GET").h(headers).q(query).b(body);
351
+ return b.build();
515
352
  };
516
353
  export const se_GetComponentPolicyCommand = async (input, context) => {
517
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
354
+ const b = rb(input, context);
518
355
  const headers = {};
519
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/GetComponentPolicy";
356
+ b.bp("/GetComponentPolicy");
520
357
  const query = map({
521
- componentArn: [, __expectNonNull(input.componentArn, `componentArn`)],
358
+ [_cA]: [, __expectNonNull(input[_cA], `componentArn`)],
522
359
  });
523
360
  let body;
524
- return new __HttpRequest({
525
- protocol,
526
- hostname,
527
- port,
528
- method: "GET",
529
- headers,
530
- path: resolvedPath,
531
- query,
532
- body,
533
- });
361
+ b.m("GET").h(headers).q(query).b(body);
362
+ return b.build();
534
363
  };
535
364
  export const se_GetContainerRecipeCommand = async (input, context) => {
536
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
365
+ const b = rb(input, context);
537
366
  const headers = {};
538
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/GetContainerRecipe";
367
+ b.bp("/GetContainerRecipe");
539
368
  const query = map({
540
- containerRecipeArn: [, __expectNonNull(input.containerRecipeArn, `containerRecipeArn`)],
369
+ [_cRA]: [, __expectNonNull(input[_cRA], `containerRecipeArn`)],
541
370
  });
542
371
  let body;
543
- return new __HttpRequest({
544
- protocol,
545
- hostname,
546
- port,
547
- method: "GET",
548
- headers,
549
- path: resolvedPath,
550
- query,
551
- body,
552
- });
372
+ b.m("GET").h(headers).q(query).b(body);
373
+ return b.build();
553
374
  };
554
375
  export const se_GetContainerRecipePolicyCommand = async (input, context) => {
555
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
376
+ const b = rb(input, context);
556
377
  const headers = {};
557
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/GetContainerRecipePolicy";
378
+ b.bp("/GetContainerRecipePolicy");
558
379
  const query = map({
559
- containerRecipeArn: [, __expectNonNull(input.containerRecipeArn, `containerRecipeArn`)],
380
+ [_cRA]: [, __expectNonNull(input[_cRA], `containerRecipeArn`)],
560
381
  });
561
382
  let body;
562
- return new __HttpRequest({
563
- protocol,
564
- hostname,
565
- port,
566
- method: "GET",
567
- headers,
568
- path: resolvedPath,
569
- query,
570
- body,
571
- });
383
+ b.m("GET").h(headers).q(query).b(body);
384
+ return b.build();
572
385
  };
573
386
  export const se_GetDistributionConfigurationCommand = async (input, context) => {
574
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
387
+ const b = rb(input, context);
575
388
  const headers = {};
576
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/GetDistributionConfiguration";
389
+ b.bp("/GetDistributionConfiguration");
577
390
  const query = map({
578
- distributionConfigurationArn: [
579
- ,
580
- __expectNonNull(input.distributionConfigurationArn, `distributionConfigurationArn`),
581
- ],
391
+ [_dCA]: [, __expectNonNull(input[_dCA], `distributionConfigurationArn`)],
582
392
  });
583
393
  let body;
584
- return new __HttpRequest({
585
- protocol,
586
- hostname,
587
- port,
588
- method: "GET",
589
- headers,
590
- path: resolvedPath,
591
- query,
592
- body,
593
- });
394
+ b.m("GET").h(headers).q(query).b(body);
395
+ return b.build();
594
396
  };
595
397
  export const se_GetImageCommand = async (input, context) => {
596
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
398
+ const b = rb(input, context);
597
399
  const headers = {};
598
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/GetImage";
400
+ b.bp("/GetImage");
599
401
  const query = map({
600
- imageBuildVersionArn: [, __expectNonNull(input.imageBuildVersionArn, `imageBuildVersionArn`)],
402
+ [_iBVA]: [, __expectNonNull(input[_iBVA], `imageBuildVersionArn`)],
601
403
  });
602
404
  let body;
603
- return new __HttpRequest({
604
- protocol,
605
- hostname,
606
- port,
607
- method: "GET",
608
- headers,
609
- path: resolvedPath,
610
- query,
611
- body,
612
- });
405
+ b.m("GET").h(headers).q(query).b(body);
406
+ return b.build();
613
407
  };
614
408
  export const se_GetImagePipelineCommand = async (input, context) => {
615
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
409
+ const b = rb(input, context);
616
410
  const headers = {};
617
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/GetImagePipeline";
411
+ b.bp("/GetImagePipeline");
618
412
  const query = map({
619
- imagePipelineArn: [, __expectNonNull(input.imagePipelineArn, `imagePipelineArn`)],
413
+ [_iPA]: [, __expectNonNull(input[_iPA], `imagePipelineArn`)],
620
414
  });
621
415
  let body;
622
- return new __HttpRequest({
623
- protocol,
624
- hostname,
625
- port,
626
- method: "GET",
627
- headers,
628
- path: resolvedPath,
629
- query,
630
- body,
631
- });
416
+ b.m("GET").h(headers).q(query).b(body);
417
+ return b.build();
632
418
  };
633
419
  export const se_GetImagePolicyCommand = async (input, context) => {
634
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
420
+ const b = rb(input, context);
635
421
  const headers = {};
636
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/GetImagePolicy";
422
+ b.bp("/GetImagePolicy");
637
423
  const query = map({
638
- imageArn: [, __expectNonNull(input.imageArn, `imageArn`)],
424
+ [_iA]: [, __expectNonNull(input[_iA], `imageArn`)],
639
425
  });
640
426
  let body;
641
- return new __HttpRequest({
642
- protocol,
643
- hostname,
644
- port,
645
- method: "GET",
646
- headers,
647
- path: resolvedPath,
648
- query,
649
- body,
650
- });
427
+ b.m("GET").h(headers).q(query).b(body);
428
+ return b.build();
651
429
  };
652
430
  export const se_GetImageRecipeCommand = async (input, context) => {
653
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
431
+ const b = rb(input, context);
654
432
  const headers = {};
655
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/GetImageRecipe";
433
+ b.bp("/GetImageRecipe");
656
434
  const query = map({
657
- imageRecipeArn: [, __expectNonNull(input.imageRecipeArn, `imageRecipeArn`)],
435
+ [_iRA]: [, __expectNonNull(input[_iRA], `imageRecipeArn`)],
658
436
  });
659
437
  let body;
660
- return new __HttpRequest({
661
- protocol,
662
- hostname,
663
- port,
664
- method: "GET",
665
- headers,
666
- path: resolvedPath,
667
- query,
668
- body,
669
- });
438
+ b.m("GET").h(headers).q(query).b(body);
439
+ return b.build();
670
440
  };
671
441
  export const se_GetImageRecipePolicyCommand = async (input, context) => {
672
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
442
+ const b = rb(input, context);
673
443
  const headers = {};
674
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/GetImageRecipePolicy";
444
+ b.bp("/GetImageRecipePolicy");
675
445
  const query = map({
676
- imageRecipeArn: [, __expectNonNull(input.imageRecipeArn, `imageRecipeArn`)],
446
+ [_iRA]: [, __expectNonNull(input[_iRA], `imageRecipeArn`)],
677
447
  });
678
448
  let body;
679
- return new __HttpRequest({
680
- protocol,
681
- hostname,
682
- port,
683
- method: "GET",
684
- headers,
685
- path: resolvedPath,
686
- query,
687
- body,
688
- });
449
+ b.m("GET").h(headers).q(query).b(body);
450
+ return b.build();
689
451
  };
690
452
  export const se_GetInfrastructureConfigurationCommand = async (input, context) => {
691
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
453
+ const b = rb(input, context);
692
454
  const headers = {};
693
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/GetInfrastructureConfiguration";
455
+ b.bp("/GetInfrastructureConfiguration");
694
456
  const query = map({
695
- infrastructureConfigurationArn: [
696
- ,
697
- __expectNonNull(input.infrastructureConfigurationArn, `infrastructureConfigurationArn`),
698
- ],
457
+ [_iCA]: [, __expectNonNull(input[_iCA], `infrastructureConfigurationArn`)],
699
458
  });
700
459
  let body;
701
- return new __HttpRequest({
702
- protocol,
703
- hostname,
704
- port,
705
- method: "GET",
706
- headers,
707
- path: resolvedPath,
708
- query,
709
- body,
710
- });
460
+ b.m("GET").h(headers).q(query).b(body);
461
+ return b.build();
711
462
  };
712
463
  export const se_GetLifecycleExecutionCommand = async (input, context) => {
713
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
464
+ const b = rb(input, context);
714
465
  const headers = {};
715
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/GetLifecycleExecution";
466
+ b.bp("/GetLifecycleExecution");
716
467
  const query = map({
717
- lifecycleExecutionId: [, __expectNonNull(input.lifecycleExecutionId, `lifecycleExecutionId`)],
468
+ [_lEI]: [, __expectNonNull(input[_lEI], `lifecycleExecutionId`)],
718
469
  });
719
470
  let body;
720
- return new __HttpRequest({
721
- protocol,
722
- hostname,
723
- port,
724
- method: "GET",
725
- headers,
726
- path: resolvedPath,
727
- query,
728
- body,
729
- });
471
+ b.m("GET").h(headers).q(query).b(body);
472
+ return b.build();
730
473
  };
731
474
  export const se_GetLifecyclePolicyCommand = async (input, context) => {
732
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
475
+ const b = rb(input, context);
733
476
  const headers = {};
734
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/GetLifecyclePolicy";
477
+ b.bp("/GetLifecyclePolicy");
735
478
  const query = map({
736
- lifecyclePolicyArn: [, __expectNonNull(input.lifecyclePolicyArn, `lifecyclePolicyArn`)],
479
+ [_lPA]: [, __expectNonNull(input[_lPA], `lifecyclePolicyArn`)],
737
480
  });
738
481
  let body;
739
- return new __HttpRequest({
740
- protocol,
741
- hostname,
742
- port,
743
- method: "GET",
744
- headers,
745
- path: resolvedPath,
746
- query,
747
- body,
748
- });
482
+ b.m("GET").h(headers).q(query).b(body);
483
+ return b.build();
749
484
  };
750
485
  export const se_GetWorkflowCommand = async (input, context) => {
751
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
486
+ const b = rb(input, context);
752
487
  const headers = {};
753
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/GetWorkflow";
488
+ b.bp("/GetWorkflow");
754
489
  const query = map({
755
- workflowBuildVersionArn: [, __expectNonNull(input.workflowBuildVersionArn, `workflowBuildVersionArn`)],
490
+ [_wBVA]: [, __expectNonNull(input[_wBVA], `workflowBuildVersionArn`)],
756
491
  });
757
492
  let body;
758
- return new __HttpRequest({
759
- protocol,
760
- hostname,
761
- port,
762
- method: "GET",
763
- headers,
764
- path: resolvedPath,
765
- query,
766
- body,
767
- });
493
+ b.m("GET").h(headers).q(query).b(body);
494
+ return b.build();
768
495
  };
769
496
  export const se_GetWorkflowExecutionCommand = async (input, context) => {
770
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
497
+ const b = rb(input, context);
771
498
  const headers = {};
772
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/GetWorkflowExecution";
499
+ b.bp("/GetWorkflowExecution");
773
500
  const query = map({
774
- workflowExecutionId: [, __expectNonNull(input.workflowExecutionId, `workflowExecutionId`)],
501
+ [_wEI]: [, __expectNonNull(input[_wEI], `workflowExecutionId`)],
775
502
  });
776
503
  let body;
777
- return new __HttpRequest({
778
- protocol,
779
- hostname,
780
- port,
781
- method: "GET",
782
- headers,
783
- path: resolvedPath,
784
- query,
785
- body,
786
- });
504
+ b.m("GET").h(headers).q(query).b(body);
505
+ return b.build();
787
506
  };
788
507
  export const se_GetWorkflowStepExecutionCommand = async (input, context) => {
789
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
508
+ const b = rb(input, context);
790
509
  const headers = {};
791
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/GetWorkflowStepExecution";
510
+ b.bp("/GetWorkflowStepExecution");
792
511
  const query = map({
793
- stepExecutionId: [, __expectNonNull(input.stepExecutionId, `stepExecutionId`)],
512
+ [_sEI]: [, __expectNonNull(input[_sEI], `stepExecutionId`)],
794
513
  });
795
514
  let body;
796
- return new __HttpRequest({
797
- protocol,
798
- hostname,
799
- port,
800
- method: "GET",
801
- headers,
802
- path: resolvedPath,
803
- query,
804
- body,
805
- });
515
+ b.m("GET").h(headers).q(query).b(body);
516
+ return b.build();
806
517
  };
807
518
  export const se_ImportComponentCommand = async (input, context) => {
808
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
519
+ const b = rb(input, context);
809
520
  const headers = {
810
521
  "content-type": "application/json",
811
522
  };
812
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ImportComponent";
523
+ b.bp("/ImportComponent");
813
524
  let body;
814
525
  body = JSON.stringify(take(input, {
815
526
  changeDescription: [],
@@ -825,22 +536,15 @@ export const se_ImportComponentCommand = async (input, context) => {
825
536
  type: [],
826
537
  uri: [],
827
538
  }));
828
- return new __HttpRequest({
829
- protocol,
830
- hostname,
831
- port,
832
- method: "PUT",
833
- headers,
834
- path: resolvedPath,
835
- body,
836
- });
539
+ b.m("PUT").h(headers).b(body);
540
+ return b.build();
837
541
  };
838
542
  export const se_ImportVmImageCommand = async (input, context) => {
839
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
543
+ const b = rb(input, context);
840
544
  const headers = {
841
545
  "content-type": "application/json",
842
546
  };
843
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ImportVmImage";
547
+ b.bp("/ImportVmImage");
844
548
  let body;
845
549
  body = JSON.stringify(take(input, {
846
550
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -852,44 +556,30 @@ export const se_ImportVmImageCommand = async (input, context) => {
852
556
  tags: (_) => _json(_),
853
557
  vmImportTaskId: [],
854
558
  }));
855
- return new __HttpRequest({
856
- protocol,
857
- hostname,
858
- port,
859
- method: "PUT",
860
- headers,
861
- path: resolvedPath,
862
- body,
863
- });
559
+ b.m("PUT").h(headers).b(body);
560
+ return b.build();
864
561
  };
865
562
  export const se_ListComponentBuildVersionsCommand = async (input, context) => {
866
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
563
+ const b = rb(input, context);
867
564
  const headers = {
868
565
  "content-type": "application/json",
869
566
  };
870
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListComponentBuildVersions";
567
+ b.bp("/ListComponentBuildVersions");
871
568
  let body;
872
569
  body = JSON.stringify(take(input, {
873
570
  componentVersionArn: [],
874
571
  maxResults: [],
875
572
  nextToken: [],
876
573
  }));
877
- return new __HttpRequest({
878
- protocol,
879
- hostname,
880
- port,
881
- method: "POST",
882
- headers,
883
- path: resolvedPath,
884
- body,
885
- });
574
+ b.m("POST").h(headers).b(body);
575
+ return b.build();
886
576
  };
887
577
  export const se_ListComponentsCommand = async (input, context) => {
888
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
578
+ const b = rb(input, context);
889
579
  const headers = {
890
580
  "content-type": "application/json",
891
581
  };
892
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListComponents";
582
+ b.bp("/ListComponents");
893
583
  let body;
894
584
  body = JSON.stringify(take(input, {
895
585
  byName: [],
@@ -898,22 +588,15 @@ export const se_ListComponentsCommand = async (input, context) => {
898
588
  nextToken: [],
899
589
  owner: [],
900
590
  }));
901
- return new __HttpRequest({
902
- protocol,
903
- hostname,
904
- port,
905
- method: "POST",
906
- headers,
907
- path: resolvedPath,
908
- body,
909
- });
591
+ b.m("POST").h(headers).b(body);
592
+ return b.build();
910
593
  };
911
594
  export const se_ListContainerRecipesCommand = async (input, context) => {
912
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
595
+ const b = rb(input, context);
913
596
  const headers = {
914
597
  "content-type": "application/json",
915
598
  };
916
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListContainerRecipes";
599
+ b.bp("/ListContainerRecipes");
917
600
  let body;
918
601
  body = JSON.stringify(take(input, {
919
602
  filters: (_) => _json(_),
@@ -921,44 +604,30 @@ export const se_ListContainerRecipesCommand = async (input, context) => {
921
604
  nextToken: [],
922
605
  owner: [],
923
606
  }));
924
- return new __HttpRequest({
925
- protocol,
926
- hostname,
927
- port,
928
- method: "POST",
929
- headers,
930
- path: resolvedPath,
931
- body,
932
- });
607
+ b.m("POST").h(headers).b(body);
608
+ return b.build();
933
609
  };
934
610
  export const se_ListDistributionConfigurationsCommand = async (input, context) => {
935
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
611
+ const b = rb(input, context);
936
612
  const headers = {
937
613
  "content-type": "application/json",
938
614
  };
939
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListDistributionConfigurations";
615
+ b.bp("/ListDistributionConfigurations");
940
616
  let body;
941
617
  body = JSON.stringify(take(input, {
942
618
  filters: (_) => _json(_),
943
619
  maxResults: [],
944
620
  nextToken: [],
945
621
  }));
946
- return new __HttpRequest({
947
- protocol,
948
- hostname,
949
- port,
950
- method: "POST",
951
- headers,
952
- path: resolvedPath,
953
- body,
954
- });
622
+ b.m("POST").h(headers).b(body);
623
+ return b.build();
955
624
  };
956
625
  export const se_ListImageBuildVersionsCommand = async (input, context) => {
957
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
626
+ const b = rb(input, context);
958
627
  const headers = {
959
628
  "content-type": "application/json",
960
629
  };
961
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListImageBuildVersions";
630
+ b.bp("/ListImageBuildVersions");
962
631
  let body;
963
632
  body = JSON.stringify(take(input, {
964
633
  filters: (_) => _json(_),
@@ -966,44 +635,30 @@ export const se_ListImageBuildVersionsCommand = async (input, context) => {
966
635
  maxResults: [],
967
636
  nextToken: [],
968
637
  }));
969
- return new __HttpRequest({
970
- protocol,
971
- hostname,
972
- port,
973
- method: "POST",
974
- headers,
975
- path: resolvedPath,
976
- body,
977
- });
638
+ b.m("POST").h(headers).b(body);
639
+ return b.build();
978
640
  };
979
641
  export const se_ListImagePackagesCommand = async (input, context) => {
980
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
642
+ const b = rb(input, context);
981
643
  const headers = {
982
644
  "content-type": "application/json",
983
645
  };
984
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListImagePackages";
646
+ b.bp("/ListImagePackages");
985
647
  let body;
986
648
  body = JSON.stringify(take(input, {
987
649
  imageBuildVersionArn: [],
988
650
  maxResults: [],
989
651
  nextToken: [],
990
652
  }));
991
- return new __HttpRequest({
992
- protocol,
993
- hostname,
994
- port,
995
- method: "POST",
996
- headers,
997
- path: resolvedPath,
998
- body,
999
- });
653
+ b.m("POST").h(headers).b(body);
654
+ return b.build();
1000
655
  };
1001
656
  export const se_ListImagePipelineImagesCommand = async (input, context) => {
1002
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
657
+ const b = rb(input, context);
1003
658
  const headers = {
1004
659
  "content-type": "application/json",
1005
660
  };
1006
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListImagePipelineImages";
661
+ b.bp("/ListImagePipelineImages");
1007
662
  let body;
1008
663
  body = JSON.stringify(take(input, {
1009
664
  filters: (_) => _json(_),
@@ -1011,44 +666,30 @@ export const se_ListImagePipelineImagesCommand = async (input, context) => {
1011
666
  maxResults: [],
1012
667
  nextToken: [],
1013
668
  }));
1014
- return new __HttpRequest({
1015
- protocol,
1016
- hostname,
1017
- port,
1018
- method: "POST",
1019
- headers,
1020
- path: resolvedPath,
1021
- body,
1022
- });
669
+ b.m("POST").h(headers).b(body);
670
+ return b.build();
1023
671
  };
1024
672
  export const se_ListImagePipelinesCommand = async (input, context) => {
1025
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
673
+ const b = rb(input, context);
1026
674
  const headers = {
1027
675
  "content-type": "application/json",
1028
676
  };
1029
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListImagePipelines";
677
+ b.bp("/ListImagePipelines");
1030
678
  let body;
1031
679
  body = JSON.stringify(take(input, {
1032
680
  filters: (_) => _json(_),
1033
681
  maxResults: [],
1034
682
  nextToken: [],
1035
683
  }));
1036
- return new __HttpRequest({
1037
- protocol,
1038
- hostname,
1039
- port,
1040
- method: "POST",
1041
- headers,
1042
- path: resolvedPath,
1043
- body,
1044
- });
684
+ b.m("POST").h(headers).b(body);
685
+ return b.build();
1045
686
  };
1046
687
  export const se_ListImageRecipesCommand = async (input, context) => {
1047
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
688
+ const b = rb(input, context);
1048
689
  const headers = {
1049
690
  "content-type": "application/json",
1050
691
  };
1051
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListImageRecipes";
692
+ b.bp("/ListImageRecipes");
1052
693
  let body;
1053
694
  body = JSON.stringify(take(input, {
1054
695
  filters: (_) => _json(_),
@@ -1056,22 +697,15 @@ export const se_ListImageRecipesCommand = async (input, context) => {
1056
697
  nextToken: [],
1057
698
  owner: [],
1058
699
  }));
1059
- return new __HttpRequest({
1060
- protocol,
1061
- hostname,
1062
- port,
1063
- method: "POST",
1064
- headers,
1065
- path: resolvedPath,
1066
- body,
1067
- });
700
+ b.m("POST").h(headers).b(body);
701
+ return b.build();
1068
702
  };
1069
703
  export const se_ListImagesCommand = async (input, context) => {
1070
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
704
+ const b = rb(input, context);
1071
705
  const headers = {
1072
706
  "content-type": "application/json",
1073
707
  };
1074
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListImages";
708
+ b.bp("/ListImages");
1075
709
  let body;
1076
710
  body = JSON.stringify(take(input, {
1077
711
  byName: [],
@@ -1081,87 +715,59 @@ export const se_ListImagesCommand = async (input, context) => {
1081
715
  nextToken: [],
1082
716
  owner: [],
1083
717
  }));
1084
- return new __HttpRequest({
1085
- protocol,
1086
- hostname,
1087
- port,
1088
- method: "POST",
1089
- headers,
1090
- path: resolvedPath,
1091
- body,
1092
- });
718
+ b.m("POST").h(headers).b(body);
719
+ return b.build();
1093
720
  };
1094
721
  export const se_ListImageScanFindingAggregationsCommand = async (input, context) => {
1095
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
722
+ const b = rb(input, context);
1096
723
  const headers = {
1097
724
  "content-type": "application/json",
1098
725
  };
1099
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListImageScanFindingAggregations";
726
+ b.bp("/ListImageScanFindingAggregations");
1100
727
  let body;
1101
728
  body = JSON.stringify(take(input, {
1102
729
  filter: (_) => _json(_),
1103
730
  nextToken: [],
1104
731
  }));
1105
- return new __HttpRequest({
1106
- protocol,
1107
- hostname,
1108
- port,
1109
- method: "POST",
1110
- headers,
1111
- path: resolvedPath,
1112
- body,
1113
- });
732
+ b.m("POST").h(headers).b(body);
733
+ return b.build();
1114
734
  };
1115
735
  export const se_ListImageScanFindingsCommand = async (input, context) => {
1116
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
736
+ const b = rb(input, context);
1117
737
  const headers = {
1118
738
  "content-type": "application/json",
1119
739
  };
1120
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListImageScanFindings";
740
+ b.bp("/ListImageScanFindings");
1121
741
  let body;
1122
742
  body = JSON.stringify(take(input, {
1123
743
  filters: (_) => _json(_),
1124
744
  maxResults: [],
1125
745
  nextToken: [],
1126
746
  }));
1127
- return new __HttpRequest({
1128
- protocol,
1129
- hostname,
1130
- port,
1131
- method: "POST",
1132
- headers,
1133
- path: resolvedPath,
1134
- body,
1135
- });
747
+ b.m("POST").h(headers).b(body);
748
+ return b.build();
1136
749
  };
1137
750
  export const se_ListInfrastructureConfigurationsCommand = async (input, context) => {
1138
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
751
+ const b = rb(input, context);
1139
752
  const headers = {
1140
753
  "content-type": "application/json",
1141
754
  };
1142
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListInfrastructureConfigurations";
755
+ b.bp("/ListInfrastructureConfigurations");
1143
756
  let body;
1144
757
  body = JSON.stringify(take(input, {
1145
758
  filters: (_) => _json(_),
1146
759
  maxResults: [],
1147
760
  nextToken: [],
1148
761
  }));
1149
- return new __HttpRequest({
1150
- protocol,
1151
- hostname,
1152
- port,
1153
- method: "POST",
1154
- headers,
1155
- path: resolvedPath,
1156
- body,
1157
- });
762
+ b.m("POST").h(headers).b(body);
763
+ return b.build();
1158
764
  };
1159
765
  export const se_ListLifecycleExecutionResourcesCommand = async (input, context) => {
1160
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
766
+ const b = rb(input, context);
1161
767
  const headers = {
1162
768
  "content-type": "application/json",
1163
769
  };
1164
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListLifecycleExecutionResources";
770
+ b.bp("/ListLifecycleExecutionResources");
1165
771
  let body;
1166
772
  body = JSON.stringify(take(input, {
1167
773
  lifecycleExecutionId: [],
@@ -1169,147 +775,98 @@ export const se_ListLifecycleExecutionResourcesCommand = async (input, context)
1169
775
  nextToken: [],
1170
776
  parentResourceId: [],
1171
777
  }));
1172
- return new __HttpRequest({
1173
- protocol,
1174
- hostname,
1175
- port,
1176
- method: "POST",
1177
- headers,
1178
- path: resolvedPath,
1179
- body,
1180
- });
778
+ b.m("POST").h(headers).b(body);
779
+ return b.build();
1181
780
  };
1182
781
  export const se_ListLifecycleExecutionsCommand = async (input, context) => {
1183
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
782
+ const b = rb(input, context);
1184
783
  const headers = {
1185
784
  "content-type": "application/json",
1186
785
  };
1187
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListLifecycleExecutions";
786
+ b.bp("/ListLifecycleExecutions");
1188
787
  let body;
1189
788
  body = JSON.stringify(take(input, {
1190
789
  maxResults: [],
1191
790
  nextToken: [],
1192
791
  resourceArn: [],
1193
792
  }));
1194
- return new __HttpRequest({
1195
- protocol,
1196
- hostname,
1197
- port,
1198
- method: "POST",
1199
- headers,
1200
- path: resolvedPath,
1201
- body,
1202
- });
793
+ b.m("POST").h(headers).b(body);
794
+ return b.build();
1203
795
  };
1204
796
  export const se_ListLifecyclePoliciesCommand = async (input, context) => {
1205
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
797
+ const b = rb(input, context);
1206
798
  const headers = {
1207
799
  "content-type": "application/json",
1208
800
  };
1209
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListLifecyclePolicies";
801
+ b.bp("/ListLifecyclePolicies");
1210
802
  let body;
1211
803
  body = JSON.stringify(take(input, {
1212
804
  filters: (_) => _json(_),
1213
805
  maxResults: [],
1214
806
  nextToken: [],
1215
807
  }));
1216
- return new __HttpRequest({
1217
- protocol,
1218
- hostname,
1219
- port,
1220
- method: "POST",
1221
- headers,
1222
- path: resolvedPath,
1223
- body,
1224
- });
808
+ b.m("POST").h(headers).b(body);
809
+ return b.build();
1225
810
  };
1226
811
  export const se_ListTagsForResourceCommand = async (input, context) => {
1227
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
812
+ const b = rb(input, context);
1228
813
  const headers = {};
1229
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
1230
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
814
+ b.bp("/tags/{resourceArn}");
815
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
1231
816
  let body;
1232
- return new __HttpRequest({
1233
- protocol,
1234
- hostname,
1235
- port,
1236
- method: "GET",
1237
- headers,
1238
- path: resolvedPath,
1239
- body,
1240
- });
817
+ b.m("GET").h(headers).b(body);
818
+ return b.build();
1241
819
  };
1242
820
  export const se_ListWaitingWorkflowStepsCommand = async (input, context) => {
1243
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
821
+ const b = rb(input, context);
1244
822
  const headers = {
1245
823
  "content-type": "application/json",
1246
824
  };
1247
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListWaitingWorkflowSteps";
825
+ b.bp("/ListWaitingWorkflowSteps");
1248
826
  let body;
1249
827
  body = JSON.stringify(take(input, {
1250
828
  maxResults: [],
1251
829
  nextToken: [],
1252
830
  }));
1253
- return new __HttpRequest({
1254
- protocol,
1255
- hostname,
1256
- port,
1257
- method: "POST",
1258
- headers,
1259
- path: resolvedPath,
1260
- body,
1261
- });
831
+ b.m("POST").h(headers).b(body);
832
+ return b.build();
1262
833
  };
1263
834
  export const se_ListWorkflowBuildVersionsCommand = async (input, context) => {
1264
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
835
+ const b = rb(input, context);
1265
836
  const headers = {
1266
837
  "content-type": "application/json",
1267
838
  };
1268
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListWorkflowBuildVersions";
839
+ b.bp("/ListWorkflowBuildVersions");
1269
840
  let body;
1270
841
  body = JSON.stringify(take(input, {
1271
842
  maxResults: [],
1272
843
  nextToken: [],
1273
844
  workflowVersionArn: [],
1274
845
  }));
1275
- return new __HttpRequest({
1276
- protocol,
1277
- hostname,
1278
- port,
1279
- method: "POST",
1280
- headers,
1281
- path: resolvedPath,
1282
- body,
1283
- });
846
+ b.m("POST").h(headers).b(body);
847
+ return b.build();
1284
848
  };
1285
849
  export const se_ListWorkflowExecutionsCommand = async (input, context) => {
1286
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
850
+ const b = rb(input, context);
1287
851
  const headers = {
1288
852
  "content-type": "application/json",
1289
853
  };
1290
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListWorkflowExecutions";
854
+ b.bp("/ListWorkflowExecutions");
1291
855
  let body;
1292
856
  body = JSON.stringify(take(input, {
1293
857
  imageBuildVersionArn: [],
1294
858
  maxResults: [],
1295
859
  nextToken: [],
1296
860
  }));
1297
- return new __HttpRequest({
1298
- protocol,
1299
- hostname,
1300
- port,
1301
- method: "POST",
1302
- headers,
1303
- path: resolvedPath,
1304
- body,
1305
- });
861
+ b.m("POST").h(headers).b(body);
862
+ return b.build();
1306
863
  };
1307
864
  export const se_ListWorkflowsCommand = async (input, context) => {
1308
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
865
+ const b = rb(input, context);
1309
866
  const headers = {
1310
867
  "content-type": "application/json",
1311
868
  };
1312
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListWorkflows";
869
+ b.bp("/ListWorkflows");
1313
870
  let body;
1314
871
  body = JSON.stringify(take(input, {
1315
872
  byName: [],
@@ -1318,128 +875,86 @@ export const se_ListWorkflowsCommand = async (input, context) => {
1318
875
  nextToken: [],
1319
876
  owner: [],
1320
877
  }));
1321
- return new __HttpRequest({
1322
- protocol,
1323
- hostname,
1324
- port,
1325
- method: "POST",
1326
- headers,
1327
- path: resolvedPath,
1328
- body,
1329
- });
878
+ b.m("POST").h(headers).b(body);
879
+ return b.build();
1330
880
  };
1331
881
  export const se_ListWorkflowStepExecutionsCommand = async (input, context) => {
1332
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
882
+ const b = rb(input, context);
1333
883
  const headers = {
1334
884
  "content-type": "application/json",
1335
885
  };
1336
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListWorkflowStepExecutions";
886
+ b.bp("/ListWorkflowStepExecutions");
1337
887
  let body;
1338
888
  body = JSON.stringify(take(input, {
1339
889
  maxResults: [],
1340
890
  nextToken: [],
1341
891
  workflowExecutionId: [],
1342
892
  }));
1343
- return new __HttpRequest({
1344
- protocol,
1345
- hostname,
1346
- port,
1347
- method: "POST",
1348
- headers,
1349
- path: resolvedPath,
1350
- body,
1351
- });
893
+ b.m("POST").h(headers).b(body);
894
+ return b.build();
1352
895
  };
1353
896
  export const se_PutComponentPolicyCommand = async (input, context) => {
1354
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
897
+ const b = rb(input, context);
1355
898
  const headers = {
1356
899
  "content-type": "application/json",
1357
900
  };
1358
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/PutComponentPolicy";
901
+ b.bp("/PutComponentPolicy");
1359
902
  let body;
1360
903
  body = JSON.stringify(take(input, {
1361
904
  componentArn: [],
1362
905
  policy: [],
1363
906
  }));
1364
- return new __HttpRequest({
1365
- protocol,
1366
- hostname,
1367
- port,
1368
- method: "PUT",
1369
- headers,
1370
- path: resolvedPath,
1371
- body,
1372
- });
907
+ b.m("PUT").h(headers).b(body);
908
+ return b.build();
1373
909
  };
1374
910
  export const se_PutContainerRecipePolicyCommand = async (input, context) => {
1375
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
911
+ const b = rb(input, context);
1376
912
  const headers = {
1377
913
  "content-type": "application/json",
1378
914
  };
1379
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/PutContainerRecipePolicy";
915
+ b.bp("/PutContainerRecipePolicy");
1380
916
  let body;
1381
917
  body = JSON.stringify(take(input, {
1382
918
  containerRecipeArn: [],
1383
919
  policy: [],
1384
920
  }));
1385
- return new __HttpRequest({
1386
- protocol,
1387
- hostname,
1388
- port,
1389
- method: "PUT",
1390
- headers,
1391
- path: resolvedPath,
1392
- body,
1393
- });
921
+ b.m("PUT").h(headers).b(body);
922
+ return b.build();
1394
923
  };
1395
924
  export const se_PutImagePolicyCommand = async (input, context) => {
1396
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
925
+ const b = rb(input, context);
1397
926
  const headers = {
1398
927
  "content-type": "application/json",
1399
928
  };
1400
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/PutImagePolicy";
929
+ b.bp("/PutImagePolicy");
1401
930
  let body;
1402
931
  body = JSON.stringify(take(input, {
1403
932
  imageArn: [],
1404
933
  policy: [],
1405
934
  }));
1406
- return new __HttpRequest({
1407
- protocol,
1408
- hostname,
1409
- port,
1410
- method: "PUT",
1411
- headers,
1412
- path: resolvedPath,
1413
- body,
1414
- });
935
+ b.m("PUT").h(headers).b(body);
936
+ return b.build();
1415
937
  };
1416
938
  export const se_PutImageRecipePolicyCommand = async (input, context) => {
1417
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
939
+ const b = rb(input, context);
1418
940
  const headers = {
1419
941
  "content-type": "application/json",
1420
942
  };
1421
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/PutImageRecipePolicy";
943
+ b.bp("/PutImageRecipePolicy");
1422
944
  let body;
1423
945
  body = JSON.stringify(take(input, {
1424
946
  imageRecipeArn: [],
1425
947
  policy: [],
1426
948
  }));
1427
- return new __HttpRequest({
1428
- protocol,
1429
- hostname,
1430
- port,
1431
- method: "PUT",
1432
- headers,
1433
- path: resolvedPath,
1434
- body,
1435
- });
949
+ b.m("PUT").h(headers).b(body);
950
+ return b.build();
1436
951
  };
1437
952
  export const se_SendWorkflowStepActionCommand = async (input, context) => {
1438
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
953
+ const b = rb(input, context);
1439
954
  const headers = {
1440
955
  "content-type": "application/json",
1441
956
  };
1442
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/SendWorkflowStepAction";
957
+ b.bp("/SendWorkflowStepAction");
1443
958
  let body;
1444
959
  body = JSON.stringify(take(input, {
1445
960
  action: [],
@@ -1448,43 +963,29 @@ export const se_SendWorkflowStepActionCommand = async (input, context) => {
1448
963
  reason: [],
1449
964
  stepExecutionId: [],
1450
965
  }));
1451
- return new __HttpRequest({
1452
- protocol,
1453
- hostname,
1454
- port,
1455
- method: "PUT",
1456
- headers,
1457
- path: resolvedPath,
1458
- body,
1459
- });
966
+ b.m("PUT").h(headers).b(body);
967
+ return b.build();
1460
968
  };
1461
969
  export const se_StartImagePipelineExecutionCommand = async (input, context) => {
1462
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
970
+ const b = rb(input, context);
1463
971
  const headers = {
1464
972
  "content-type": "application/json",
1465
973
  };
1466
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/StartImagePipelineExecution";
974
+ b.bp("/StartImagePipelineExecution");
1467
975
  let body;
1468
976
  body = JSON.stringify(take(input, {
1469
977
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
1470
978
  imagePipelineArn: [],
1471
979
  }));
1472
- return new __HttpRequest({
1473
- protocol,
1474
- hostname,
1475
- port,
1476
- method: "PUT",
1477
- headers,
1478
- path: resolvedPath,
1479
- body,
1480
- });
980
+ b.m("PUT").h(headers).b(body);
981
+ return b.build();
1481
982
  };
1482
983
  export const se_StartResourceStateUpdateCommand = async (input, context) => {
1483
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
984
+ const b = rb(input, context);
1484
985
  const headers = {
1485
986
  "content-type": "application/json",
1486
987
  };
1487
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/StartResourceStateUpdate";
988
+ b.bp("/StartResourceStateUpdate");
1488
989
  let body;
1489
990
  body = JSON.stringify(take(input, {
1490
991
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -1495,66 +996,44 @@ export const se_StartResourceStateUpdateCommand = async (input, context) => {
1495
996
  state: (_) => _json(_),
1496
997
  updateAt: (_) => Math.round(_.getTime() / 1000),
1497
998
  }));
1498
- return new __HttpRequest({
1499
- protocol,
1500
- hostname,
1501
- port,
1502
- method: "PUT",
1503
- headers,
1504
- path: resolvedPath,
1505
- body,
1506
- });
999
+ b.m("PUT").h(headers).b(body);
1000
+ return b.build();
1507
1001
  };
1508
1002
  export const se_TagResourceCommand = async (input, context) => {
1509
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1003
+ const b = rb(input, context);
1510
1004
  const headers = {
1511
1005
  "content-type": "application/json",
1512
1006
  };
1513
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
1514
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
1007
+ b.bp("/tags/{resourceArn}");
1008
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
1515
1009
  let body;
1516
1010
  body = JSON.stringify(take(input, {
1517
1011
  tags: (_) => _json(_),
1518
1012
  }));
1519
- return new __HttpRequest({
1520
- protocol,
1521
- hostname,
1522
- port,
1523
- method: "POST",
1524
- headers,
1525
- path: resolvedPath,
1526
- body,
1527
- });
1013
+ b.m("POST").h(headers).b(body);
1014
+ return b.build();
1528
1015
  };
1529
1016
  export const se_UntagResourceCommand = async (input, context) => {
1530
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1017
+ const b = rb(input, context);
1531
1018
  const headers = {};
1532
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
1533
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
1019
+ b.bp("/tags/{resourceArn}");
1020
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
1534
1021
  const query = map({
1535
- tagKeys: [
1022
+ [_tK]: [
1536
1023
  __expectNonNull(input.tagKeys, `tagKeys`) != null,
1537
- () => (input.tagKeys || []).map((_entry) => _entry),
1024
+ () => (input[_tK] || []).map((_entry) => _entry),
1538
1025
  ],
1539
1026
  });
1540
1027
  let body;
1541
- return new __HttpRequest({
1542
- protocol,
1543
- hostname,
1544
- port,
1545
- method: "DELETE",
1546
- headers,
1547
- path: resolvedPath,
1548
- query,
1549
- body,
1550
- });
1028
+ b.m("DELETE").h(headers).q(query).b(body);
1029
+ return b.build();
1551
1030
  };
1552
1031
  export const se_UpdateDistributionConfigurationCommand = async (input, context) => {
1553
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1032
+ const b = rb(input, context);
1554
1033
  const headers = {
1555
1034
  "content-type": "application/json",
1556
1035
  };
1557
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/UpdateDistributionConfiguration";
1036
+ b.bp("/UpdateDistributionConfiguration");
1558
1037
  let body;
1559
1038
  body = JSON.stringify(take(input, {
1560
1039
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -1562,22 +1041,15 @@ export const se_UpdateDistributionConfigurationCommand = async (input, context)
1562
1041
  distributionConfigurationArn: [],
1563
1042
  distributions: (_) => _json(_),
1564
1043
  }));
1565
- return new __HttpRequest({
1566
- protocol,
1567
- hostname,
1568
- port,
1569
- method: "PUT",
1570
- headers,
1571
- path: resolvedPath,
1572
- body,
1573
- });
1044
+ b.m("PUT").h(headers).b(body);
1045
+ return b.build();
1574
1046
  };
1575
1047
  export const se_UpdateImagePipelineCommand = async (input, context) => {
1576
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1048
+ const b = rb(input, context);
1577
1049
  const headers = {
1578
1050
  "content-type": "application/json",
1579
1051
  };
1580
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/UpdateImagePipeline";
1052
+ b.bp("/UpdateImagePipeline");
1581
1053
  let body;
1582
1054
  body = JSON.stringify(take(input, {
1583
1055
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -1595,22 +1067,15 @@ export const se_UpdateImagePipelineCommand = async (input, context) => {
1595
1067
  status: [],
1596
1068
  workflows: (_) => _json(_),
1597
1069
  }));
1598
- return new __HttpRequest({
1599
- protocol,
1600
- hostname,
1601
- port,
1602
- method: "PUT",
1603
- headers,
1604
- path: resolvedPath,
1605
- body,
1606
- });
1070
+ b.m("PUT").h(headers).b(body);
1071
+ return b.build();
1607
1072
  };
1608
1073
  export const se_UpdateInfrastructureConfigurationCommand = async (input, context) => {
1609
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1074
+ const b = rb(input, context);
1610
1075
  const headers = {
1611
1076
  "content-type": "application/json",
1612
1077
  };
1613
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/UpdateInfrastructureConfiguration";
1078
+ b.bp("/UpdateInfrastructureConfiguration");
1614
1079
  let body;
1615
1080
  body = JSON.stringify(take(input, {
1616
1081
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -1627,22 +1092,15 @@ export const se_UpdateInfrastructureConfigurationCommand = async (input, context
1627
1092
  subnetId: [],
1628
1093
  terminateInstanceOnFailure: [],
1629
1094
  }));
1630
- return new __HttpRequest({
1631
- protocol,
1632
- hostname,
1633
- port,
1634
- method: "PUT",
1635
- headers,
1636
- path: resolvedPath,
1637
- body,
1638
- });
1095
+ b.m("PUT").h(headers).b(body);
1096
+ return b.build();
1639
1097
  };
1640
1098
  export const se_UpdateLifecyclePolicyCommand = async (input, context) => {
1641
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1099
+ const b = rb(input, context);
1642
1100
  const headers = {
1643
1101
  "content-type": "application/json",
1644
1102
  };
1645
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/UpdateLifecyclePolicy";
1103
+ b.bp("/UpdateLifecyclePolicy");
1646
1104
  let body;
1647
1105
  body = JSON.stringify(take(input, {
1648
1106
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -1654,15 +1112,8 @@ export const se_UpdateLifecyclePolicyCommand = async (input, context) => {
1654
1112
  resourceType: [],
1655
1113
  status: [],
1656
1114
  }));
1657
- return new __HttpRequest({
1658
- protocol,
1659
- hostname,
1660
- port,
1661
- method: "PUT",
1662
- headers,
1663
- path: resolvedPath,
1664
- body,
1665
- });
1115
+ b.m("PUT").h(headers).b(body);
1116
+ return b.build();
1666
1117
  };
1667
1118
  export const de_CancelImageCreationCommand = async (output, context) => {
1668
1119
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -5995,6 +5446,21 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
5995
5446
  value !== "" &&
5996
5447
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
5997
5448
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
5449
+ const _cA = "componentArn";
5450
+ const _cBVA = "componentBuildVersionArn";
5451
+ const _cRA = "containerRecipeArn";
5452
+ const _dCA = "distributionConfigurationArn";
5453
+ const _iA = "imageArn";
5454
+ const _iBVA = "imageBuildVersionArn";
5455
+ const _iCA = "infrastructureConfigurationArn";
5456
+ const _iPA = "imagePipelineArn";
5457
+ const _iRA = "imageRecipeArn";
5458
+ const _lEI = "lifecycleExecutionId";
5459
+ const _lPA = "lifecyclePolicyArn";
5460
+ const _sEI = "stepExecutionId";
5461
+ const _tK = "tagKeys";
5462
+ const _wBVA = "workflowBuildVersionArn";
5463
+ const _wEI = "workflowExecutionId";
5998
5464
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
5999
5465
  if (encoded.length) {
6000
5466
  return JSON.parse(encoded);