@aws-sdk/client-api-gateway 3.474.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 +773 -1669
  2. package/dist-es/protocols/Aws_restJson1.js +774 -1670
  3. package/package.json +5 -4
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,13 +1,13 @@
1
- import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
2
- import { _json, collectBody, convertMap, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
1
+ import { requestBuilder as rb } from "@smithy/core";
2
+ import { _json, collectBody, convertMap, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseEpochTimestamp as __parseEpochTimestamp, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
3
3
  import { APIGatewayServiceException as __BaseException } from "../models/APIGatewayServiceException";
4
4
  import { BadRequestException, ConflictException, LimitExceededException, NotFoundException, ServiceUnavailableException, TooManyRequestsException, UnauthorizedException, } from "../models/models_0";
5
5
  export const se_CreateApiKeyCommand = async (input, context) => {
6
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
6
+ const b = rb(input, context);
7
7
  const headers = {
8
8
  "content-type": "application/json",
9
9
  };
10
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/apikeys";
10
+ b.bp("/apikeys");
11
11
  let body;
12
12
  body = JSON.stringify(take(input, {
13
13
  customerId: [],
@@ -19,23 +19,16 @@ export const se_CreateApiKeyCommand = async (input, context) => {
19
19
  tags: (_) => _json(_),
20
20
  value: [],
21
21
  }));
22
- return new __HttpRequest({
23
- protocol,
24
- hostname,
25
- port,
26
- method: "POST",
27
- headers,
28
- path: resolvedPath,
29
- body,
30
- });
22
+ b.m("POST").h(headers).b(body);
23
+ return b.build();
31
24
  };
32
25
  export const se_CreateAuthorizerCommand = async (input, context) => {
33
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
26
+ const b = rb(input, context);
34
27
  const headers = {
35
28
  "content-type": "application/json",
36
29
  };
37
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/authorizers";
38
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
30
+ b.bp("/restapis/{restApiId}/authorizers");
31
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
39
32
  let body;
40
33
  body = JSON.stringify(take(input, {
41
34
  authType: [],
@@ -48,47 +41,32 @@ export const se_CreateAuthorizerCommand = async (input, context) => {
48
41
  providerARNs: (_) => _json(_),
49
42
  type: [],
50
43
  }));
51
- return new __HttpRequest({
52
- protocol,
53
- hostname,
54
- port,
55
- method: "POST",
56
- headers,
57
- path: resolvedPath,
58
- body,
59
- });
44
+ b.m("POST").h(headers).b(body);
45
+ return b.build();
60
46
  };
61
47
  export const se_CreateBasePathMappingCommand = async (input, context) => {
62
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
48
+ const b = rb(input, context);
63
49
  const headers = {
64
50
  "content-type": "application/json",
65
51
  };
66
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
67
- "/domainnames/{domainName}/basepathmappings";
68
- resolvedPath = __resolvedPath(resolvedPath, input, "domainName", () => input.domainName, "{domainName}", false);
52
+ b.bp("/domainnames/{domainName}/basepathmappings");
53
+ b.p("domainName", () => input.domainName, "{domainName}", false);
69
54
  let body;
70
55
  body = JSON.stringify(take(input, {
71
56
  basePath: [],
72
57
  restApiId: [],
73
58
  stage: [],
74
59
  }));
75
- return new __HttpRequest({
76
- protocol,
77
- hostname,
78
- port,
79
- method: "POST",
80
- headers,
81
- path: resolvedPath,
82
- body,
83
- });
60
+ b.m("POST").h(headers).b(body);
61
+ return b.build();
84
62
  };
85
63
  export const se_CreateDeploymentCommand = async (input, context) => {
86
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
64
+ const b = rb(input, context);
87
65
  const headers = {
88
66
  "content-type": "application/json",
89
67
  };
90
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/deployments";
91
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
68
+ b.bp("/restapis/{restApiId}/deployments");
69
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
92
70
  let body;
93
71
  body = JSON.stringify(take(input, {
94
72
  cacheClusterEnabled: [],
@@ -100,68 +78,46 @@ export const se_CreateDeploymentCommand = async (input, context) => {
100
78
  tracingEnabled: [],
101
79
  variables: (_) => _json(_),
102
80
  }));
103
- return new __HttpRequest({
104
- protocol,
105
- hostname,
106
- port,
107
- method: "POST",
108
- headers,
109
- path: resolvedPath,
110
- body,
111
- });
81
+ b.m("POST").h(headers).b(body);
82
+ return b.build();
112
83
  };
113
84
  export const se_CreateDocumentationPartCommand = async (input, context) => {
114
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
85
+ const b = rb(input, context);
115
86
  const headers = {
116
87
  "content-type": "application/json",
117
88
  };
118
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/documentation/parts";
119
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
89
+ b.bp("/restapis/{restApiId}/documentation/parts");
90
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
120
91
  let body;
121
92
  body = JSON.stringify(take(input, {
122
93
  location: (_) => _json(_),
123
94
  properties: [],
124
95
  }));
125
- return new __HttpRequest({
126
- protocol,
127
- hostname,
128
- port,
129
- method: "POST",
130
- headers,
131
- path: resolvedPath,
132
- body,
133
- });
96
+ b.m("POST").h(headers).b(body);
97
+ return b.build();
134
98
  };
135
99
  export const se_CreateDocumentationVersionCommand = async (input, context) => {
136
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
100
+ const b = rb(input, context);
137
101
  const headers = {
138
102
  "content-type": "application/json",
139
103
  };
140
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
141
- "/restapis/{restApiId}/documentation/versions";
142
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
104
+ b.bp("/restapis/{restApiId}/documentation/versions");
105
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
143
106
  let body;
144
107
  body = JSON.stringify(take(input, {
145
108
  description: [],
146
109
  documentationVersion: [],
147
110
  stageName: [],
148
111
  }));
149
- return new __HttpRequest({
150
- protocol,
151
- hostname,
152
- port,
153
- method: "POST",
154
- headers,
155
- path: resolvedPath,
156
- body,
157
- });
112
+ b.m("POST").h(headers).b(body);
113
+ return b.build();
158
114
  };
159
115
  export const se_CreateDomainNameCommand = async (input, context) => {
160
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
116
+ const b = rb(input, context);
161
117
  const headers = {
162
118
  "content-type": "application/json",
163
119
  };
164
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/domainnames";
120
+ b.bp("/domainnames");
165
121
  let body;
166
122
  body = JSON.stringify(take(input, {
167
123
  certificateArn: [],
@@ -178,23 +134,16 @@ export const se_CreateDomainNameCommand = async (input, context) => {
178
134
  securityPolicy: [],
179
135
  tags: (_) => _json(_),
180
136
  }));
181
- return new __HttpRequest({
182
- protocol,
183
- hostname,
184
- port,
185
- method: "POST",
186
- headers,
187
- path: resolvedPath,
188
- body,
189
- });
137
+ b.m("POST").h(headers).b(body);
138
+ return b.build();
190
139
  };
191
140
  export const se_CreateModelCommand = async (input, context) => {
192
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
141
+ const b = rb(input, context);
193
142
  const headers = {
194
143
  "content-type": "application/json",
195
144
  };
196
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/models";
197
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
145
+ b.bp("/restapis/{restApiId}/models");
146
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
198
147
  let body;
199
148
  body = JSON.stringify(take(input, {
200
149
  contentType: [],
@@ -202,68 +151,46 @@ export const se_CreateModelCommand = async (input, context) => {
202
151
  name: [],
203
152
  schema: [],
204
153
  }));
205
- return new __HttpRequest({
206
- protocol,
207
- hostname,
208
- port,
209
- method: "POST",
210
- headers,
211
- path: resolvedPath,
212
- body,
213
- });
154
+ b.m("POST").h(headers).b(body);
155
+ return b.build();
214
156
  };
215
157
  export const se_CreateRequestValidatorCommand = async (input, context) => {
216
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
158
+ const b = rb(input, context);
217
159
  const headers = {
218
160
  "content-type": "application/json",
219
161
  };
220
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/requestvalidators";
221
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
162
+ b.bp("/restapis/{restApiId}/requestvalidators");
163
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
222
164
  let body;
223
165
  body = JSON.stringify(take(input, {
224
166
  name: [],
225
167
  validateRequestBody: [],
226
168
  validateRequestParameters: [],
227
169
  }));
228
- return new __HttpRequest({
229
- protocol,
230
- hostname,
231
- port,
232
- method: "POST",
233
- headers,
234
- path: resolvedPath,
235
- body,
236
- });
170
+ b.m("POST").h(headers).b(body);
171
+ return b.build();
237
172
  };
238
173
  export const se_CreateResourceCommand = async (input, context) => {
239
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
174
+ const b = rb(input, context);
240
175
  const headers = {
241
176
  "content-type": "application/json",
242
177
  };
243
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
244
- "/restapis/{restApiId}/resources/{parentId}";
245
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
246
- resolvedPath = __resolvedPath(resolvedPath, input, "parentId", () => input.parentId, "{parentId}", false);
178
+ b.bp("/restapis/{restApiId}/resources/{parentId}");
179
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
180
+ b.p("parentId", () => input.parentId, "{parentId}", false);
247
181
  let body;
248
182
  body = JSON.stringify(take(input, {
249
183
  pathPart: [],
250
184
  }));
251
- return new __HttpRequest({
252
- protocol,
253
- hostname,
254
- port,
255
- method: "POST",
256
- headers,
257
- path: resolvedPath,
258
- body,
259
- });
185
+ b.m("POST").h(headers).b(body);
186
+ return b.build();
260
187
  };
261
188
  export const se_CreateRestApiCommand = async (input, context) => {
262
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
189
+ const b = rb(input, context);
263
190
  const headers = {
264
191
  "content-type": "application/json",
265
192
  };
266
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis";
193
+ b.bp("/restapis");
267
194
  let body;
268
195
  body = JSON.stringify(take(input, {
269
196
  apiKeySource: [],
@@ -278,23 +205,16 @@ export const se_CreateRestApiCommand = async (input, context) => {
278
205
  tags: (_) => _json(_),
279
206
  version: [],
280
207
  }));
281
- return new __HttpRequest({
282
- protocol,
283
- hostname,
284
- port,
285
- method: "POST",
286
- headers,
287
- path: resolvedPath,
288
- body,
289
- });
208
+ b.m("POST").h(headers).b(body);
209
+ return b.build();
290
210
  };
291
211
  export const se_CreateStageCommand = async (input, context) => {
292
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
212
+ const b = rb(input, context);
293
213
  const headers = {
294
214
  "content-type": "application/json",
295
215
  };
296
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/stages";
297
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
216
+ b.bp("/restapis/{restApiId}/stages");
217
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
298
218
  let body;
299
219
  body = JSON.stringify(take(input, {
300
220
  cacheClusterEnabled: [],
@@ -308,22 +228,15 @@ export const se_CreateStageCommand = async (input, context) => {
308
228
  tracingEnabled: [],
309
229
  variables: (_) => _json(_),
310
230
  }));
311
- return new __HttpRequest({
312
- protocol,
313
- hostname,
314
- port,
315
- method: "POST",
316
- headers,
317
- path: resolvedPath,
318
- body,
319
- });
231
+ b.m("POST").h(headers).b(body);
232
+ return b.build();
320
233
  };
321
234
  export const se_CreateUsagePlanCommand = async (input, context) => {
322
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
235
+ const b = rb(input, context);
323
236
  const headers = {
324
237
  "content-type": "application/json",
325
238
  };
326
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans";
239
+ b.bp("/usageplans");
327
240
  let body;
328
241
  body = JSON.stringify(take(input, {
329
242
  apiStages: (_) => se_ListOfApiStage(_, context),
@@ -333,44 +246,30 @@ export const se_CreateUsagePlanCommand = async (input, context) => {
333
246
  tags: (_) => _json(_),
334
247
  throttle: (_) => se_ThrottleSettings(_, context),
335
248
  }));
336
- return new __HttpRequest({
337
- protocol,
338
- hostname,
339
- port,
340
- method: "POST",
341
- headers,
342
- path: resolvedPath,
343
- body,
344
- });
249
+ b.m("POST").h(headers).b(body);
250
+ return b.build();
345
251
  };
346
252
  export const se_CreateUsagePlanKeyCommand = async (input, context) => {
347
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
253
+ const b = rb(input, context);
348
254
  const headers = {
349
255
  "content-type": "application/json",
350
256
  };
351
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans/{usagePlanId}/keys";
352
- resolvedPath = __resolvedPath(resolvedPath, input, "usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
257
+ b.bp("/usageplans/{usagePlanId}/keys");
258
+ b.p("usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
353
259
  let body;
354
260
  body = JSON.stringify(take(input, {
355
261
  keyId: [],
356
262
  keyType: [],
357
263
  }));
358
- return new __HttpRequest({
359
- protocol,
360
- hostname,
361
- port,
362
- method: "POST",
363
- headers,
364
- path: resolvedPath,
365
- body,
366
- });
264
+ b.m("POST").h(headers).b(body);
265
+ return b.build();
367
266
  };
368
267
  export const se_CreateVpcLinkCommand = async (input, context) => {
369
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
268
+ const b = rb(input, context);
370
269
  const headers = {
371
270
  "content-type": "application/json",
372
271
  };
373
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/vpclinks";
272
+ b.bp("/vpclinks");
374
273
  let body;
375
274
  body = JSON.stringify(take(input, {
376
275
  description: [],
@@ -378,1467 +277,880 @@ export const se_CreateVpcLinkCommand = async (input, context) => {
378
277
  tags: (_) => _json(_),
379
278
  targetArns: (_) => _json(_),
380
279
  }));
381
- return new __HttpRequest({
382
- protocol,
383
- hostname,
384
- port,
385
- method: "POST",
386
- headers,
387
- path: resolvedPath,
388
- body,
389
- });
280
+ b.m("POST").h(headers).b(body);
281
+ return b.build();
390
282
  };
391
283
  export const se_DeleteApiKeyCommand = async (input, context) => {
392
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
284
+ const b = rb(input, context);
393
285
  const headers = {};
394
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/apikeys/{apiKey}";
395
- resolvedPath = __resolvedPath(resolvedPath, input, "apiKey", () => input.apiKey, "{apiKey}", false);
286
+ b.bp("/apikeys/{apiKey}");
287
+ b.p("apiKey", () => input.apiKey, "{apiKey}", false);
396
288
  let body;
397
- return new __HttpRequest({
398
- protocol,
399
- hostname,
400
- port,
401
- method: "DELETE",
402
- headers,
403
- path: resolvedPath,
404
- body,
405
- });
289
+ b.m("DELETE").h(headers).b(body);
290
+ return b.build();
406
291
  };
407
292
  export const se_DeleteAuthorizerCommand = async (input, context) => {
408
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
293
+ const b = rb(input, context);
409
294
  const headers = {};
410
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
411
- "/restapis/{restApiId}/authorizers/{authorizerId}";
412
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
413
- resolvedPath = __resolvedPath(resolvedPath, input, "authorizerId", () => input.authorizerId, "{authorizerId}", false);
295
+ b.bp("/restapis/{restApiId}/authorizers/{authorizerId}");
296
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
297
+ b.p("authorizerId", () => input.authorizerId, "{authorizerId}", false);
414
298
  let body;
415
- return new __HttpRequest({
416
- protocol,
417
- hostname,
418
- port,
419
- method: "DELETE",
420
- headers,
421
- path: resolvedPath,
422
- body,
423
- });
299
+ b.m("DELETE").h(headers).b(body);
300
+ return b.build();
424
301
  };
425
302
  export const se_DeleteBasePathMappingCommand = async (input, context) => {
426
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
303
+ const b = rb(input, context);
427
304
  const headers = {};
428
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
429
- "/domainnames/{domainName}/basepathmappings/{basePath}";
430
- resolvedPath = __resolvedPath(resolvedPath, input, "domainName", () => input.domainName, "{domainName}", false);
431
- resolvedPath = __resolvedPath(resolvedPath, input, "basePath", () => input.basePath, "{basePath}", false);
305
+ b.bp("/domainnames/{domainName}/basepathmappings/{basePath}");
306
+ b.p("domainName", () => input.domainName, "{domainName}", false);
307
+ b.p("basePath", () => input.basePath, "{basePath}", false);
432
308
  let body;
433
- return new __HttpRequest({
434
- protocol,
435
- hostname,
436
- port,
437
- method: "DELETE",
438
- headers,
439
- path: resolvedPath,
440
- body,
441
- });
309
+ b.m("DELETE").h(headers).b(body);
310
+ return b.build();
442
311
  };
443
312
  export const se_DeleteClientCertificateCommand = async (input, context) => {
444
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
313
+ const b = rb(input, context);
445
314
  const headers = {};
446
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/clientcertificates/{clientCertificateId}";
447
- resolvedPath = __resolvedPath(resolvedPath, input, "clientCertificateId", () => input.clientCertificateId, "{clientCertificateId}", false);
315
+ b.bp("/clientcertificates/{clientCertificateId}");
316
+ b.p("clientCertificateId", () => input.clientCertificateId, "{clientCertificateId}", false);
448
317
  let body;
449
- return new __HttpRequest({
450
- protocol,
451
- hostname,
452
- port,
453
- method: "DELETE",
454
- headers,
455
- path: resolvedPath,
456
- body,
457
- });
318
+ b.m("DELETE").h(headers).b(body);
319
+ return b.build();
458
320
  };
459
321
  export const se_DeleteDeploymentCommand = async (input, context) => {
460
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
322
+ const b = rb(input, context);
461
323
  const headers = {};
462
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
463
- "/restapis/{restApiId}/deployments/{deploymentId}";
464
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
465
- resolvedPath = __resolvedPath(resolvedPath, input, "deploymentId", () => input.deploymentId, "{deploymentId}", false);
324
+ b.bp("/restapis/{restApiId}/deployments/{deploymentId}");
325
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
326
+ b.p("deploymentId", () => input.deploymentId, "{deploymentId}", false);
466
327
  let body;
467
- return new __HttpRequest({
468
- protocol,
469
- hostname,
470
- port,
471
- method: "DELETE",
472
- headers,
473
- path: resolvedPath,
474
- body,
475
- });
328
+ b.m("DELETE").h(headers).b(body);
329
+ return b.build();
476
330
  };
477
331
  export const se_DeleteDocumentationPartCommand = async (input, context) => {
478
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
332
+ const b = rb(input, context);
479
333
  const headers = {};
480
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
481
- "/restapis/{restApiId}/documentation/parts/{documentationPartId}";
482
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
483
- resolvedPath = __resolvedPath(resolvedPath, input, "documentationPartId", () => input.documentationPartId, "{documentationPartId}", false);
334
+ b.bp("/restapis/{restApiId}/documentation/parts/{documentationPartId}");
335
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
336
+ b.p("documentationPartId", () => input.documentationPartId, "{documentationPartId}", false);
484
337
  let body;
485
- return new __HttpRequest({
486
- protocol,
487
- hostname,
488
- port,
489
- method: "DELETE",
490
- headers,
491
- path: resolvedPath,
492
- body,
493
- });
338
+ b.m("DELETE").h(headers).b(body);
339
+ return b.build();
494
340
  };
495
341
  export const se_DeleteDocumentationVersionCommand = async (input, context) => {
496
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
342
+ const b = rb(input, context);
497
343
  const headers = {};
498
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
499
- "/restapis/{restApiId}/documentation/versions/{documentationVersion}";
500
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
501
- resolvedPath = __resolvedPath(resolvedPath, input, "documentationVersion", () => input.documentationVersion, "{documentationVersion}", false);
344
+ b.bp("/restapis/{restApiId}/documentation/versions/{documentationVersion}");
345
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
346
+ b.p("documentationVersion", () => input.documentationVersion, "{documentationVersion}", false);
502
347
  let body;
503
- return new __HttpRequest({
504
- protocol,
505
- hostname,
506
- port,
507
- method: "DELETE",
508
- headers,
509
- path: resolvedPath,
510
- body,
511
- });
348
+ b.m("DELETE").h(headers).b(body);
349
+ return b.build();
512
350
  };
513
351
  export const se_DeleteDomainNameCommand = async (input, context) => {
514
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
352
+ const b = rb(input, context);
515
353
  const headers = {};
516
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/domainnames/{domainName}";
517
- resolvedPath = __resolvedPath(resolvedPath, input, "domainName", () => input.domainName, "{domainName}", false);
354
+ b.bp("/domainnames/{domainName}");
355
+ b.p("domainName", () => input.domainName, "{domainName}", false);
518
356
  let body;
519
- return new __HttpRequest({
520
- protocol,
521
- hostname,
522
- port,
523
- method: "DELETE",
524
- headers,
525
- path: resolvedPath,
526
- body,
527
- });
357
+ b.m("DELETE").h(headers).b(body);
358
+ return b.build();
528
359
  };
529
360
  export const se_DeleteGatewayResponseCommand = async (input, context) => {
530
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
361
+ const b = rb(input, context);
531
362
  const headers = {};
532
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
533
- "/restapis/{restApiId}/gatewayresponses/{responseType}";
534
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
535
- resolvedPath = __resolvedPath(resolvedPath, input, "responseType", () => input.responseType, "{responseType}", false);
363
+ b.bp("/restapis/{restApiId}/gatewayresponses/{responseType}");
364
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
365
+ b.p("responseType", () => input.responseType, "{responseType}", false);
536
366
  let body;
537
- return new __HttpRequest({
538
- protocol,
539
- hostname,
540
- port,
541
- method: "DELETE",
542
- headers,
543
- path: resolvedPath,
544
- body,
545
- });
367
+ b.m("DELETE").h(headers).b(body);
368
+ return b.build();
546
369
  };
547
370
  export const se_DeleteIntegrationCommand = async (input, context) => {
548
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
371
+ const b = rb(input, context);
549
372
  const headers = {};
550
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
551
- "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration";
552
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
553
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
554
- resolvedPath = __resolvedPath(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
373
+ b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration");
374
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
375
+ b.p("resourceId", () => input.resourceId, "{resourceId}", false);
376
+ b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
555
377
  let body;
556
- return new __HttpRequest({
557
- protocol,
558
- hostname,
559
- port,
560
- method: "DELETE",
561
- headers,
562
- path: resolvedPath,
563
- body,
564
- });
378
+ b.m("DELETE").h(headers).b(body);
379
+ return b.build();
565
380
  };
566
381
  export const se_DeleteIntegrationResponseCommand = async (input, context) => {
567
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
382
+ const b = rb(input, context);
568
383
  const headers = {};
569
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
570
- "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration/responses/{statusCode}";
571
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
572
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
573
- resolvedPath = __resolvedPath(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
574
- resolvedPath = __resolvedPath(resolvedPath, input, "statusCode", () => input.statusCode, "{statusCode}", false);
384
+ b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration/responses/{statusCode}");
385
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
386
+ b.p("resourceId", () => input.resourceId, "{resourceId}", false);
387
+ b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
388
+ b.p("statusCode", () => input.statusCode, "{statusCode}", false);
575
389
  let body;
576
- return new __HttpRequest({
577
- protocol,
578
- hostname,
579
- port,
580
- method: "DELETE",
581
- headers,
582
- path: resolvedPath,
583
- body,
584
- });
390
+ b.m("DELETE").h(headers).b(body);
391
+ return b.build();
585
392
  };
586
393
  export const se_DeleteMethodCommand = async (input, context) => {
587
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
394
+ const b = rb(input, context);
588
395
  const headers = {};
589
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
590
- "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}";
591
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
592
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
593
- resolvedPath = __resolvedPath(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
396
+ b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}");
397
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
398
+ b.p("resourceId", () => input.resourceId, "{resourceId}", false);
399
+ b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
594
400
  let body;
595
- return new __HttpRequest({
596
- protocol,
597
- hostname,
598
- port,
599
- method: "DELETE",
600
- headers,
601
- path: resolvedPath,
602
- body,
603
- });
401
+ b.m("DELETE").h(headers).b(body);
402
+ return b.build();
604
403
  };
605
404
  export const se_DeleteMethodResponseCommand = async (input, context) => {
606
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
405
+ const b = rb(input, context);
607
406
  const headers = {};
608
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
609
- "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/responses/{statusCode}";
610
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
611
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
612
- resolvedPath = __resolvedPath(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
613
- resolvedPath = __resolvedPath(resolvedPath, input, "statusCode", () => input.statusCode, "{statusCode}", false);
407
+ b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/responses/{statusCode}");
408
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
409
+ b.p("resourceId", () => input.resourceId, "{resourceId}", false);
410
+ b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
411
+ b.p("statusCode", () => input.statusCode, "{statusCode}", false);
614
412
  let body;
615
- return new __HttpRequest({
616
- protocol,
617
- hostname,
618
- port,
619
- method: "DELETE",
620
- headers,
621
- path: resolvedPath,
622
- body,
623
- });
413
+ b.m("DELETE").h(headers).b(body);
414
+ return b.build();
624
415
  };
625
416
  export const se_DeleteModelCommand = async (input, context) => {
626
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
417
+ const b = rb(input, context);
627
418
  const headers = {};
628
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/models/{modelName}";
629
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
630
- resolvedPath = __resolvedPath(resolvedPath, input, "modelName", () => input.modelName, "{modelName}", false);
419
+ b.bp("/restapis/{restApiId}/models/{modelName}");
420
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
421
+ b.p("modelName", () => input.modelName, "{modelName}", false);
631
422
  let body;
632
- return new __HttpRequest({
633
- protocol,
634
- hostname,
635
- port,
636
- method: "DELETE",
637
- headers,
638
- path: resolvedPath,
639
- body,
640
- });
423
+ b.m("DELETE").h(headers).b(body);
424
+ return b.build();
641
425
  };
642
426
  export const se_DeleteRequestValidatorCommand = async (input, context) => {
643
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
427
+ const b = rb(input, context);
644
428
  const headers = {};
645
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
646
- "/restapis/{restApiId}/requestvalidators/{requestValidatorId}";
647
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
648
- resolvedPath = __resolvedPath(resolvedPath, input, "requestValidatorId", () => input.requestValidatorId, "{requestValidatorId}", false);
429
+ b.bp("/restapis/{restApiId}/requestvalidators/{requestValidatorId}");
430
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
431
+ b.p("requestValidatorId", () => input.requestValidatorId, "{requestValidatorId}", false);
649
432
  let body;
650
- return new __HttpRequest({
651
- protocol,
652
- hostname,
653
- port,
654
- method: "DELETE",
655
- headers,
656
- path: resolvedPath,
657
- body,
658
- });
433
+ b.m("DELETE").h(headers).b(body);
434
+ return b.build();
659
435
  };
660
436
  export const se_DeleteResourceCommand = async (input, context) => {
661
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
437
+ const b = rb(input, context);
662
438
  const headers = {};
663
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
664
- "/restapis/{restApiId}/resources/{resourceId}";
665
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
666
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
439
+ b.bp("/restapis/{restApiId}/resources/{resourceId}");
440
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
441
+ b.p("resourceId", () => input.resourceId, "{resourceId}", false);
667
442
  let body;
668
- return new __HttpRequest({
669
- protocol,
670
- hostname,
671
- port,
672
- method: "DELETE",
673
- headers,
674
- path: resolvedPath,
675
- body,
676
- });
443
+ b.m("DELETE").h(headers).b(body);
444
+ return b.build();
677
445
  };
678
446
  export const se_DeleteRestApiCommand = async (input, context) => {
679
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
447
+ const b = rb(input, context);
680
448
  const headers = {};
681
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}";
682
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
449
+ b.bp("/restapis/{restApiId}");
450
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
683
451
  let body;
684
- return new __HttpRequest({
685
- protocol,
686
- hostname,
687
- port,
688
- method: "DELETE",
689
- headers,
690
- path: resolvedPath,
691
- body,
692
- });
452
+ b.m("DELETE").h(headers).b(body);
453
+ return b.build();
693
454
  };
694
455
  export const se_DeleteStageCommand = async (input, context) => {
695
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
456
+ const b = rb(input, context);
696
457
  const headers = {};
697
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/stages/{stageName}";
698
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
699
- resolvedPath = __resolvedPath(resolvedPath, input, "stageName", () => input.stageName, "{stageName}", false);
458
+ b.bp("/restapis/{restApiId}/stages/{stageName}");
459
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
460
+ b.p("stageName", () => input.stageName, "{stageName}", false);
700
461
  let body;
701
- return new __HttpRequest({
702
- protocol,
703
- hostname,
704
- port,
705
- method: "DELETE",
706
- headers,
707
- path: resolvedPath,
708
- body,
709
- });
462
+ b.m("DELETE").h(headers).b(body);
463
+ return b.build();
710
464
  };
711
465
  export const se_DeleteUsagePlanCommand = async (input, context) => {
712
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
466
+ const b = rb(input, context);
713
467
  const headers = {};
714
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans/{usagePlanId}";
715
- resolvedPath = __resolvedPath(resolvedPath, input, "usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
468
+ b.bp("/usageplans/{usagePlanId}");
469
+ b.p("usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
716
470
  let body;
717
- return new __HttpRequest({
718
- protocol,
719
- hostname,
720
- port,
721
- method: "DELETE",
722
- headers,
723
- path: resolvedPath,
724
- body,
725
- });
471
+ b.m("DELETE").h(headers).b(body);
472
+ return b.build();
726
473
  };
727
474
  export const se_DeleteUsagePlanKeyCommand = async (input, context) => {
728
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
475
+ const b = rb(input, context);
729
476
  const headers = {};
730
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans/{usagePlanId}/keys/{keyId}";
731
- resolvedPath = __resolvedPath(resolvedPath, input, "usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
732
- resolvedPath = __resolvedPath(resolvedPath, input, "keyId", () => input.keyId, "{keyId}", false);
477
+ b.bp("/usageplans/{usagePlanId}/keys/{keyId}");
478
+ b.p("usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
479
+ b.p("keyId", () => input.keyId, "{keyId}", false);
733
480
  let body;
734
- return new __HttpRequest({
735
- protocol,
736
- hostname,
737
- port,
738
- method: "DELETE",
739
- headers,
740
- path: resolvedPath,
741
- body,
742
- });
481
+ b.m("DELETE").h(headers).b(body);
482
+ return b.build();
743
483
  };
744
484
  export const se_DeleteVpcLinkCommand = async (input, context) => {
745
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
485
+ const b = rb(input, context);
746
486
  const headers = {};
747
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/vpclinks/{vpcLinkId}";
748
- resolvedPath = __resolvedPath(resolvedPath, input, "vpcLinkId", () => input.vpcLinkId, "{vpcLinkId}", false);
487
+ b.bp("/vpclinks/{vpcLinkId}");
488
+ b.p("vpcLinkId", () => input.vpcLinkId, "{vpcLinkId}", false);
749
489
  let body;
750
- return new __HttpRequest({
751
- protocol,
752
- hostname,
753
- port,
754
- method: "DELETE",
755
- headers,
756
- path: resolvedPath,
757
- body,
758
- });
490
+ b.m("DELETE").h(headers).b(body);
491
+ return b.build();
759
492
  };
760
493
  export const se_FlushStageAuthorizersCacheCommand = async (input, context) => {
761
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
494
+ const b = rb(input, context);
762
495
  const headers = {};
763
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
764
- "/restapis/{restApiId}/stages/{stageName}/cache/authorizers";
765
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
766
- resolvedPath = __resolvedPath(resolvedPath, input, "stageName", () => input.stageName, "{stageName}", false);
496
+ b.bp("/restapis/{restApiId}/stages/{stageName}/cache/authorizers");
497
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
498
+ b.p("stageName", () => input.stageName, "{stageName}", false);
767
499
  let body;
768
- return new __HttpRequest({
769
- protocol,
770
- hostname,
771
- port,
772
- method: "DELETE",
773
- headers,
774
- path: resolvedPath,
775
- body,
776
- });
500
+ b.m("DELETE").h(headers).b(body);
501
+ return b.build();
777
502
  };
778
503
  export const se_FlushStageCacheCommand = async (input, context) => {
779
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
504
+ const b = rb(input, context);
780
505
  const headers = {};
781
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
782
- "/restapis/{restApiId}/stages/{stageName}/cache/data";
783
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
784
- resolvedPath = __resolvedPath(resolvedPath, input, "stageName", () => input.stageName, "{stageName}", false);
506
+ b.bp("/restapis/{restApiId}/stages/{stageName}/cache/data");
507
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
508
+ b.p("stageName", () => input.stageName, "{stageName}", false);
785
509
  let body;
786
- return new __HttpRequest({
787
- protocol,
788
- hostname,
789
- port,
790
- method: "DELETE",
791
- headers,
792
- path: resolvedPath,
793
- body,
794
- });
510
+ b.m("DELETE").h(headers).b(body);
511
+ return b.build();
795
512
  };
796
513
  export const se_GenerateClientCertificateCommand = async (input, context) => {
797
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
514
+ const b = rb(input, context);
798
515
  const headers = {
799
516
  "content-type": "application/json",
800
517
  };
801
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/clientcertificates";
518
+ b.bp("/clientcertificates");
802
519
  let body;
803
520
  body = JSON.stringify(take(input, {
804
521
  description: [],
805
522
  tags: (_) => _json(_),
806
523
  }));
807
- return new __HttpRequest({
808
- protocol,
809
- hostname,
810
- port,
811
- method: "POST",
812
- headers,
813
- path: resolvedPath,
814
- body,
815
- });
524
+ b.m("POST").h(headers).b(body);
525
+ return b.build();
816
526
  };
817
527
  export const se_GetAccountCommand = async (input, context) => {
818
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
528
+ const b = rb(input, context);
819
529
  const headers = {
820
530
  "content-type": "application/json",
821
531
  };
822
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/account";
532
+ b.bp("/account");
823
533
  let body;
824
534
  body = "";
825
- return new __HttpRequest({
826
- protocol,
827
- hostname,
828
- port,
829
- method: "GET",
830
- headers,
831
- path: resolvedPath,
832
- body,
833
- });
535
+ b.m("GET").h(headers).b(body);
536
+ return b.build();
834
537
  };
835
538
  export const se_GetApiKeyCommand = async (input, context) => {
836
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
539
+ const b = rb(input, context);
837
540
  const headers = {};
838
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/apikeys/{apiKey}";
839
- resolvedPath = __resolvedPath(resolvedPath, input, "apiKey", () => input.apiKey, "{apiKey}", false);
541
+ b.bp("/apikeys/{apiKey}");
542
+ b.p("apiKey", () => input.apiKey, "{apiKey}", false);
840
543
  const query = map({
841
- includeValue: [() => input.includeValue !== void 0, () => input.includeValue.toString()],
544
+ [_iV]: [() => input.includeValue !== void 0, () => input[_iV].toString()],
842
545
  });
843
546
  let body;
844
- return new __HttpRequest({
845
- protocol,
846
- hostname,
847
- port,
848
- method: "GET",
849
- headers,
850
- path: resolvedPath,
851
- query,
852
- body,
853
- });
547
+ b.m("GET").h(headers).q(query).b(body);
548
+ return b.build();
854
549
  };
855
550
  export const se_GetApiKeysCommand = async (input, context) => {
856
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
551
+ const b = rb(input, context);
857
552
  const headers = {};
858
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/apikeys";
553
+ b.bp("/apikeys");
859
554
  const query = map({
860
- position: [, input.position],
861
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
862
- name: [, input.nameQuery],
863
- customerId: [, input.customerId],
864
- includeValues: [() => input.includeValues !== void 0, () => input.includeValues.toString()],
555
+ [_p]: [, input[_p]],
556
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
557
+ [_n]: [, input[_nQ]],
558
+ [_cI]: [, input[_cI]],
559
+ [_iVn]: [() => input.includeValues !== void 0, () => input[_iVn].toString()],
865
560
  });
866
561
  let body;
867
- return new __HttpRequest({
868
- protocol,
869
- hostname,
870
- port,
871
- method: "GET",
872
- headers,
873
- path: resolvedPath,
874
- query,
875
- body,
876
- });
562
+ b.m("GET").h(headers).q(query).b(body);
563
+ return b.build();
877
564
  };
878
565
  export const se_GetAuthorizerCommand = async (input, context) => {
879
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
566
+ const b = rb(input, context);
880
567
  const headers = {};
881
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
882
- "/restapis/{restApiId}/authorizers/{authorizerId}";
883
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
884
- resolvedPath = __resolvedPath(resolvedPath, input, "authorizerId", () => input.authorizerId, "{authorizerId}", false);
568
+ b.bp("/restapis/{restApiId}/authorizers/{authorizerId}");
569
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
570
+ b.p("authorizerId", () => input.authorizerId, "{authorizerId}", false);
885
571
  let body;
886
- return new __HttpRequest({
887
- protocol,
888
- hostname,
889
- port,
890
- method: "GET",
891
- headers,
892
- path: resolvedPath,
893
- body,
894
- });
572
+ b.m("GET").h(headers).b(body);
573
+ return b.build();
895
574
  };
896
575
  export const se_GetAuthorizersCommand = async (input, context) => {
897
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
576
+ const b = rb(input, context);
898
577
  const headers = {};
899
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/authorizers";
900
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
578
+ b.bp("/restapis/{restApiId}/authorizers");
579
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
901
580
  const query = map({
902
- position: [, input.position],
903
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
581
+ [_p]: [, input[_p]],
582
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
904
583
  });
905
584
  let body;
906
- return new __HttpRequest({
907
- protocol,
908
- hostname,
909
- port,
910
- method: "GET",
911
- headers,
912
- path: resolvedPath,
913
- query,
914
- body,
915
- });
585
+ b.m("GET").h(headers).q(query).b(body);
586
+ return b.build();
916
587
  };
917
588
  export const se_GetBasePathMappingCommand = async (input, context) => {
918
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
589
+ const b = rb(input, context);
919
590
  const headers = {};
920
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
921
- "/domainnames/{domainName}/basepathmappings/{basePath}";
922
- resolvedPath = __resolvedPath(resolvedPath, input, "domainName", () => input.domainName, "{domainName}", false);
923
- resolvedPath = __resolvedPath(resolvedPath, input, "basePath", () => input.basePath, "{basePath}", false);
591
+ b.bp("/domainnames/{domainName}/basepathmappings/{basePath}");
592
+ b.p("domainName", () => input.domainName, "{domainName}", false);
593
+ b.p("basePath", () => input.basePath, "{basePath}", false);
924
594
  let body;
925
- return new __HttpRequest({
926
- protocol,
927
- hostname,
928
- port,
929
- method: "GET",
930
- headers,
931
- path: resolvedPath,
932
- body,
933
- });
595
+ b.m("GET").h(headers).b(body);
596
+ return b.build();
934
597
  };
935
598
  export const se_GetBasePathMappingsCommand = async (input, context) => {
936
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
599
+ const b = rb(input, context);
937
600
  const headers = {};
938
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
939
- "/domainnames/{domainName}/basepathmappings";
940
- resolvedPath = __resolvedPath(resolvedPath, input, "domainName", () => input.domainName, "{domainName}", false);
601
+ b.bp("/domainnames/{domainName}/basepathmappings");
602
+ b.p("domainName", () => input.domainName, "{domainName}", false);
941
603
  const query = map({
942
- position: [, input.position],
943
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
604
+ [_p]: [, input[_p]],
605
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
944
606
  });
945
607
  let body;
946
- return new __HttpRequest({
947
- protocol,
948
- hostname,
949
- port,
950
- method: "GET",
951
- headers,
952
- path: resolvedPath,
953
- query,
954
- body,
955
- });
608
+ b.m("GET").h(headers).q(query).b(body);
609
+ return b.build();
956
610
  };
957
611
  export const se_GetClientCertificateCommand = async (input, context) => {
958
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
612
+ const b = rb(input, context);
959
613
  const headers = {};
960
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/clientcertificates/{clientCertificateId}";
961
- resolvedPath = __resolvedPath(resolvedPath, input, "clientCertificateId", () => input.clientCertificateId, "{clientCertificateId}", false);
614
+ b.bp("/clientcertificates/{clientCertificateId}");
615
+ b.p("clientCertificateId", () => input.clientCertificateId, "{clientCertificateId}", false);
962
616
  let body;
963
- return new __HttpRequest({
964
- protocol,
965
- hostname,
966
- port,
967
- method: "GET",
968
- headers,
969
- path: resolvedPath,
970
- body,
971
- });
617
+ b.m("GET").h(headers).b(body);
618
+ return b.build();
972
619
  };
973
620
  export const se_GetClientCertificatesCommand = async (input, context) => {
974
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
621
+ const b = rb(input, context);
975
622
  const headers = {};
976
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/clientcertificates";
623
+ b.bp("/clientcertificates");
977
624
  const query = map({
978
- position: [, input.position],
979
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
625
+ [_p]: [, input[_p]],
626
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
980
627
  });
981
628
  let body;
982
- return new __HttpRequest({
983
- protocol,
984
- hostname,
985
- port,
986
- method: "GET",
987
- headers,
988
- path: resolvedPath,
989
- query,
990
- body,
991
- });
629
+ b.m("GET").h(headers).q(query).b(body);
630
+ return b.build();
992
631
  };
993
632
  export const se_GetDeploymentCommand = async (input, context) => {
994
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
633
+ const b = rb(input, context);
995
634
  const headers = {};
996
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
997
- "/restapis/{restApiId}/deployments/{deploymentId}";
998
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
999
- resolvedPath = __resolvedPath(resolvedPath, input, "deploymentId", () => input.deploymentId, "{deploymentId}", false);
635
+ b.bp("/restapis/{restApiId}/deployments/{deploymentId}");
636
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
637
+ b.p("deploymentId", () => input.deploymentId, "{deploymentId}", false);
1000
638
  const query = map({
1001
- embed: [() => input.embed !== void 0, () => (input.embed || []).map((_entry) => _entry)],
639
+ [_e]: [() => input.embed !== void 0, () => (input[_e] || []).map((_entry) => _entry)],
1002
640
  });
1003
641
  let body;
1004
- return new __HttpRequest({
1005
- protocol,
1006
- hostname,
1007
- port,
1008
- method: "GET",
1009
- headers,
1010
- path: resolvedPath,
1011
- query,
1012
- body,
1013
- });
642
+ b.m("GET").h(headers).q(query).b(body);
643
+ return b.build();
1014
644
  };
1015
645
  export const se_GetDeploymentsCommand = async (input, context) => {
1016
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
646
+ const b = rb(input, context);
1017
647
  const headers = {};
1018
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/deployments";
1019
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
648
+ b.bp("/restapis/{restApiId}/deployments");
649
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1020
650
  const query = map({
1021
- position: [, input.position],
1022
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
651
+ [_p]: [, input[_p]],
652
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
1023
653
  });
1024
654
  let body;
1025
- return new __HttpRequest({
1026
- protocol,
1027
- hostname,
1028
- port,
1029
- method: "GET",
1030
- headers,
1031
- path: resolvedPath,
1032
- query,
1033
- body,
1034
- });
655
+ b.m("GET").h(headers).q(query).b(body);
656
+ return b.build();
1035
657
  };
1036
658
  export const se_GetDocumentationPartCommand = async (input, context) => {
1037
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
659
+ const b = rb(input, context);
1038
660
  const headers = {};
1039
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1040
- "/restapis/{restApiId}/documentation/parts/{documentationPartId}";
1041
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
1042
- resolvedPath = __resolvedPath(resolvedPath, input, "documentationPartId", () => input.documentationPartId, "{documentationPartId}", false);
661
+ b.bp("/restapis/{restApiId}/documentation/parts/{documentationPartId}");
662
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
663
+ b.p("documentationPartId", () => input.documentationPartId, "{documentationPartId}", false);
1043
664
  let body;
1044
- return new __HttpRequest({
1045
- protocol,
1046
- hostname,
1047
- port,
1048
- method: "GET",
1049
- headers,
1050
- path: resolvedPath,
1051
- body,
1052
- });
665
+ b.m("GET").h(headers).b(body);
666
+ return b.build();
1053
667
  };
1054
668
  export const se_GetDocumentationPartsCommand = async (input, context) => {
1055
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
669
+ const b = rb(input, context);
1056
670
  const headers = {};
1057
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/documentation/parts";
1058
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
671
+ b.bp("/restapis/{restApiId}/documentation/parts");
672
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1059
673
  const query = map({
1060
- type: [, input.type],
1061
- name: [, input.nameQuery],
1062
- path: [, input.path],
1063
- position: [, input.position],
1064
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
1065
- locationStatus: [, input.locationStatus],
674
+ [_t]: [, input[_t]],
675
+ [_n]: [, input[_nQ]],
676
+ [_pa]: [, input[_pa]],
677
+ [_p]: [, input[_p]],
678
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
679
+ [_lS]: [, input[_lS]],
1066
680
  });
1067
681
  let body;
1068
- return new __HttpRequest({
1069
- protocol,
1070
- hostname,
1071
- port,
1072
- method: "GET",
1073
- headers,
1074
- path: resolvedPath,
1075
- query,
1076
- body,
1077
- });
682
+ b.m("GET").h(headers).q(query).b(body);
683
+ return b.build();
1078
684
  };
1079
685
  export const se_GetDocumentationVersionCommand = async (input, context) => {
1080
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
686
+ const b = rb(input, context);
1081
687
  const headers = {};
1082
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1083
- "/restapis/{restApiId}/documentation/versions/{documentationVersion}";
1084
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
1085
- resolvedPath = __resolvedPath(resolvedPath, input, "documentationVersion", () => input.documentationVersion, "{documentationVersion}", false);
688
+ b.bp("/restapis/{restApiId}/documentation/versions/{documentationVersion}");
689
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
690
+ b.p("documentationVersion", () => input.documentationVersion, "{documentationVersion}", false);
1086
691
  let body;
1087
- return new __HttpRequest({
1088
- protocol,
1089
- hostname,
1090
- port,
1091
- method: "GET",
1092
- headers,
1093
- path: resolvedPath,
1094
- body,
1095
- });
692
+ b.m("GET").h(headers).b(body);
693
+ return b.build();
1096
694
  };
1097
695
  export const se_GetDocumentationVersionsCommand = async (input, context) => {
1098
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
696
+ const b = rb(input, context);
1099
697
  const headers = {};
1100
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1101
- "/restapis/{restApiId}/documentation/versions";
1102
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
698
+ b.bp("/restapis/{restApiId}/documentation/versions");
699
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1103
700
  const query = map({
1104
- position: [, input.position],
1105
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
701
+ [_p]: [, input[_p]],
702
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
1106
703
  });
1107
704
  let body;
1108
- return new __HttpRequest({
1109
- protocol,
1110
- hostname,
1111
- port,
1112
- method: "GET",
1113
- headers,
1114
- path: resolvedPath,
1115
- query,
1116
- body,
1117
- });
705
+ b.m("GET").h(headers).q(query).b(body);
706
+ return b.build();
1118
707
  };
1119
708
  export const se_GetDomainNameCommand = async (input, context) => {
1120
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
709
+ const b = rb(input, context);
1121
710
  const headers = {};
1122
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/domainnames/{domainName}";
1123
- resolvedPath = __resolvedPath(resolvedPath, input, "domainName", () => input.domainName, "{domainName}", false);
711
+ b.bp("/domainnames/{domainName}");
712
+ b.p("domainName", () => input.domainName, "{domainName}", false);
1124
713
  let body;
1125
- return new __HttpRequest({
1126
- protocol,
1127
- hostname,
1128
- port,
1129
- method: "GET",
1130
- headers,
1131
- path: resolvedPath,
1132
- body,
1133
- });
714
+ b.m("GET").h(headers).b(body);
715
+ return b.build();
1134
716
  };
1135
717
  export const se_GetDomainNamesCommand = async (input, context) => {
1136
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
718
+ const b = rb(input, context);
1137
719
  const headers = {};
1138
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/domainnames";
720
+ b.bp("/domainnames");
1139
721
  const query = map({
1140
- position: [, input.position],
1141
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
722
+ [_p]: [, input[_p]],
723
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
1142
724
  });
1143
725
  let body;
1144
- return new __HttpRequest({
1145
- protocol,
1146
- hostname,
1147
- port,
1148
- method: "GET",
1149
- headers,
1150
- path: resolvedPath,
1151
- query,
1152
- body,
1153
- });
726
+ b.m("GET").h(headers).q(query).b(body);
727
+ return b.build();
1154
728
  };
1155
729
  export const se_GetExportCommand = async (input, context) => {
1156
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
730
+ const b = rb(input, context);
1157
731
  const headers = map({}, isSerializableHeaderValue, {
1158
- accept: input.accepts,
732
+ [_ac]: input[_a],
1159
733
  });
1160
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1161
- "/restapis/{restApiId}/stages/{stageName}/exports/{exportType}";
1162
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
1163
- resolvedPath = __resolvedPath(resolvedPath, input, "stageName", () => input.stageName, "{stageName}", false);
1164
- resolvedPath = __resolvedPath(resolvedPath, input, "exportType", () => input.exportType, "{exportType}", false);
734
+ b.bp("/restapis/{restApiId}/stages/{stageName}/exports/{exportType}");
735
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
736
+ b.p("stageName", () => input.stageName, "{stageName}", false);
737
+ b.p("exportType", () => input.exportType, "{exportType}", false);
1165
738
  const query = map({
1166
739
  ...convertMap(input.parameters),
1167
740
  });
1168
741
  let body;
1169
- return new __HttpRequest({
1170
- protocol,
1171
- hostname,
1172
- port,
1173
- method: "GET",
1174
- headers,
1175
- path: resolvedPath,
1176
- query,
1177
- body,
1178
- });
742
+ b.m("GET").h(headers).q(query).b(body);
743
+ return b.build();
1179
744
  };
1180
745
  export const se_GetGatewayResponseCommand = async (input, context) => {
1181
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
746
+ const b = rb(input, context);
1182
747
  const headers = {};
1183
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1184
- "/restapis/{restApiId}/gatewayresponses/{responseType}";
1185
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
1186
- resolvedPath = __resolvedPath(resolvedPath, input, "responseType", () => input.responseType, "{responseType}", false);
748
+ b.bp("/restapis/{restApiId}/gatewayresponses/{responseType}");
749
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
750
+ b.p("responseType", () => input.responseType, "{responseType}", false);
1187
751
  let body;
1188
- return new __HttpRequest({
1189
- protocol,
1190
- hostname,
1191
- port,
1192
- method: "GET",
1193
- headers,
1194
- path: resolvedPath,
1195
- body,
1196
- });
752
+ b.m("GET").h(headers).b(body);
753
+ return b.build();
1197
754
  };
1198
755
  export const se_GetGatewayResponsesCommand = async (input, context) => {
1199
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
756
+ const b = rb(input, context);
1200
757
  const headers = {};
1201
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/gatewayresponses";
1202
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
758
+ b.bp("/restapis/{restApiId}/gatewayresponses");
759
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1203
760
  const query = map({
1204
- position: [, input.position],
1205
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
761
+ [_p]: [, input[_p]],
762
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
1206
763
  });
1207
764
  let body;
1208
- return new __HttpRequest({
1209
- protocol,
1210
- hostname,
1211
- port,
1212
- method: "GET",
1213
- headers,
1214
- path: resolvedPath,
1215
- query,
1216
- body,
1217
- });
765
+ b.m("GET").h(headers).q(query).b(body);
766
+ return b.build();
1218
767
  };
1219
768
  export const se_GetIntegrationCommand = async (input, context) => {
1220
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
769
+ const b = rb(input, context);
1221
770
  const headers = {};
1222
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1223
- "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration";
1224
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
1225
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
1226
- resolvedPath = __resolvedPath(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
771
+ b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration");
772
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
773
+ b.p("resourceId", () => input.resourceId, "{resourceId}", false);
774
+ b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
1227
775
  let body;
1228
- return new __HttpRequest({
1229
- protocol,
1230
- hostname,
1231
- port,
1232
- method: "GET",
1233
- headers,
1234
- path: resolvedPath,
1235
- body,
1236
- });
776
+ b.m("GET").h(headers).b(body);
777
+ return b.build();
1237
778
  };
1238
779
  export const se_GetIntegrationResponseCommand = async (input, context) => {
1239
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
780
+ const b = rb(input, context);
1240
781
  const headers = {};
1241
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1242
- "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration/responses/{statusCode}";
1243
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
1244
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
1245
- resolvedPath = __resolvedPath(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
1246
- resolvedPath = __resolvedPath(resolvedPath, input, "statusCode", () => input.statusCode, "{statusCode}", false);
782
+ b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration/responses/{statusCode}");
783
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
784
+ b.p("resourceId", () => input.resourceId, "{resourceId}", false);
785
+ b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
786
+ b.p("statusCode", () => input.statusCode, "{statusCode}", false);
1247
787
  let body;
1248
- return new __HttpRequest({
1249
- protocol,
1250
- hostname,
1251
- port,
1252
- method: "GET",
1253
- headers,
1254
- path: resolvedPath,
1255
- body,
1256
- });
788
+ b.m("GET").h(headers).b(body);
789
+ return b.build();
1257
790
  };
1258
791
  export const se_GetMethodCommand = async (input, context) => {
1259
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
792
+ const b = rb(input, context);
1260
793
  const headers = {};
1261
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1262
- "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}";
1263
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
1264
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
1265
- resolvedPath = __resolvedPath(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
794
+ b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}");
795
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
796
+ b.p("resourceId", () => input.resourceId, "{resourceId}", false);
797
+ b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
1266
798
  let body;
1267
- return new __HttpRequest({
1268
- protocol,
1269
- hostname,
1270
- port,
1271
- method: "GET",
1272
- headers,
1273
- path: resolvedPath,
1274
- body,
1275
- });
799
+ b.m("GET").h(headers).b(body);
800
+ return b.build();
1276
801
  };
1277
802
  export const se_GetMethodResponseCommand = async (input, context) => {
1278
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
803
+ const b = rb(input, context);
1279
804
  const headers = {};
1280
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1281
- "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/responses/{statusCode}";
1282
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
1283
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
1284
- resolvedPath = __resolvedPath(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
1285
- resolvedPath = __resolvedPath(resolvedPath, input, "statusCode", () => input.statusCode, "{statusCode}", false);
805
+ b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/responses/{statusCode}");
806
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
807
+ b.p("resourceId", () => input.resourceId, "{resourceId}", false);
808
+ b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
809
+ b.p("statusCode", () => input.statusCode, "{statusCode}", false);
1286
810
  let body;
1287
- return new __HttpRequest({
1288
- protocol,
1289
- hostname,
1290
- port,
1291
- method: "GET",
1292
- headers,
1293
- path: resolvedPath,
1294
- body,
1295
- });
811
+ b.m("GET").h(headers).b(body);
812
+ return b.build();
1296
813
  };
1297
814
  export const se_GetModelCommand = async (input, context) => {
1298
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
815
+ const b = rb(input, context);
1299
816
  const headers = {};
1300
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/models/{modelName}";
1301
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
1302
- resolvedPath = __resolvedPath(resolvedPath, input, "modelName", () => input.modelName, "{modelName}", false);
817
+ b.bp("/restapis/{restApiId}/models/{modelName}");
818
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
819
+ b.p("modelName", () => input.modelName, "{modelName}", false);
1303
820
  const query = map({
1304
- flatten: [() => input.flatten !== void 0, () => input.flatten.toString()],
821
+ [_f]: [() => input.flatten !== void 0, () => input[_f].toString()],
1305
822
  });
1306
823
  let body;
1307
- return new __HttpRequest({
1308
- protocol,
1309
- hostname,
1310
- port,
1311
- method: "GET",
1312
- headers,
1313
- path: resolvedPath,
1314
- query,
1315
- body,
1316
- });
824
+ b.m("GET").h(headers).q(query).b(body);
825
+ return b.build();
1317
826
  };
1318
827
  export const se_GetModelsCommand = async (input, context) => {
1319
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
828
+ const b = rb(input, context);
1320
829
  const headers = {};
1321
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/models";
1322
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
830
+ b.bp("/restapis/{restApiId}/models");
831
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1323
832
  const query = map({
1324
- position: [, input.position],
1325
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
833
+ [_p]: [, input[_p]],
834
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
1326
835
  });
1327
836
  let body;
1328
- return new __HttpRequest({
1329
- protocol,
1330
- hostname,
1331
- port,
1332
- method: "GET",
1333
- headers,
1334
- path: resolvedPath,
1335
- query,
1336
- body,
1337
- });
837
+ b.m("GET").h(headers).q(query).b(body);
838
+ return b.build();
1338
839
  };
1339
840
  export const se_GetModelTemplateCommand = async (input, context) => {
1340
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
841
+ const b = rb(input, context);
1341
842
  const headers = {};
1342
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1343
- "/restapis/{restApiId}/models/{modelName}/default_template";
1344
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
1345
- resolvedPath = __resolvedPath(resolvedPath, input, "modelName", () => input.modelName, "{modelName}", false);
843
+ b.bp("/restapis/{restApiId}/models/{modelName}/default_template");
844
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
845
+ b.p("modelName", () => input.modelName, "{modelName}", false);
1346
846
  let body;
1347
- return new __HttpRequest({
1348
- protocol,
1349
- hostname,
1350
- port,
1351
- method: "GET",
1352
- headers,
1353
- path: resolvedPath,
1354
- body,
1355
- });
847
+ b.m("GET").h(headers).b(body);
848
+ return b.build();
1356
849
  };
1357
850
  export const se_GetRequestValidatorCommand = async (input, context) => {
1358
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
851
+ const b = rb(input, context);
1359
852
  const headers = {};
1360
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1361
- "/restapis/{restApiId}/requestvalidators/{requestValidatorId}";
1362
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
1363
- resolvedPath = __resolvedPath(resolvedPath, input, "requestValidatorId", () => input.requestValidatorId, "{requestValidatorId}", false);
853
+ b.bp("/restapis/{restApiId}/requestvalidators/{requestValidatorId}");
854
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
855
+ b.p("requestValidatorId", () => input.requestValidatorId, "{requestValidatorId}", false);
1364
856
  let body;
1365
- return new __HttpRequest({
1366
- protocol,
1367
- hostname,
1368
- port,
1369
- method: "GET",
1370
- headers,
1371
- path: resolvedPath,
1372
- body,
1373
- });
857
+ b.m("GET").h(headers).b(body);
858
+ return b.build();
1374
859
  };
1375
860
  export const se_GetRequestValidatorsCommand = async (input, context) => {
1376
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
861
+ const b = rb(input, context);
1377
862
  const headers = {};
1378
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/requestvalidators";
1379
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
863
+ b.bp("/restapis/{restApiId}/requestvalidators");
864
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1380
865
  const query = map({
1381
- position: [, input.position],
1382
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
866
+ [_p]: [, input[_p]],
867
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
1383
868
  });
1384
869
  let body;
1385
- return new __HttpRequest({
1386
- protocol,
1387
- hostname,
1388
- port,
1389
- method: "GET",
1390
- headers,
1391
- path: resolvedPath,
1392
- query,
1393
- body,
1394
- });
870
+ b.m("GET").h(headers).q(query).b(body);
871
+ return b.build();
1395
872
  };
1396
873
  export const se_GetResourceCommand = async (input, context) => {
1397
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
874
+ const b = rb(input, context);
1398
875
  const headers = {};
1399
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1400
- "/restapis/{restApiId}/resources/{resourceId}";
1401
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
1402
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
876
+ b.bp("/restapis/{restApiId}/resources/{resourceId}");
877
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
878
+ b.p("resourceId", () => input.resourceId, "{resourceId}", false);
1403
879
  const query = map({
1404
- embed: [() => input.embed !== void 0, () => (input.embed || []).map((_entry) => _entry)],
880
+ [_e]: [() => input.embed !== void 0, () => (input[_e] || []).map((_entry) => _entry)],
1405
881
  });
1406
882
  let body;
1407
- return new __HttpRequest({
1408
- protocol,
1409
- hostname,
1410
- port,
1411
- method: "GET",
1412
- headers,
1413
- path: resolvedPath,
1414
- query,
1415
- body,
1416
- });
883
+ b.m("GET").h(headers).q(query).b(body);
884
+ return b.build();
1417
885
  };
1418
886
  export const se_GetResourcesCommand = async (input, context) => {
1419
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
887
+ const b = rb(input, context);
1420
888
  const headers = {};
1421
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/resources";
1422
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
889
+ b.bp("/restapis/{restApiId}/resources");
890
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1423
891
  const query = map({
1424
- position: [, input.position],
1425
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
1426
- embed: [() => input.embed !== void 0, () => (input.embed || []).map((_entry) => _entry)],
892
+ [_p]: [, input[_p]],
893
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
894
+ [_e]: [() => input.embed !== void 0, () => (input[_e] || []).map((_entry) => _entry)],
1427
895
  });
1428
896
  let body;
1429
- return new __HttpRequest({
1430
- protocol,
1431
- hostname,
1432
- port,
1433
- method: "GET",
1434
- headers,
1435
- path: resolvedPath,
1436
- query,
1437
- body,
1438
- });
897
+ b.m("GET").h(headers).q(query).b(body);
898
+ return b.build();
1439
899
  };
1440
900
  export const se_GetRestApiCommand = async (input, context) => {
1441
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
901
+ const b = rb(input, context);
1442
902
  const headers = {};
1443
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}";
1444
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
903
+ b.bp("/restapis/{restApiId}");
904
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1445
905
  let body;
1446
- return new __HttpRequest({
1447
- protocol,
1448
- hostname,
1449
- port,
1450
- method: "GET",
1451
- headers,
1452
- path: resolvedPath,
1453
- body,
1454
- });
906
+ b.m("GET").h(headers).b(body);
907
+ return b.build();
1455
908
  };
1456
909
  export const se_GetRestApisCommand = async (input, context) => {
1457
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
910
+ const b = rb(input, context);
1458
911
  const headers = {};
1459
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis";
912
+ b.bp("/restapis");
1460
913
  const query = map({
1461
- position: [, input.position],
1462
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
914
+ [_p]: [, input[_p]],
915
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
1463
916
  });
1464
917
  let body;
1465
- return new __HttpRequest({
1466
- protocol,
1467
- hostname,
1468
- port,
1469
- method: "GET",
1470
- headers,
1471
- path: resolvedPath,
1472
- query,
1473
- body,
1474
- });
918
+ b.m("GET").h(headers).q(query).b(body);
919
+ return b.build();
1475
920
  };
1476
921
  export const se_GetSdkCommand = async (input, context) => {
1477
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
922
+ const b = rb(input, context);
1478
923
  const headers = {};
1479
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1480
- "/restapis/{restApiId}/stages/{stageName}/sdks/{sdkType}";
1481
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
1482
- resolvedPath = __resolvedPath(resolvedPath, input, "stageName", () => input.stageName, "{stageName}", false);
1483
- resolvedPath = __resolvedPath(resolvedPath, input, "sdkType", () => input.sdkType, "{sdkType}", false);
924
+ b.bp("/restapis/{restApiId}/stages/{stageName}/sdks/{sdkType}");
925
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
926
+ b.p("stageName", () => input.stageName, "{stageName}", false);
927
+ b.p("sdkType", () => input.sdkType, "{sdkType}", false);
1484
928
  const query = map({
1485
929
  ...convertMap(input.parameters),
1486
930
  });
1487
931
  let body;
1488
- return new __HttpRequest({
1489
- protocol,
1490
- hostname,
1491
- port,
1492
- method: "GET",
1493
- headers,
1494
- path: resolvedPath,
1495
- query,
1496
- body,
1497
- });
932
+ b.m("GET").h(headers).q(query).b(body);
933
+ return b.build();
1498
934
  };
1499
935
  export const se_GetSdkTypeCommand = async (input, context) => {
1500
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
936
+ const b = rb(input, context);
1501
937
  const headers = {};
1502
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sdktypes/{id}";
1503
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
938
+ b.bp("/sdktypes/{id}");
939
+ b.p("id", () => input.id, "{id}", false);
1504
940
  let body;
1505
- return new __HttpRequest({
1506
- protocol,
1507
- hostname,
1508
- port,
1509
- method: "GET",
1510
- headers,
1511
- path: resolvedPath,
1512
- body,
1513
- });
941
+ b.m("GET").h(headers).b(body);
942
+ return b.build();
1514
943
  };
1515
944
  export const se_GetSdkTypesCommand = async (input, context) => {
1516
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
945
+ const b = rb(input, context);
1517
946
  const headers = {};
1518
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sdktypes";
947
+ b.bp("/sdktypes");
1519
948
  const query = map({
1520
- position: [, input.position],
1521
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
949
+ [_p]: [, input[_p]],
950
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
1522
951
  });
1523
952
  let body;
1524
- return new __HttpRequest({
1525
- protocol,
1526
- hostname,
1527
- port,
1528
- method: "GET",
1529
- headers,
1530
- path: resolvedPath,
1531
- query,
1532
- body,
1533
- });
953
+ b.m("GET").h(headers).q(query).b(body);
954
+ return b.build();
1534
955
  };
1535
956
  export const se_GetStageCommand = async (input, context) => {
1536
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
957
+ const b = rb(input, context);
1537
958
  const headers = {};
1538
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/stages/{stageName}";
1539
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
1540
- resolvedPath = __resolvedPath(resolvedPath, input, "stageName", () => input.stageName, "{stageName}", false);
959
+ b.bp("/restapis/{restApiId}/stages/{stageName}");
960
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
961
+ b.p("stageName", () => input.stageName, "{stageName}", false);
1541
962
  let body;
1542
- return new __HttpRequest({
1543
- protocol,
1544
- hostname,
1545
- port,
1546
- method: "GET",
1547
- headers,
1548
- path: resolvedPath,
1549
- body,
1550
- });
963
+ b.m("GET").h(headers).b(body);
964
+ return b.build();
1551
965
  };
1552
966
  export const se_GetStagesCommand = async (input, context) => {
1553
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
967
+ const b = rb(input, context);
1554
968
  const headers = {};
1555
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/stages";
1556
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
969
+ b.bp("/restapis/{restApiId}/stages");
970
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1557
971
  const query = map({
1558
- deploymentId: [, input.deploymentId],
972
+ [_dI]: [, input[_dI]],
1559
973
  });
1560
974
  let body;
1561
- return new __HttpRequest({
1562
- protocol,
1563
- hostname,
1564
- port,
1565
- method: "GET",
1566
- headers,
1567
- path: resolvedPath,
1568
- query,
1569
- body,
1570
- });
975
+ b.m("GET").h(headers).q(query).b(body);
976
+ return b.build();
1571
977
  };
1572
978
  export const se_GetTagsCommand = async (input, context) => {
1573
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
979
+ const b = rb(input, context);
1574
980
  const headers = {};
1575
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
1576
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
981
+ b.bp("/tags/{resourceArn}");
982
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
1577
983
  const query = map({
1578
- position: [, input.position],
1579
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
984
+ [_p]: [, input[_p]],
985
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
1580
986
  });
1581
987
  let body;
1582
- return new __HttpRequest({
1583
- protocol,
1584
- hostname,
1585
- port,
1586
- method: "GET",
1587
- headers,
1588
- path: resolvedPath,
1589
- query,
1590
- body,
1591
- });
988
+ b.m("GET").h(headers).q(query).b(body);
989
+ return b.build();
1592
990
  };
1593
991
  export const se_GetUsageCommand = async (input, context) => {
1594
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
992
+ const b = rb(input, context);
1595
993
  const headers = {};
1596
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans/{usagePlanId}/usage";
1597
- resolvedPath = __resolvedPath(resolvedPath, input, "usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
994
+ b.bp("/usageplans/{usagePlanId}/usage");
995
+ b.p("usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
1598
996
  const query = map({
1599
- keyId: [, input.keyId],
1600
- startDate: [, __expectNonNull(input.startDate, `startDate`)],
1601
- endDate: [, __expectNonNull(input.endDate, `endDate`)],
1602
- position: [, input.position],
1603
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
997
+ [_kI]: [, input[_kI]],
998
+ [_sD]: [, __expectNonNull(input[_sD], `startDate`)],
999
+ [_eD]: [, __expectNonNull(input[_eD], `endDate`)],
1000
+ [_p]: [, input[_p]],
1001
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
1604
1002
  });
1605
1003
  let body;
1606
- return new __HttpRequest({
1607
- protocol,
1608
- hostname,
1609
- port,
1610
- method: "GET",
1611
- headers,
1612
- path: resolvedPath,
1613
- query,
1614
- body,
1615
- });
1004
+ b.m("GET").h(headers).q(query).b(body);
1005
+ return b.build();
1616
1006
  };
1617
1007
  export const se_GetUsagePlanCommand = async (input, context) => {
1618
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1008
+ const b = rb(input, context);
1619
1009
  const headers = {};
1620
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans/{usagePlanId}";
1621
- resolvedPath = __resolvedPath(resolvedPath, input, "usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
1010
+ b.bp("/usageplans/{usagePlanId}");
1011
+ b.p("usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
1622
1012
  let body;
1623
- return new __HttpRequest({
1624
- protocol,
1625
- hostname,
1626
- port,
1627
- method: "GET",
1628
- headers,
1629
- path: resolvedPath,
1630
- body,
1631
- });
1013
+ b.m("GET").h(headers).b(body);
1014
+ return b.build();
1632
1015
  };
1633
1016
  export const se_GetUsagePlanKeyCommand = async (input, context) => {
1634
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1017
+ const b = rb(input, context);
1635
1018
  const headers = {};
1636
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans/{usagePlanId}/keys/{keyId}";
1637
- resolvedPath = __resolvedPath(resolvedPath, input, "usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
1638
- resolvedPath = __resolvedPath(resolvedPath, input, "keyId", () => input.keyId, "{keyId}", false);
1019
+ b.bp("/usageplans/{usagePlanId}/keys/{keyId}");
1020
+ b.p("usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
1021
+ b.p("keyId", () => input.keyId, "{keyId}", false);
1639
1022
  let body;
1640
- return new __HttpRequest({
1641
- protocol,
1642
- hostname,
1643
- port,
1644
- method: "GET",
1645
- headers,
1646
- path: resolvedPath,
1647
- body,
1648
- });
1023
+ b.m("GET").h(headers).b(body);
1024
+ return b.build();
1649
1025
  };
1650
1026
  export const se_GetUsagePlanKeysCommand = async (input, context) => {
1651
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1027
+ const b = rb(input, context);
1652
1028
  const headers = {};
1653
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans/{usagePlanId}/keys";
1654
- resolvedPath = __resolvedPath(resolvedPath, input, "usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
1029
+ b.bp("/usageplans/{usagePlanId}/keys");
1030
+ b.p("usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
1655
1031
  const query = map({
1656
- position: [, input.position],
1657
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
1658
- name: [, input.nameQuery],
1032
+ [_p]: [, input[_p]],
1033
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
1034
+ [_n]: [, input[_nQ]],
1659
1035
  });
1660
1036
  let body;
1661
- return new __HttpRequest({
1662
- protocol,
1663
- hostname,
1664
- port,
1665
- method: "GET",
1666
- headers,
1667
- path: resolvedPath,
1668
- query,
1669
- body,
1670
- });
1037
+ b.m("GET").h(headers).q(query).b(body);
1038
+ return b.build();
1671
1039
  };
1672
1040
  export const se_GetUsagePlansCommand = async (input, context) => {
1673
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1041
+ const b = rb(input, context);
1674
1042
  const headers = {};
1675
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans";
1043
+ b.bp("/usageplans");
1676
1044
  const query = map({
1677
- position: [, input.position],
1678
- keyId: [, input.keyId],
1679
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
1045
+ [_p]: [, input[_p]],
1046
+ [_kI]: [, input[_kI]],
1047
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
1680
1048
  });
1681
1049
  let body;
1682
- return new __HttpRequest({
1683
- protocol,
1684
- hostname,
1685
- port,
1686
- method: "GET",
1687
- headers,
1688
- path: resolvedPath,
1689
- query,
1690
- body,
1691
- });
1050
+ b.m("GET").h(headers).q(query).b(body);
1051
+ return b.build();
1692
1052
  };
1693
1053
  export const se_GetVpcLinkCommand = async (input, context) => {
1694
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1054
+ const b = rb(input, context);
1695
1055
  const headers = {};
1696
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/vpclinks/{vpcLinkId}";
1697
- resolvedPath = __resolvedPath(resolvedPath, input, "vpcLinkId", () => input.vpcLinkId, "{vpcLinkId}", false);
1056
+ b.bp("/vpclinks/{vpcLinkId}");
1057
+ b.p("vpcLinkId", () => input.vpcLinkId, "{vpcLinkId}", false);
1698
1058
  let body;
1699
- return new __HttpRequest({
1700
- protocol,
1701
- hostname,
1702
- port,
1703
- method: "GET",
1704
- headers,
1705
- path: resolvedPath,
1706
- body,
1707
- });
1059
+ b.m("GET").h(headers).b(body);
1060
+ return b.build();
1708
1061
  };
1709
1062
  export const se_GetVpcLinksCommand = async (input, context) => {
1710
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1063
+ const b = rb(input, context);
1711
1064
  const headers = {};
1712
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/vpclinks";
1065
+ b.bp("/vpclinks");
1713
1066
  const query = map({
1714
- position: [, input.position],
1715
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
1067
+ [_p]: [, input[_p]],
1068
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
1716
1069
  });
1717
1070
  let body;
1718
- return new __HttpRequest({
1719
- protocol,
1720
- hostname,
1721
- port,
1722
- method: "GET",
1723
- headers,
1724
- path: resolvedPath,
1725
- query,
1726
- body,
1727
- });
1071
+ b.m("GET").h(headers).q(query).b(body);
1072
+ return b.build();
1728
1073
  };
1729
1074
  export const se_ImportApiKeysCommand = async (input, context) => {
1730
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1075
+ const b = rb(input, context);
1731
1076
  const headers = {
1732
1077
  "content-type": "application/octet-stream",
1733
1078
  };
1734
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/apikeys";
1079
+ b.bp("/apikeys");
1735
1080
  const query = map({
1736
- mode: [, "import"],
1737
- format: [, __expectNonNull(input.format, `format`)],
1738
- failonwarnings: [() => input.failOnWarnings !== void 0, () => input.failOnWarnings.toString()],
1081
+ [_m]: [, "import"],
1082
+ [_fo]: [, __expectNonNull(input[_fo], `format`)],
1083
+ [_fa]: [() => input.failOnWarnings !== void 0, () => input[_fOW].toString()],
1739
1084
  });
1740
1085
  let body;
1741
1086
  if (input.body !== undefined) {
1742
1087
  body = input.body;
1743
1088
  }
1744
- return new __HttpRequest({
1745
- protocol,
1746
- hostname,
1747
- port,
1748
- method: "POST",
1749
- headers,
1750
- path: resolvedPath,
1751
- query,
1752
- body,
1753
- });
1089
+ b.m("POST").h(headers).q(query).b(body);
1090
+ return b.build();
1754
1091
  };
1755
1092
  export const se_ImportDocumentationPartsCommand = async (input, context) => {
1756
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1093
+ const b = rb(input, context);
1757
1094
  const headers = {
1758
1095
  "content-type": "application/octet-stream",
1759
1096
  };
1760
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/documentation/parts";
1761
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
1097
+ b.bp("/restapis/{restApiId}/documentation/parts");
1098
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1762
1099
  const query = map({
1763
- mode: [, input.mode],
1764
- failonwarnings: [() => input.failOnWarnings !== void 0, () => input.failOnWarnings.toString()],
1100
+ [_m]: [, input[_m]],
1101
+ [_fa]: [() => input.failOnWarnings !== void 0, () => input[_fOW].toString()],
1765
1102
  });
1766
1103
  let body;
1767
1104
  if (input.body !== undefined) {
1768
1105
  body = input.body;
1769
1106
  }
1770
- return new __HttpRequest({
1771
- protocol,
1772
- hostname,
1773
- port,
1774
- method: "PUT",
1775
- headers,
1776
- path: resolvedPath,
1777
- query,
1778
- body,
1779
- });
1107
+ b.m("PUT").h(headers).q(query).b(body);
1108
+ return b.build();
1780
1109
  };
1781
1110
  export const se_ImportRestApiCommand = async (input, context) => {
1782
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1111
+ const b = rb(input, context);
1783
1112
  const headers = {
1784
1113
  "content-type": "application/octet-stream",
1785
1114
  };
1786
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis";
1115
+ b.bp("/restapis");
1787
1116
  const query = map({
1788
- mode: [, "import"],
1117
+ [_m]: [, "import"],
1789
1118
  ...convertMap(input.parameters),
1790
- failonwarnings: [() => input.failOnWarnings !== void 0, () => input.failOnWarnings.toString()],
1119
+ [_fa]: [() => input.failOnWarnings !== void 0, () => input[_fOW].toString()],
1791
1120
  });
1792
1121
  let body;
1793
1122
  if (input.body !== undefined) {
1794
1123
  body = input.body;
1795
1124
  }
1796
- return new __HttpRequest({
1797
- protocol,
1798
- hostname,
1799
- port,
1800
- method: "POST",
1801
- headers,
1802
- path: resolvedPath,
1803
- query,
1804
- body,
1805
- });
1125
+ b.m("POST").h(headers).q(query).b(body);
1126
+ return b.build();
1806
1127
  };
1807
1128
  export const se_PutGatewayResponseCommand = async (input, context) => {
1808
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1129
+ const b = rb(input, context);
1809
1130
  const headers = {
1810
1131
  "content-type": "application/json",
1811
1132
  };
1812
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1813
- "/restapis/{restApiId}/gatewayresponses/{responseType}";
1814
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
1815
- resolvedPath = __resolvedPath(resolvedPath, input, "responseType", () => input.responseType, "{responseType}", false);
1133
+ b.bp("/restapis/{restApiId}/gatewayresponses/{responseType}");
1134
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1135
+ b.p("responseType", () => input.responseType, "{responseType}", false);
1816
1136
  let body;
1817
1137
  body = JSON.stringify(take(input, {
1818
1138
  responseParameters: (_) => _json(_),
1819
1139
  responseTemplates: (_) => _json(_),
1820
1140
  statusCode: [],
1821
1141
  }));
1822
- return new __HttpRequest({
1823
- protocol,
1824
- hostname,
1825
- port,
1826
- method: "PUT",
1827
- headers,
1828
- path: resolvedPath,
1829
- body,
1830
- });
1142
+ b.m("PUT").h(headers).b(body);
1143
+ return b.build();
1831
1144
  };
1832
1145
  export const se_PutIntegrationCommand = async (input, context) => {
1833
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1146
+ const b = rb(input, context);
1834
1147
  const headers = {
1835
1148
  "content-type": "application/json",
1836
1149
  };
1837
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1838
- "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration";
1839
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
1840
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
1841
- resolvedPath = __resolvedPath(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
1150
+ b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration");
1151
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1152
+ b.p("resourceId", () => input.resourceId, "{resourceId}", false);
1153
+ b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
1842
1154
  let body;
1843
1155
  body = JSON.stringify(take(input, {
1844
1156
  cacheKeyParameters: (_) => _json(_),
@@ -1856,27 +1168,19 @@ export const se_PutIntegrationCommand = async (input, context) => {
1856
1168
  type: [],
1857
1169
  uri: [],
1858
1170
  }));
1859
- return new __HttpRequest({
1860
- protocol,
1861
- hostname,
1862
- port,
1863
- method: "PUT",
1864
- headers,
1865
- path: resolvedPath,
1866
- body,
1867
- });
1171
+ b.m("PUT").h(headers).b(body);
1172
+ return b.build();
1868
1173
  };
1869
1174
  export const se_PutIntegrationResponseCommand = async (input, context) => {
1870
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1175
+ const b = rb(input, context);
1871
1176
  const headers = {
1872
1177
  "content-type": "application/json",
1873
1178
  };
1874
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1875
- "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration/responses/{statusCode}";
1876
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
1877
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
1878
- resolvedPath = __resolvedPath(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
1879
- resolvedPath = __resolvedPath(resolvedPath, input, "statusCode", () => input.statusCode, "{statusCode}", false);
1179
+ b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration/responses/{statusCode}");
1180
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1181
+ b.p("resourceId", () => input.resourceId, "{resourceId}", false);
1182
+ b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
1183
+ b.p("statusCode", () => input.statusCode, "{statusCode}", false);
1880
1184
  let body;
1881
1185
  body = JSON.stringify(take(input, {
1882
1186
  contentHandling: [],
@@ -1884,26 +1188,18 @@ export const se_PutIntegrationResponseCommand = async (input, context) => {
1884
1188
  responseTemplates: (_) => _json(_),
1885
1189
  selectionPattern: [],
1886
1190
  }));
1887
- return new __HttpRequest({
1888
- protocol,
1889
- hostname,
1890
- port,
1891
- method: "PUT",
1892
- headers,
1893
- path: resolvedPath,
1894
- body,
1895
- });
1191
+ b.m("PUT").h(headers).b(body);
1192
+ return b.build();
1896
1193
  };
1897
1194
  export const se_PutMethodCommand = async (input, context) => {
1898
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1195
+ const b = rb(input, context);
1899
1196
  const headers = {
1900
1197
  "content-type": "application/json",
1901
1198
  };
1902
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1903
- "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}";
1904
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
1905
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
1906
- resolvedPath = __resolvedPath(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
1199
+ b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}");
1200
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1201
+ b.p("resourceId", () => input.resourceId, "{resourceId}", false);
1202
+ b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
1907
1203
  let body;
1908
1204
  body = JSON.stringify(take(input, {
1909
1205
  apiKeyRequired: [],
@@ -1915,99 +1211,68 @@ export const se_PutMethodCommand = async (input, context) => {
1915
1211
  requestParameters: (_) => _json(_),
1916
1212
  requestValidatorId: [],
1917
1213
  }));
1918
- return new __HttpRequest({
1919
- protocol,
1920
- hostname,
1921
- port,
1922
- method: "PUT",
1923
- headers,
1924
- path: resolvedPath,
1925
- body,
1926
- });
1214
+ b.m("PUT").h(headers).b(body);
1215
+ return b.build();
1927
1216
  };
1928
1217
  export const se_PutMethodResponseCommand = async (input, context) => {
1929
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1218
+ const b = rb(input, context);
1930
1219
  const headers = {
1931
1220
  "content-type": "application/json",
1932
1221
  };
1933
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1934
- "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/responses/{statusCode}";
1935
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
1936
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
1937
- resolvedPath = __resolvedPath(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
1938
- resolvedPath = __resolvedPath(resolvedPath, input, "statusCode", () => input.statusCode, "{statusCode}", false);
1222
+ b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/responses/{statusCode}");
1223
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1224
+ b.p("resourceId", () => input.resourceId, "{resourceId}", false);
1225
+ b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
1226
+ b.p("statusCode", () => input.statusCode, "{statusCode}", false);
1939
1227
  let body;
1940
1228
  body = JSON.stringify(take(input, {
1941
1229
  responseModels: (_) => _json(_),
1942
1230
  responseParameters: (_) => _json(_),
1943
1231
  }));
1944
- return new __HttpRequest({
1945
- protocol,
1946
- hostname,
1947
- port,
1948
- method: "PUT",
1949
- headers,
1950
- path: resolvedPath,
1951
- body,
1952
- });
1232
+ b.m("PUT").h(headers).b(body);
1233
+ return b.build();
1953
1234
  };
1954
1235
  export const se_PutRestApiCommand = async (input, context) => {
1955
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1236
+ const b = rb(input, context);
1956
1237
  const headers = {
1957
1238
  "content-type": "application/octet-stream",
1958
1239
  };
1959
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}";
1960
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
1240
+ b.bp("/restapis/{restApiId}");
1241
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1961
1242
  const query = map({
1962
1243
  ...convertMap(input.parameters),
1963
- mode: [, input.mode],
1964
- failonwarnings: [() => input.failOnWarnings !== void 0, () => input.failOnWarnings.toString()],
1244
+ [_m]: [, input[_m]],
1245
+ [_fa]: [() => input.failOnWarnings !== void 0, () => input[_fOW].toString()],
1965
1246
  });
1966
1247
  let body;
1967
1248
  if (input.body !== undefined) {
1968
1249
  body = input.body;
1969
1250
  }
1970
- return new __HttpRequest({
1971
- protocol,
1972
- hostname,
1973
- port,
1974
- method: "PUT",
1975
- headers,
1976
- path: resolvedPath,
1977
- query,
1978
- body,
1979
- });
1251
+ b.m("PUT").h(headers).q(query).b(body);
1252
+ return b.build();
1980
1253
  };
1981
1254
  export const se_TagResourceCommand = async (input, context) => {
1982
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1255
+ const b = rb(input, context);
1983
1256
  const headers = {
1984
1257
  "content-type": "application/json",
1985
1258
  };
1986
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
1987
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
1259
+ b.bp("/tags/{resourceArn}");
1260
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
1988
1261
  let body;
1989
1262
  body = JSON.stringify(take(input, {
1990
1263
  tags: (_) => _json(_),
1991
1264
  }));
1992
- return new __HttpRequest({
1993
- protocol,
1994
- hostname,
1995
- port,
1996
- method: "PUT",
1997
- headers,
1998
- path: resolvedPath,
1999
- body,
2000
- });
1265
+ b.m("PUT").h(headers).b(body);
1266
+ return b.build();
2001
1267
  };
2002
1268
  export const se_TestInvokeAuthorizerCommand = async (input, context) => {
2003
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1269
+ const b = rb(input, context);
2004
1270
  const headers = {
2005
1271
  "content-type": "application/json",
2006
1272
  };
2007
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2008
- "/restapis/{restApiId}/authorizers/{authorizerId}";
2009
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
2010
- resolvedPath = __resolvedPath(resolvedPath, input, "authorizerId", () => input.authorizerId, "{authorizerId}", false);
1273
+ b.bp("/restapis/{restApiId}/authorizers/{authorizerId}");
1274
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1275
+ b.p("authorizerId", () => input.authorizerId, "{authorizerId}", false);
2011
1276
  let body;
2012
1277
  body = JSON.stringify(take(input, {
2013
1278
  additionalContext: (_) => _json(_),
@@ -2017,26 +1282,18 @@ export const se_TestInvokeAuthorizerCommand = async (input, context) => {
2017
1282
  pathWithQueryString: [],
2018
1283
  stageVariables: (_) => _json(_),
2019
1284
  }));
2020
- return new __HttpRequest({
2021
- protocol,
2022
- hostname,
2023
- port,
2024
- method: "POST",
2025
- headers,
2026
- path: resolvedPath,
2027
- body,
2028
- });
1285
+ b.m("POST").h(headers).b(body);
1286
+ return b.build();
2029
1287
  };
2030
1288
  export const se_TestInvokeMethodCommand = async (input, context) => {
2031
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1289
+ const b = rb(input, context);
2032
1290
  const headers = {
2033
1291
  "content-type": "application/json",
2034
1292
  };
2035
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2036
- "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}";
2037
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
2038
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
2039
- resolvedPath = __resolvedPath(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
1293
+ b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}");
1294
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1295
+ b.p("resourceId", () => input.resourceId, "{resourceId}", false);
1296
+ b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
2040
1297
  let body;
2041
1298
  body = JSON.stringify(take(input, {
2042
1299
  body: [],
@@ -2046,533 +1303,351 @@ export const se_TestInvokeMethodCommand = async (input, context) => {
2046
1303
  pathWithQueryString: [],
2047
1304
  stageVariables: (_) => _json(_),
2048
1305
  }));
2049
- return new __HttpRequest({
2050
- protocol,
2051
- hostname,
2052
- port,
2053
- method: "POST",
2054
- headers,
2055
- path: resolvedPath,
2056
- body,
2057
- });
1306
+ b.m("POST").h(headers).b(body);
1307
+ return b.build();
2058
1308
  };
2059
1309
  export const se_UntagResourceCommand = async (input, context) => {
2060
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1310
+ const b = rb(input, context);
2061
1311
  const headers = {};
2062
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
2063
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
1312
+ b.bp("/tags/{resourceArn}");
1313
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
2064
1314
  const query = map({
2065
- tagKeys: [
1315
+ [_tK]: [
2066
1316
  __expectNonNull(input.tagKeys, `tagKeys`) != null,
2067
- () => (input.tagKeys || []).map((_entry) => _entry),
1317
+ () => (input[_tK] || []).map((_entry) => _entry),
2068
1318
  ],
2069
1319
  });
2070
1320
  let body;
2071
- return new __HttpRequest({
2072
- protocol,
2073
- hostname,
2074
- port,
2075
- method: "DELETE",
2076
- headers,
2077
- path: resolvedPath,
2078
- query,
2079
- body,
2080
- });
1321
+ b.m("DELETE").h(headers).q(query).b(body);
1322
+ return b.build();
2081
1323
  };
2082
1324
  export const se_UpdateAccountCommand = async (input, context) => {
2083
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1325
+ const b = rb(input, context);
2084
1326
  const headers = {
2085
1327
  "content-type": "application/json",
2086
1328
  };
2087
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/account";
1329
+ b.bp("/account");
2088
1330
  let body;
2089
1331
  body = JSON.stringify(take(input, {
2090
1332
  patchOperations: (_) => _json(_),
2091
1333
  }));
2092
- return new __HttpRequest({
2093
- protocol,
2094
- hostname,
2095
- port,
2096
- method: "PATCH",
2097
- headers,
2098
- path: resolvedPath,
2099
- body,
2100
- });
1334
+ b.m("PATCH").h(headers).b(body);
1335
+ return b.build();
2101
1336
  };
2102
1337
  export const se_UpdateApiKeyCommand = async (input, context) => {
2103
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1338
+ const b = rb(input, context);
2104
1339
  const headers = {
2105
1340
  "content-type": "application/json",
2106
1341
  };
2107
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/apikeys/{apiKey}";
2108
- resolvedPath = __resolvedPath(resolvedPath, input, "apiKey", () => input.apiKey, "{apiKey}", false);
1342
+ b.bp("/apikeys/{apiKey}");
1343
+ b.p("apiKey", () => input.apiKey, "{apiKey}", false);
2109
1344
  let body;
2110
1345
  body = JSON.stringify(take(input, {
2111
1346
  patchOperations: (_) => _json(_),
2112
1347
  }));
2113
- return new __HttpRequest({
2114
- protocol,
2115
- hostname,
2116
- port,
2117
- method: "PATCH",
2118
- headers,
2119
- path: resolvedPath,
2120
- body,
2121
- });
1348
+ b.m("PATCH").h(headers).b(body);
1349
+ return b.build();
2122
1350
  };
2123
1351
  export const se_UpdateAuthorizerCommand = async (input, context) => {
2124
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1352
+ const b = rb(input, context);
2125
1353
  const headers = {
2126
1354
  "content-type": "application/json",
2127
1355
  };
2128
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2129
- "/restapis/{restApiId}/authorizers/{authorizerId}";
2130
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
2131
- resolvedPath = __resolvedPath(resolvedPath, input, "authorizerId", () => input.authorizerId, "{authorizerId}", false);
1356
+ b.bp("/restapis/{restApiId}/authorizers/{authorizerId}");
1357
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1358
+ b.p("authorizerId", () => input.authorizerId, "{authorizerId}", false);
2132
1359
  let body;
2133
1360
  body = JSON.stringify(take(input, {
2134
1361
  patchOperations: (_) => _json(_),
2135
1362
  }));
2136
- return new __HttpRequest({
2137
- protocol,
2138
- hostname,
2139
- port,
2140
- method: "PATCH",
2141
- headers,
2142
- path: resolvedPath,
2143
- body,
2144
- });
1363
+ b.m("PATCH").h(headers).b(body);
1364
+ return b.build();
2145
1365
  };
2146
1366
  export const se_UpdateBasePathMappingCommand = async (input, context) => {
2147
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1367
+ const b = rb(input, context);
2148
1368
  const headers = {
2149
1369
  "content-type": "application/json",
2150
1370
  };
2151
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2152
- "/domainnames/{domainName}/basepathmappings/{basePath}";
2153
- resolvedPath = __resolvedPath(resolvedPath, input, "domainName", () => input.domainName, "{domainName}", false);
2154
- resolvedPath = __resolvedPath(resolvedPath, input, "basePath", () => input.basePath, "{basePath}", false);
1371
+ b.bp("/domainnames/{domainName}/basepathmappings/{basePath}");
1372
+ b.p("domainName", () => input.domainName, "{domainName}", false);
1373
+ b.p("basePath", () => input.basePath, "{basePath}", false);
2155
1374
  let body;
2156
1375
  body = JSON.stringify(take(input, {
2157
1376
  patchOperations: (_) => _json(_),
2158
1377
  }));
2159
- return new __HttpRequest({
2160
- protocol,
2161
- hostname,
2162
- port,
2163
- method: "PATCH",
2164
- headers,
2165
- path: resolvedPath,
2166
- body,
2167
- });
1378
+ b.m("PATCH").h(headers).b(body);
1379
+ return b.build();
2168
1380
  };
2169
1381
  export const se_UpdateClientCertificateCommand = async (input, context) => {
2170
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1382
+ const b = rb(input, context);
2171
1383
  const headers = {
2172
1384
  "content-type": "application/json",
2173
1385
  };
2174
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/clientcertificates/{clientCertificateId}";
2175
- resolvedPath = __resolvedPath(resolvedPath, input, "clientCertificateId", () => input.clientCertificateId, "{clientCertificateId}", false);
1386
+ b.bp("/clientcertificates/{clientCertificateId}");
1387
+ b.p("clientCertificateId", () => input.clientCertificateId, "{clientCertificateId}", false);
2176
1388
  let body;
2177
1389
  body = JSON.stringify(take(input, {
2178
1390
  patchOperations: (_) => _json(_),
2179
1391
  }));
2180
- return new __HttpRequest({
2181
- protocol,
2182
- hostname,
2183
- port,
2184
- method: "PATCH",
2185
- headers,
2186
- path: resolvedPath,
2187
- body,
2188
- });
1392
+ b.m("PATCH").h(headers).b(body);
1393
+ return b.build();
2189
1394
  };
2190
1395
  export const se_UpdateDeploymentCommand = async (input, context) => {
2191
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1396
+ const b = rb(input, context);
2192
1397
  const headers = {
2193
1398
  "content-type": "application/json",
2194
1399
  };
2195
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2196
- "/restapis/{restApiId}/deployments/{deploymentId}";
2197
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
2198
- resolvedPath = __resolvedPath(resolvedPath, input, "deploymentId", () => input.deploymentId, "{deploymentId}", false);
1400
+ b.bp("/restapis/{restApiId}/deployments/{deploymentId}");
1401
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1402
+ b.p("deploymentId", () => input.deploymentId, "{deploymentId}", false);
2199
1403
  let body;
2200
1404
  body = JSON.stringify(take(input, {
2201
1405
  patchOperations: (_) => _json(_),
2202
1406
  }));
2203
- return new __HttpRequest({
2204
- protocol,
2205
- hostname,
2206
- port,
2207
- method: "PATCH",
2208
- headers,
2209
- path: resolvedPath,
2210
- body,
2211
- });
1407
+ b.m("PATCH").h(headers).b(body);
1408
+ return b.build();
2212
1409
  };
2213
1410
  export const se_UpdateDocumentationPartCommand = async (input, context) => {
2214
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1411
+ const b = rb(input, context);
2215
1412
  const headers = {
2216
1413
  "content-type": "application/json",
2217
1414
  };
2218
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2219
- "/restapis/{restApiId}/documentation/parts/{documentationPartId}";
2220
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
2221
- resolvedPath = __resolvedPath(resolvedPath, input, "documentationPartId", () => input.documentationPartId, "{documentationPartId}", false);
1415
+ b.bp("/restapis/{restApiId}/documentation/parts/{documentationPartId}");
1416
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1417
+ b.p("documentationPartId", () => input.documentationPartId, "{documentationPartId}", false);
2222
1418
  let body;
2223
1419
  body = JSON.stringify(take(input, {
2224
1420
  patchOperations: (_) => _json(_),
2225
1421
  }));
2226
- return new __HttpRequest({
2227
- protocol,
2228
- hostname,
2229
- port,
2230
- method: "PATCH",
2231
- headers,
2232
- path: resolvedPath,
2233
- body,
2234
- });
1422
+ b.m("PATCH").h(headers).b(body);
1423
+ return b.build();
2235
1424
  };
2236
1425
  export const se_UpdateDocumentationVersionCommand = async (input, context) => {
2237
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1426
+ const b = rb(input, context);
2238
1427
  const headers = {
2239
1428
  "content-type": "application/json",
2240
1429
  };
2241
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2242
- "/restapis/{restApiId}/documentation/versions/{documentationVersion}";
2243
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
2244
- resolvedPath = __resolvedPath(resolvedPath, input, "documentationVersion", () => input.documentationVersion, "{documentationVersion}", false);
1430
+ b.bp("/restapis/{restApiId}/documentation/versions/{documentationVersion}");
1431
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1432
+ b.p("documentationVersion", () => input.documentationVersion, "{documentationVersion}", false);
2245
1433
  let body;
2246
1434
  body = JSON.stringify(take(input, {
2247
1435
  patchOperations: (_) => _json(_),
2248
1436
  }));
2249
- return new __HttpRequest({
2250
- protocol,
2251
- hostname,
2252
- port,
2253
- method: "PATCH",
2254
- headers,
2255
- path: resolvedPath,
2256
- body,
2257
- });
1437
+ b.m("PATCH").h(headers).b(body);
1438
+ return b.build();
2258
1439
  };
2259
1440
  export const se_UpdateDomainNameCommand = async (input, context) => {
2260
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1441
+ const b = rb(input, context);
2261
1442
  const headers = {
2262
1443
  "content-type": "application/json",
2263
1444
  };
2264
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/domainnames/{domainName}";
2265
- resolvedPath = __resolvedPath(resolvedPath, input, "domainName", () => input.domainName, "{domainName}", false);
1445
+ b.bp("/domainnames/{domainName}");
1446
+ b.p("domainName", () => input.domainName, "{domainName}", false);
2266
1447
  let body;
2267
1448
  body = JSON.stringify(take(input, {
2268
1449
  patchOperations: (_) => _json(_),
2269
1450
  }));
2270
- return new __HttpRequest({
2271
- protocol,
2272
- hostname,
2273
- port,
2274
- method: "PATCH",
2275
- headers,
2276
- path: resolvedPath,
2277
- body,
2278
- });
1451
+ b.m("PATCH").h(headers).b(body);
1452
+ return b.build();
2279
1453
  };
2280
1454
  export const se_UpdateGatewayResponseCommand = async (input, context) => {
2281
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1455
+ const b = rb(input, context);
2282
1456
  const headers = {
2283
1457
  "content-type": "application/json",
2284
1458
  };
2285
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2286
- "/restapis/{restApiId}/gatewayresponses/{responseType}";
2287
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
2288
- resolvedPath = __resolvedPath(resolvedPath, input, "responseType", () => input.responseType, "{responseType}", false);
1459
+ b.bp("/restapis/{restApiId}/gatewayresponses/{responseType}");
1460
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1461
+ b.p("responseType", () => input.responseType, "{responseType}", false);
2289
1462
  let body;
2290
1463
  body = JSON.stringify(take(input, {
2291
1464
  patchOperations: (_) => _json(_),
2292
1465
  }));
2293
- return new __HttpRequest({
2294
- protocol,
2295
- hostname,
2296
- port,
2297
- method: "PATCH",
2298
- headers,
2299
- path: resolvedPath,
2300
- body,
2301
- });
1466
+ b.m("PATCH").h(headers).b(body);
1467
+ return b.build();
2302
1468
  };
2303
1469
  export const se_UpdateIntegrationCommand = async (input, context) => {
2304
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1470
+ const b = rb(input, context);
2305
1471
  const headers = {
2306
1472
  "content-type": "application/json",
2307
1473
  };
2308
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2309
- "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration";
2310
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
2311
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
2312
- resolvedPath = __resolvedPath(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
1474
+ b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration");
1475
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1476
+ b.p("resourceId", () => input.resourceId, "{resourceId}", false);
1477
+ b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
2313
1478
  let body;
2314
1479
  body = JSON.stringify(take(input, {
2315
1480
  patchOperations: (_) => _json(_),
2316
1481
  }));
2317
- return new __HttpRequest({
2318
- protocol,
2319
- hostname,
2320
- port,
2321
- method: "PATCH",
2322
- headers,
2323
- path: resolvedPath,
2324
- body,
2325
- });
1482
+ b.m("PATCH").h(headers).b(body);
1483
+ return b.build();
2326
1484
  };
2327
1485
  export const se_UpdateIntegrationResponseCommand = async (input, context) => {
2328
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1486
+ const b = rb(input, context);
2329
1487
  const headers = {
2330
1488
  "content-type": "application/json",
2331
1489
  };
2332
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2333
- "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration/responses/{statusCode}";
2334
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
2335
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
2336
- resolvedPath = __resolvedPath(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
2337
- resolvedPath = __resolvedPath(resolvedPath, input, "statusCode", () => input.statusCode, "{statusCode}", false);
1490
+ b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration/responses/{statusCode}");
1491
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1492
+ b.p("resourceId", () => input.resourceId, "{resourceId}", false);
1493
+ b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
1494
+ b.p("statusCode", () => input.statusCode, "{statusCode}", false);
2338
1495
  let body;
2339
1496
  body = JSON.stringify(take(input, {
2340
1497
  patchOperations: (_) => _json(_),
2341
1498
  }));
2342
- return new __HttpRequest({
2343
- protocol,
2344
- hostname,
2345
- port,
2346
- method: "PATCH",
2347
- headers,
2348
- path: resolvedPath,
2349
- body,
2350
- });
1499
+ b.m("PATCH").h(headers).b(body);
1500
+ return b.build();
2351
1501
  };
2352
1502
  export const se_UpdateMethodCommand = async (input, context) => {
2353
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1503
+ const b = rb(input, context);
2354
1504
  const headers = {
2355
1505
  "content-type": "application/json",
2356
1506
  };
2357
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2358
- "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}";
2359
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
2360
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
2361
- resolvedPath = __resolvedPath(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
1507
+ b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}");
1508
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1509
+ b.p("resourceId", () => input.resourceId, "{resourceId}", false);
1510
+ b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
2362
1511
  let body;
2363
1512
  body = JSON.stringify(take(input, {
2364
1513
  patchOperations: (_) => _json(_),
2365
1514
  }));
2366
- return new __HttpRequest({
2367
- protocol,
2368
- hostname,
2369
- port,
2370
- method: "PATCH",
2371
- headers,
2372
- path: resolvedPath,
2373
- body,
2374
- });
1515
+ b.m("PATCH").h(headers).b(body);
1516
+ return b.build();
2375
1517
  };
2376
1518
  export const se_UpdateMethodResponseCommand = async (input, context) => {
2377
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1519
+ const b = rb(input, context);
2378
1520
  const headers = {
2379
1521
  "content-type": "application/json",
2380
1522
  };
2381
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2382
- "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/responses/{statusCode}";
2383
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
2384
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
2385
- resolvedPath = __resolvedPath(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
2386
- resolvedPath = __resolvedPath(resolvedPath, input, "statusCode", () => input.statusCode, "{statusCode}", false);
1523
+ b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/responses/{statusCode}");
1524
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1525
+ b.p("resourceId", () => input.resourceId, "{resourceId}", false);
1526
+ b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
1527
+ b.p("statusCode", () => input.statusCode, "{statusCode}", false);
2387
1528
  let body;
2388
1529
  body = JSON.stringify(take(input, {
2389
1530
  patchOperations: (_) => _json(_),
2390
1531
  }));
2391
- return new __HttpRequest({
2392
- protocol,
2393
- hostname,
2394
- port,
2395
- method: "PATCH",
2396
- headers,
2397
- path: resolvedPath,
2398
- body,
2399
- });
1532
+ b.m("PATCH").h(headers).b(body);
1533
+ return b.build();
2400
1534
  };
2401
1535
  export const se_UpdateModelCommand = async (input, context) => {
2402
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1536
+ const b = rb(input, context);
2403
1537
  const headers = {
2404
1538
  "content-type": "application/json",
2405
1539
  };
2406
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/models/{modelName}";
2407
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
2408
- resolvedPath = __resolvedPath(resolvedPath, input, "modelName", () => input.modelName, "{modelName}", false);
1540
+ b.bp("/restapis/{restApiId}/models/{modelName}");
1541
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1542
+ b.p("modelName", () => input.modelName, "{modelName}", false);
2409
1543
  let body;
2410
1544
  body = JSON.stringify(take(input, {
2411
1545
  patchOperations: (_) => _json(_),
2412
1546
  }));
2413
- return new __HttpRequest({
2414
- protocol,
2415
- hostname,
2416
- port,
2417
- method: "PATCH",
2418
- headers,
2419
- path: resolvedPath,
2420
- body,
2421
- });
1547
+ b.m("PATCH").h(headers).b(body);
1548
+ return b.build();
2422
1549
  };
2423
1550
  export const se_UpdateRequestValidatorCommand = async (input, context) => {
2424
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1551
+ const b = rb(input, context);
2425
1552
  const headers = {
2426
1553
  "content-type": "application/json",
2427
1554
  };
2428
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2429
- "/restapis/{restApiId}/requestvalidators/{requestValidatorId}";
2430
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
2431
- resolvedPath = __resolvedPath(resolvedPath, input, "requestValidatorId", () => input.requestValidatorId, "{requestValidatorId}", false);
1555
+ b.bp("/restapis/{restApiId}/requestvalidators/{requestValidatorId}");
1556
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1557
+ b.p("requestValidatorId", () => input.requestValidatorId, "{requestValidatorId}", false);
2432
1558
  let body;
2433
1559
  body = JSON.stringify(take(input, {
2434
1560
  patchOperations: (_) => _json(_),
2435
1561
  }));
2436
- return new __HttpRequest({
2437
- protocol,
2438
- hostname,
2439
- port,
2440
- method: "PATCH",
2441
- headers,
2442
- path: resolvedPath,
2443
- body,
2444
- });
1562
+ b.m("PATCH").h(headers).b(body);
1563
+ return b.build();
2445
1564
  };
2446
1565
  export const se_UpdateResourceCommand = async (input, context) => {
2447
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1566
+ const b = rb(input, context);
2448
1567
  const headers = {
2449
1568
  "content-type": "application/json",
2450
1569
  };
2451
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2452
- "/restapis/{restApiId}/resources/{resourceId}";
2453
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
2454
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
1570
+ b.bp("/restapis/{restApiId}/resources/{resourceId}");
1571
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1572
+ b.p("resourceId", () => input.resourceId, "{resourceId}", false);
2455
1573
  let body;
2456
1574
  body = JSON.stringify(take(input, {
2457
1575
  patchOperations: (_) => _json(_),
2458
1576
  }));
2459
- return new __HttpRequest({
2460
- protocol,
2461
- hostname,
2462
- port,
2463
- method: "PATCH",
2464
- headers,
2465
- path: resolvedPath,
2466
- body,
2467
- });
1577
+ b.m("PATCH").h(headers).b(body);
1578
+ return b.build();
2468
1579
  };
2469
1580
  export const se_UpdateRestApiCommand = async (input, context) => {
2470
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1581
+ const b = rb(input, context);
2471
1582
  const headers = {
2472
1583
  "content-type": "application/json",
2473
1584
  };
2474
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}";
2475
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
1585
+ b.bp("/restapis/{restApiId}");
1586
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
2476
1587
  let body;
2477
1588
  body = JSON.stringify(take(input, {
2478
1589
  patchOperations: (_) => _json(_),
2479
1590
  }));
2480
- return new __HttpRequest({
2481
- protocol,
2482
- hostname,
2483
- port,
2484
- method: "PATCH",
2485
- headers,
2486
- path: resolvedPath,
2487
- body,
2488
- });
1591
+ b.m("PATCH").h(headers).b(body);
1592
+ return b.build();
2489
1593
  };
2490
1594
  export const se_UpdateStageCommand = async (input, context) => {
2491
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1595
+ const b = rb(input, context);
2492
1596
  const headers = {
2493
1597
  "content-type": "application/json",
2494
1598
  };
2495
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/stages/{stageName}";
2496
- resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
2497
- resolvedPath = __resolvedPath(resolvedPath, input, "stageName", () => input.stageName, "{stageName}", false);
1599
+ b.bp("/restapis/{restApiId}/stages/{stageName}");
1600
+ b.p("restApiId", () => input.restApiId, "{restApiId}", false);
1601
+ b.p("stageName", () => input.stageName, "{stageName}", false);
2498
1602
  let body;
2499
1603
  body = JSON.stringify(take(input, {
2500
1604
  patchOperations: (_) => _json(_),
2501
1605
  }));
2502
- return new __HttpRequest({
2503
- protocol,
2504
- hostname,
2505
- port,
2506
- method: "PATCH",
2507
- headers,
2508
- path: resolvedPath,
2509
- body,
2510
- });
1606
+ b.m("PATCH").h(headers).b(body);
1607
+ return b.build();
2511
1608
  };
2512
1609
  export const se_UpdateUsageCommand = async (input, context) => {
2513
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1610
+ const b = rb(input, context);
2514
1611
  const headers = {
2515
1612
  "content-type": "application/json",
2516
1613
  };
2517
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2518
- "/usageplans/{usagePlanId}/keys/{keyId}/usage";
2519
- resolvedPath = __resolvedPath(resolvedPath, input, "usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
2520
- resolvedPath = __resolvedPath(resolvedPath, input, "keyId", () => input.keyId, "{keyId}", false);
1614
+ b.bp("/usageplans/{usagePlanId}/keys/{keyId}/usage");
1615
+ b.p("usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
1616
+ b.p("keyId", () => input.keyId, "{keyId}", false);
2521
1617
  let body;
2522
1618
  body = JSON.stringify(take(input, {
2523
1619
  patchOperations: (_) => _json(_),
2524
1620
  }));
2525
- return new __HttpRequest({
2526
- protocol,
2527
- hostname,
2528
- port,
2529
- method: "PATCH",
2530
- headers,
2531
- path: resolvedPath,
2532
- body,
2533
- });
1621
+ b.m("PATCH").h(headers).b(body);
1622
+ return b.build();
2534
1623
  };
2535
1624
  export const se_UpdateUsagePlanCommand = async (input, context) => {
2536
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1625
+ const b = rb(input, context);
2537
1626
  const headers = {
2538
1627
  "content-type": "application/json",
2539
1628
  };
2540
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans/{usagePlanId}";
2541
- resolvedPath = __resolvedPath(resolvedPath, input, "usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
1629
+ b.bp("/usageplans/{usagePlanId}");
1630
+ b.p("usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
2542
1631
  let body;
2543
1632
  body = JSON.stringify(take(input, {
2544
1633
  patchOperations: (_) => _json(_),
2545
1634
  }));
2546
- return new __HttpRequest({
2547
- protocol,
2548
- hostname,
2549
- port,
2550
- method: "PATCH",
2551
- headers,
2552
- path: resolvedPath,
2553
- body,
2554
- });
1635
+ b.m("PATCH").h(headers).b(body);
1636
+ return b.build();
2555
1637
  };
2556
1638
  export const se_UpdateVpcLinkCommand = async (input, context) => {
2557
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1639
+ const b = rb(input, context);
2558
1640
  const headers = {
2559
1641
  "content-type": "application/json",
2560
1642
  };
2561
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/vpclinks/{vpcLinkId}";
2562
- resolvedPath = __resolvedPath(resolvedPath, input, "vpcLinkId", () => input.vpcLinkId, "{vpcLinkId}", false);
1643
+ b.bp("/vpclinks/{vpcLinkId}");
1644
+ b.p("vpcLinkId", () => input.vpcLinkId, "{vpcLinkId}", false);
2563
1645
  let body;
2564
1646
  body = JSON.stringify(take(input, {
2565
1647
  patchOperations: (_) => _json(_),
2566
1648
  }));
2567
- return new __HttpRequest({
2568
- protocol,
2569
- hostname,
2570
- port,
2571
- method: "PATCH",
2572
- headers,
2573
- path: resolvedPath,
2574
- body,
2575
- });
1649
+ b.m("PATCH").h(headers).b(body);
1650
+ return b.build();
2576
1651
  };
2577
1652
  export const de_CreateApiKeyCommand = async (output, context) => {
2578
1653
  if (output.statusCode !== 201 && output.statusCode >= 300) {
@@ -5172,8 +4247,8 @@ export const de_GetExportCommand = async (output, context) => {
5172
4247
  }
5173
4248
  const contents = map({
5174
4249
  $metadata: deserializeMetadata(output),
5175
- contentType: [, output.headers["content-type"]],
5176
- contentDisposition: [, output.headers["content-disposition"]],
4250
+ [_cT]: [, output.headers[_ct]],
4251
+ [_cD]: [, output.headers[_cd]],
5177
4252
  });
5178
4253
  const data = await collectBody(output.body, context);
5179
4254
  contents.body = data;
@@ -5903,8 +4978,8 @@ export const de_GetSdkCommand = async (output, context) => {
5903
4978
  }
5904
4979
  const contents = map({
5905
4980
  $metadata: deserializeMetadata(output),
5906
- contentType: [, output.headers["content-type"]],
5907
- contentDisposition: [, output.headers["content-disposition"]],
4981
+ [_cT]: [, output.headers[_ct]],
4982
+ [_cD]: [, output.headers[_cd]],
5908
4983
  });
5909
4984
  const data = await collectBody(output.body, context);
5910
4985
  contents.body = data;
@@ -8403,7 +7478,7 @@ const de_ConflictExceptionRes = async (parsedOutput, context) => {
8403
7478
  };
8404
7479
  const de_LimitExceededExceptionRes = async (parsedOutput, context) => {
8405
7480
  const contents = map({
8406
- retryAfterSeconds: [, parsedOutput.headers["retry-after"]],
7481
+ [_rAS]: [, parsedOutput.headers[_ra]],
8407
7482
  });
8408
7483
  const data = parsedOutput.body;
8409
7484
  const doc = take(data, {
@@ -8431,7 +7506,7 @@ const de_NotFoundExceptionRes = async (parsedOutput, context) => {
8431
7506
  };
8432
7507
  const de_ServiceUnavailableExceptionRes = async (parsedOutput, context) => {
8433
7508
  const contents = map({
8434
- retryAfterSeconds: [, parsedOutput.headers["retry-after"]],
7509
+ [_rAS]: [, parsedOutput.headers[_ra]],
8435
7510
  });
8436
7511
  const data = parsedOutput.body;
8437
7512
  const doc = take(data, {
@@ -8446,7 +7521,7 @@ const de_ServiceUnavailableExceptionRes = async (parsedOutput, context) => {
8446
7521
  };
8447
7522
  const de_TooManyRequestsExceptionRes = async (parsedOutput, context) => {
8448
7523
  const contents = map({
8449
- retryAfterSeconds: [, parsedOutput.headers["retry-after"]],
7524
+ [_rAS]: [, parsedOutput.headers[_ra]],
8450
7525
  });
8451
7526
  const data = parsedOutput.body;
8452
7527
  const doc = take(data, {
@@ -8764,6 +7839,35 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
8764
7839
  value !== "" &&
8765
7840
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
8766
7841
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
7842
+ const _a = "accepts";
7843
+ const _ac = "accept";
7844
+ const _cD = "contentDisposition";
7845
+ const _cI = "customerId";
7846
+ const _cT = "contentType";
7847
+ const _cd = "content-disposition";
7848
+ const _ct = "content-type";
7849
+ const _dI = "deploymentId";
7850
+ const _e = "embed";
7851
+ const _eD = "endDate";
7852
+ const _f = "flatten";
7853
+ const _fOW = "failOnWarnings";
7854
+ const _fa = "failonwarnings";
7855
+ const _fo = "format";
7856
+ const _iV = "includeValue";
7857
+ const _iVn = "includeValues";
7858
+ const _kI = "keyId";
7859
+ const _l = "limit";
7860
+ const _lS = "locationStatus";
7861
+ const _m = "mode";
7862
+ const _n = "name";
7863
+ const _nQ = "nameQuery";
7864
+ const _p = "position";
7865
+ const _pa = "path";
7866
+ const _rAS = "retryAfterSeconds";
7867
+ const _ra = "retry-after";
7868
+ const _sD = "startDate";
7869
+ const _t = "type";
7870
+ const _tK = "tagKeys";
8767
7871
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
8768
7872
  if (encoded.length) {
8769
7873
  return JSON.parse(encoded);