@aws-sdk/client-greengrass 3.476.0 → 3.478.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 +521 -1241
  2. package/dist-es/protocols/Aws_restJson1.js +522 -1242
  3. package/package.json +7 -6
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,307 +1,211 @@
1
- import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
2
- import { _json, collectBody, decorateServiceException as __decorateServiceException, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, map, resolvedPath as __resolvedPath, take, withBaseException, } from "@smithy/smithy-client";
1
+ import { requestBuilder as rb } from "@smithy/core";
2
+ import { _json, collectBody, decorateServiceException as __decorateServiceException, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, map, take, withBaseException, } from "@smithy/smithy-client";
3
3
  import { GreengrassServiceException as __BaseException } from "../models/GreengrassServiceException";
4
4
  import { BadRequestException, InternalServerErrorException, } from "../models/models_0";
5
5
  export const se_AssociateRoleToGroupCommand = 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
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/groups/{GroupId}/role";
11
- resolvedPath = __resolvedPath(resolvedPath, input, "GroupId", () => input.GroupId, "{GroupId}", false);
10
+ b.bp("/greengrass/groups/{GroupId}/role");
11
+ b.p("GroupId", () => input.GroupId, "{GroupId}", false);
12
12
  let body;
13
13
  body = JSON.stringify(take(input, {
14
14
  RoleArn: [],
15
15
  }));
16
- return new __HttpRequest({
17
- protocol,
18
- hostname,
19
- port,
20
- method: "PUT",
21
- headers,
22
- path: resolvedPath,
23
- body,
24
- });
16
+ b.m("PUT").h(headers).b(body);
17
+ return b.build();
25
18
  };
26
19
  export const se_AssociateServiceRoleToAccountCommand = async (input, context) => {
27
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
20
+ const b = rb(input, context);
28
21
  const headers = {
29
22
  "content-type": "application/json",
30
23
  };
31
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/servicerole";
24
+ b.bp("/greengrass/servicerole");
32
25
  let body;
33
26
  body = JSON.stringify(take(input, {
34
27
  RoleArn: [],
35
28
  }));
36
- return new __HttpRequest({
37
- protocol,
38
- hostname,
39
- port,
40
- method: "PUT",
41
- headers,
42
- path: resolvedPath,
43
- body,
44
- });
29
+ b.m("PUT").h(headers).b(body);
30
+ return b.build();
45
31
  };
46
32
  export const se_CreateConnectorDefinitionCommand = async (input, context) => {
47
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
33
+ const b = rb(input, context);
48
34
  const headers = map({}, isSerializableHeaderValue, {
49
35
  "content-type": "application/json",
50
- "x-amzn-client-token": input.AmznClientToken,
36
+ [_xact]: input[_ACT],
51
37
  });
52
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/definition/connectors";
38
+ b.bp("/greengrass/definition/connectors");
53
39
  let body;
54
40
  body = JSON.stringify(take(input, {
55
41
  InitialVersion: (_) => _json(_),
56
42
  Name: [],
57
43
  tags: (_) => _json(_),
58
44
  }));
59
- return new __HttpRequest({
60
- protocol,
61
- hostname,
62
- port,
63
- method: "POST",
64
- headers,
65
- path: resolvedPath,
66
- body,
67
- });
45
+ b.m("POST").h(headers).b(body);
46
+ return b.build();
68
47
  };
69
48
  export const se_CreateConnectorDefinitionVersionCommand = async (input, context) => {
70
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
49
+ const b = rb(input, context);
71
50
  const headers = map({}, isSerializableHeaderValue, {
72
51
  "content-type": "application/json",
73
- "x-amzn-client-token": input.AmznClientToken,
52
+ [_xact]: input[_ACT],
74
53
  });
75
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
76
- "/greengrass/definition/connectors/{ConnectorDefinitionId}/versions";
77
- resolvedPath = __resolvedPath(resolvedPath, input, "ConnectorDefinitionId", () => input.ConnectorDefinitionId, "{ConnectorDefinitionId}", false);
54
+ b.bp("/greengrass/definition/connectors/{ConnectorDefinitionId}/versions");
55
+ b.p("ConnectorDefinitionId", () => input.ConnectorDefinitionId, "{ConnectorDefinitionId}", false);
78
56
  let body;
79
57
  body = JSON.stringify(take(input, {
80
58
  Connectors: (_) => _json(_),
81
59
  }));
82
- return new __HttpRequest({
83
- protocol,
84
- hostname,
85
- port,
86
- method: "POST",
87
- headers,
88
- path: resolvedPath,
89
- body,
90
- });
60
+ b.m("POST").h(headers).b(body);
61
+ return b.build();
91
62
  };
92
63
  export const se_CreateCoreDefinitionCommand = async (input, context) => {
93
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
64
+ const b = rb(input, context);
94
65
  const headers = map({}, isSerializableHeaderValue, {
95
66
  "content-type": "application/json",
96
- "x-amzn-client-token": input.AmznClientToken,
67
+ [_xact]: input[_ACT],
97
68
  });
98
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/definition/cores";
69
+ b.bp("/greengrass/definition/cores");
99
70
  let body;
100
71
  body = JSON.stringify(take(input, {
101
72
  InitialVersion: (_) => _json(_),
102
73
  Name: [],
103
74
  tags: (_) => _json(_),
104
75
  }));
105
- return new __HttpRequest({
106
- protocol,
107
- hostname,
108
- port,
109
- method: "POST",
110
- headers,
111
- path: resolvedPath,
112
- body,
113
- });
76
+ b.m("POST").h(headers).b(body);
77
+ return b.build();
114
78
  };
115
79
  export const se_CreateCoreDefinitionVersionCommand = async (input, context) => {
116
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
80
+ const b = rb(input, context);
117
81
  const headers = map({}, isSerializableHeaderValue, {
118
82
  "content-type": "application/json",
119
- "x-amzn-client-token": input.AmznClientToken,
83
+ [_xact]: input[_ACT],
120
84
  });
121
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
122
- "/greengrass/definition/cores/{CoreDefinitionId}/versions";
123
- resolvedPath = __resolvedPath(resolvedPath, input, "CoreDefinitionId", () => input.CoreDefinitionId, "{CoreDefinitionId}", false);
85
+ b.bp("/greengrass/definition/cores/{CoreDefinitionId}/versions");
86
+ b.p("CoreDefinitionId", () => input.CoreDefinitionId, "{CoreDefinitionId}", false);
124
87
  let body;
125
88
  body = JSON.stringify(take(input, {
126
89
  Cores: (_) => _json(_),
127
90
  }));
128
- return new __HttpRequest({
129
- protocol,
130
- hostname,
131
- port,
132
- method: "POST",
133
- headers,
134
- path: resolvedPath,
135
- body,
136
- });
91
+ b.m("POST").h(headers).b(body);
92
+ return b.build();
137
93
  };
138
94
  export const se_CreateDeploymentCommand = async (input, context) => {
139
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
95
+ const b = rb(input, context);
140
96
  const headers = map({}, isSerializableHeaderValue, {
141
97
  "content-type": "application/json",
142
- "x-amzn-client-token": input.AmznClientToken,
98
+ [_xact]: input[_ACT],
143
99
  });
144
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/groups/{GroupId}/deployments";
145
- resolvedPath = __resolvedPath(resolvedPath, input, "GroupId", () => input.GroupId, "{GroupId}", false);
100
+ b.bp("/greengrass/groups/{GroupId}/deployments");
101
+ b.p("GroupId", () => input.GroupId, "{GroupId}", false);
146
102
  let body;
147
103
  body = JSON.stringify(take(input, {
148
104
  DeploymentId: [],
149
105
  DeploymentType: [],
150
106
  GroupVersionId: [],
151
107
  }));
152
- return new __HttpRequest({
153
- protocol,
154
- hostname,
155
- port,
156
- method: "POST",
157
- headers,
158
- path: resolvedPath,
159
- body,
160
- });
108
+ b.m("POST").h(headers).b(body);
109
+ return b.build();
161
110
  };
162
111
  export const se_CreateDeviceDefinitionCommand = async (input, context) => {
163
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
112
+ const b = rb(input, context);
164
113
  const headers = map({}, isSerializableHeaderValue, {
165
114
  "content-type": "application/json",
166
- "x-amzn-client-token": input.AmznClientToken,
115
+ [_xact]: input[_ACT],
167
116
  });
168
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/definition/devices";
117
+ b.bp("/greengrass/definition/devices");
169
118
  let body;
170
119
  body = JSON.stringify(take(input, {
171
120
  InitialVersion: (_) => _json(_),
172
121
  Name: [],
173
122
  tags: (_) => _json(_),
174
123
  }));
175
- return new __HttpRequest({
176
- protocol,
177
- hostname,
178
- port,
179
- method: "POST",
180
- headers,
181
- path: resolvedPath,
182
- body,
183
- });
124
+ b.m("POST").h(headers).b(body);
125
+ return b.build();
184
126
  };
185
127
  export const se_CreateDeviceDefinitionVersionCommand = async (input, context) => {
186
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
128
+ const b = rb(input, context);
187
129
  const headers = map({}, isSerializableHeaderValue, {
188
130
  "content-type": "application/json",
189
- "x-amzn-client-token": input.AmznClientToken,
131
+ [_xact]: input[_ACT],
190
132
  });
191
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
192
- "/greengrass/definition/devices/{DeviceDefinitionId}/versions";
193
- resolvedPath = __resolvedPath(resolvedPath, input, "DeviceDefinitionId", () => input.DeviceDefinitionId, "{DeviceDefinitionId}", false);
133
+ b.bp("/greengrass/definition/devices/{DeviceDefinitionId}/versions");
134
+ b.p("DeviceDefinitionId", () => input.DeviceDefinitionId, "{DeviceDefinitionId}", false);
194
135
  let body;
195
136
  body = JSON.stringify(take(input, {
196
137
  Devices: (_) => _json(_),
197
138
  }));
198
- return new __HttpRequest({
199
- protocol,
200
- hostname,
201
- port,
202
- method: "POST",
203
- headers,
204
- path: resolvedPath,
205
- body,
206
- });
139
+ b.m("POST").h(headers).b(body);
140
+ return b.build();
207
141
  };
208
142
  export const se_CreateFunctionDefinitionCommand = async (input, context) => {
209
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
143
+ const b = rb(input, context);
210
144
  const headers = map({}, isSerializableHeaderValue, {
211
145
  "content-type": "application/json",
212
- "x-amzn-client-token": input.AmznClientToken,
146
+ [_xact]: input[_ACT],
213
147
  });
214
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/definition/functions";
148
+ b.bp("/greengrass/definition/functions");
215
149
  let body;
216
150
  body = JSON.stringify(take(input, {
217
151
  InitialVersion: (_) => _json(_),
218
152
  Name: [],
219
153
  tags: (_) => _json(_),
220
154
  }));
221
- return new __HttpRequest({
222
- protocol,
223
- hostname,
224
- port,
225
- method: "POST",
226
- headers,
227
- path: resolvedPath,
228
- body,
229
- });
155
+ b.m("POST").h(headers).b(body);
156
+ return b.build();
230
157
  };
231
158
  export const se_CreateFunctionDefinitionVersionCommand = async (input, context) => {
232
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
159
+ const b = rb(input, context);
233
160
  const headers = map({}, isSerializableHeaderValue, {
234
161
  "content-type": "application/json",
235
- "x-amzn-client-token": input.AmznClientToken,
162
+ [_xact]: input[_ACT],
236
163
  });
237
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
238
- "/greengrass/definition/functions/{FunctionDefinitionId}/versions";
239
- resolvedPath = __resolvedPath(resolvedPath, input, "FunctionDefinitionId", () => input.FunctionDefinitionId, "{FunctionDefinitionId}", false);
164
+ b.bp("/greengrass/definition/functions/{FunctionDefinitionId}/versions");
165
+ b.p("FunctionDefinitionId", () => input.FunctionDefinitionId, "{FunctionDefinitionId}", false);
240
166
  let body;
241
167
  body = JSON.stringify(take(input, {
242
168
  DefaultConfig: (_) => _json(_),
243
169
  Functions: (_) => _json(_),
244
170
  }));
245
- return new __HttpRequest({
246
- protocol,
247
- hostname,
248
- port,
249
- method: "POST",
250
- headers,
251
- path: resolvedPath,
252
- body,
253
- });
171
+ b.m("POST").h(headers).b(body);
172
+ return b.build();
254
173
  };
255
174
  export const se_CreateGroupCommand = async (input, context) => {
256
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
175
+ const b = rb(input, context);
257
176
  const headers = map({}, isSerializableHeaderValue, {
258
177
  "content-type": "application/json",
259
- "x-amzn-client-token": input.AmznClientToken,
178
+ [_xact]: input[_ACT],
260
179
  });
261
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/groups";
180
+ b.bp("/greengrass/groups");
262
181
  let body;
263
182
  body = JSON.stringify(take(input, {
264
183
  InitialVersion: (_) => _json(_),
265
184
  Name: [],
266
185
  tags: (_) => _json(_),
267
186
  }));
268
- return new __HttpRequest({
269
- protocol,
270
- hostname,
271
- port,
272
- method: "POST",
273
- headers,
274
- path: resolvedPath,
275
- body,
276
- });
187
+ b.m("POST").h(headers).b(body);
188
+ return b.build();
277
189
  };
278
190
  export const se_CreateGroupCertificateAuthorityCommand = async (input, context) => {
279
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
191
+ const b = rb(input, context);
280
192
  const headers = map({}, isSerializableHeaderValue, {
281
- "x-amzn-client-token": input.AmznClientToken,
193
+ [_xact]: input[_ACT],
282
194
  });
283
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
284
- "/greengrass/groups/{GroupId}/certificateauthorities";
285
- resolvedPath = __resolvedPath(resolvedPath, input, "GroupId", () => input.GroupId, "{GroupId}", false);
195
+ b.bp("/greengrass/groups/{GroupId}/certificateauthorities");
196
+ b.p("GroupId", () => input.GroupId, "{GroupId}", false);
286
197
  let body;
287
- return new __HttpRequest({
288
- protocol,
289
- hostname,
290
- port,
291
- method: "POST",
292
- headers,
293
- path: resolvedPath,
294
- body,
295
- });
198
+ b.m("POST").h(headers).b(body);
199
+ return b.build();
296
200
  };
297
201
  export const se_CreateGroupVersionCommand = async (input, context) => {
298
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
202
+ const b = rb(input, context);
299
203
  const headers = map({}, isSerializableHeaderValue, {
300
204
  "content-type": "application/json",
301
- "x-amzn-client-token": input.AmznClientToken,
205
+ [_xact]: input[_ACT],
302
206
  });
303
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/groups/{GroupId}/versions";
304
- resolvedPath = __resolvedPath(resolvedPath, input, "GroupId", () => input.GroupId, "{GroupId}", false);
207
+ b.bp("/greengrass/groups/{GroupId}/versions");
208
+ b.p("GroupId", () => input.GroupId, "{GroupId}", false);
305
209
  let body;
306
210
  body = JSON.stringify(take(input, {
307
211
  ConnectorDefinitionVersionArn: [],
@@ -312,115 +216,78 @@ export const se_CreateGroupVersionCommand = async (input, context) => {
312
216
  ResourceDefinitionVersionArn: [],
313
217
  SubscriptionDefinitionVersionArn: [],
314
218
  }));
315
- return new __HttpRequest({
316
- protocol,
317
- hostname,
318
- port,
319
- method: "POST",
320
- headers,
321
- path: resolvedPath,
322
- body,
323
- });
219
+ b.m("POST").h(headers).b(body);
220
+ return b.build();
324
221
  };
325
222
  export const se_CreateLoggerDefinitionCommand = async (input, context) => {
326
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
223
+ const b = rb(input, context);
327
224
  const headers = map({}, isSerializableHeaderValue, {
328
225
  "content-type": "application/json",
329
- "x-amzn-client-token": input.AmznClientToken,
226
+ [_xact]: input[_ACT],
330
227
  });
331
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/definition/loggers";
228
+ b.bp("/greengrass/definition/loggers");
332
229
  let body;
333
230
  body = JSON.stringify(take(input, {
334
231
  InitialVersion: (_) => _json(_),
335
232
  Name: [],
336
233
  tags: (_) => _json(_),
337
234
  }));
338
- return new __HttpRequest({
339
- protocol,
340
- hostname,
341
- port,
342
- method: "POST",
343
- headers,
344
- path: resolvedPath,
345
- body,
346
- });
235
+ b.m("POST").h(headers).b(body);
236
+ return b.build();
347
237
  };
348
238
  export const se_CreateLoggerDefinitionVersionCommand = async (input, context) => {
349
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
239
+ const b = rb(input, context);
350
240
  const headers = map({}, isSerializableHeaderValue, {
351
241
  "content-type": "application/json",
352
- "x-amzn-client-token": input.AmznClientToken,
242
+ [_xact]: input[_ACT],
353
243
  });
354
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
355
- "/greengrass/definition/loggers/{LoggerDefinitionId}/versions";
356
- resolvedPath = __resolvedPath(resolvedPath, input, "LoggerDefinitionId", () => input.LoggerDefinitionId, "{LoggerDefinitionId}", false);
244
+ b.bp("/greengrass/definition/loggers/{LoggerDefinitionId}/versions");
245
+ b.p("LoggerDefinitionId", () => input.LoggerDefinitionId, "{LoggerDefinitionId}", false);
357
246
  let body;
358
247
  body = JSON.stringify(take(input, {
359
248
  Loggers: (_) => _json(_),
360
249
  }));
361
- return new __HttpRequest({
362
- protocol,
363
- hostname,
364
- port,
365
- method: "POST",
366
- headers,
367
- path: resolvedPath,
368
- body,
369
- });
250
+ b.m("POST").h(headers).b(body);
251
+ return b.build();
370
252
  };
371
253
  export const se_CreateResourceDefinitionCommand = async (input, context) => {
372
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
254
+ const b = rb(input, context);
373
255
  const headers = map({}, isSerializableHeaderValue, {
374
256
  "content-type": "application/json",
375
- "x-amzn-client-token": input.AmznClientToken,
257
+ [_xact]: input[_ACT],
376
258
  });
377
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/definition/resources";
259
+ b.bp("/greengrass/definition/resources");
378
260
  let body;
379
261
  body = JSON.stringify(take(input, {
380
262
  InitialVersion: (_) => _json(_),
381
263
  Name: [],
382
264
  tags: (_) => _json(_),
383
265
  }));
384
- return new __HttpRequest({
385
- protocol,
386
- hostname,
387
- port,
388
- method: "POST",
389
- headers,
390
- path: resolvedPath,
391
- body,
392
- });
266
+ b.m("POST").h(headers).b(body);
267
+ return b.build();
393
268
  };
394
269
  export const se_CreateResourceDefinitionVersionCommand = async (input, context) => {
395
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
270
+ const b = rb(input, context);
396
271
  const headers = map({}, isSerializableHeaderValue, {
397
272
  "content-type": "application/json",
398
- "x-amzn-client-token": input.AmznClientToken,
273
+ [_xact]: input[_ACT],
399
274
  });
400
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
401
- "/greengrass/definition/resources/{ResourceDefinitionId}/versions";
402
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceDefinitionId", () => input.ResourceDefinitionId, "{ResourceDefinitionId}", false);
275
+ b.bp("/greengrass/definition/resources/{ResourceDefinitionId}/versions");
276
+ b.p("ResourceDefinitionId", () => input.ResourceDefinitionId, "{ResourceDefinitionId}", false);
403
277
  let body;
404
278
  body = JSON.stringify(take(input, {
405
279
  Resources: (_) => _json(_),
406
280
  }));
407
- return new __HttpRequest({
408
- protocol,
409
- hostname,
410
- port,
411
- method: "POST",
412
- headers,
413
- path: resolvedPath,
414
- body,
415
- });
281
+ b.m("POST").h(headers).b(body);
282
+ return b.build();
416
283
  };
417
284
  export const se_CreateSoftwareUpdateJobCommand = async (input, context) => {
418
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
285
+ const b = rb(input, context);
419
286
  const headers = map({}, isSerializableHeaderValue, {
420
287
  "content-type": "application/json",
421
- "x-amzn-client-token": input.AmznClientToken,
288
+ [_xact]: input[_ACT],
422
289
  });
423
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/updates";
290
+ b.bp("/greengrass/updates");
424
291
  let body;
425
292
  body = JSON.stringify(take(input, {
426
293
  S3UrlSignerRole: [],
@@ -430,1446 +297,853 @@ export const se_CreateSoftwareUpdateJobCommand = async (input, context) => {
430
297
  UpdateTargetsArchitecture: [],
431
298
  UpdateTargetsOperatingSystem: [],
432
299
  }));
433
- return new __HttpRequest({
434
- protocol,
435
- hostname,
436
- port,
437
- method: "POST",
438
- headers,
439
- path: resolvedPath,
440
- body,
441
- });
300
+ b.m("POST").h(headers).b(body);
301
+ return b.build();
442
302
  };
443
303
  export const se_CreateSubscriptionDefinitionCommand = async (input, context) => {
444
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
304
+ const b = rb(input, context);
445
305
  const headers = map({}, isSerializableHeaderValue, {
446
306
  "content-type": "application/json",
447
- "x-amzn-client-token": input.AmznClientToken,
307
+ [_xact]: input[_ACT],
448
308
  });
449
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/definition/subscriptions";
309
+ b.bp("/greengrass/definition/subscriptions");
450
310
  let body;
451
311
  body = JSON.stringify(take(input, {
452
312
  InitialVersion: (_) => _json(_),
453
313
  Name: [],
454
314
  tags: (_) => _json(_),
455
315
  }));
456
- return new __HttpRequest({
457
- protocol,
458
- hostname,
459
- port,
460
- method: "POST",
461
- headers,
462
- path: resolvedPath,
463
- body,
464
- });
316
+ b.m("POST").h(headers).b(body);
317
+ return b.build();
465
318
  };
466
319
  export const se_CreateSubscriptionDefinitionVersionCommand = async (input, context) => {
467
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
320
+ const b = rb(input, context);
468
321
  const headers = map({}, isSerializableHeaderValue, {
469
322
  "content-type": "application/json",
470
- "x-amzn-client-token": input.AmznClientToken,
323
+ [_xact]: input[_ACT],
471
324
  });
472
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
473
- "/greengrass/definition/subscriptions/{SubscriptionDefinitionId}/versions";
474
- resolvedPath = __resolvedPath(resolvedPath, input, "SubscriptionDefinitionId", () => input.SubscriptionDefinitionId, "{SubscriptionDefinitionId}", false);
325
+ b.bp("/greengrass/definition/subscriptions/{SubscriptionDefinitionId}/versions");
326
+ b.p("SubscriptionDefinitionId", () => input.SubscriptionDefinitionId, "{SubscriptionDefinitionId}", false);
475
327
  let body;
476
328
  body = JSON.stringify(take(input, {
477
329
  Subscriptions: (_) => _json(_),
478
330
  }));
479
- return new __HttpRequest({
480
- protocol,
481
- hostname,
482
- port,
483
- method: "POST",
484
- headers,
485
- path: resolvedPath,
486
- body,
487
- });
331
+ b.m("POST").h(headers).b(body);
332
+ return b.build();
488
333
  };
489
334
  export const se_DeleteConnectorDefinitionCommand = async (input, context) => {
490
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
335
+ const b = rb(input, context);
491
336
  const headers = {};
492
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
493
- "/greengrass/definition/connectors/{ConnectorDefinitionId}";
494
- resolvedPath = __resolvedPath(resolvedPath, input, "ConnectorDefinitionId", () => input.ConnectorDefinitionId, "{ConnectorDefinitionId}", false);
337
+ b.bp("/greengrass/definition/connectors/{ConnectorDefinitionId}");
338
+ b.p("ConnectorDefinitionId", () => input.ConnectorDefinitionId, "{ConnectorDefinitionId}", false);
495
339
  let body;
496
- return new __HttpRequest({
497
- protocol,
498
- hostname,
499
- port,
500
- method: "DELETE",
501
- headers,
502
- path: resolvedPath,
503
- body,
504
- });
340
+ b.m("DELETE").h(headers).b(body);
341
+ return b.build();
505
342
  };
506
343
  export const se_DeleteCoreDefinitionCommand = async (input, context) => {
507
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
344
+ const b = rb(input, context);
508
345
  const headers = {};
509
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
510
- "/greengrass/definition/cores/{CoreDefinitionId}";
511
- resolvedPath = __resolvedPath(resolvedPath, input, "CoreDefinitionId", () => input.CoreDefinitionId, "{CoreDefinitionId}", false);
346
+ b.bp("/greengrass/definition/cores/{CoreDefinitionId}");
347
+ b.p("CoreDefinitionId", () => input.CoreDefinitionId, "{CoreDefinitionId}", false);
512
348
  let body;
513
- return new __HttpRequest({
514
- protocol,
515
- hostname,
516
- port,
517
- method: "DELETE",
518
- headers,
519
- path: resolvedPath,
520
- body,
521
- });
349
+ b.m("DELETE").h(headers).b(body);
350
+ return b.build();
522
351
  };
523
352
  export const se_DeleteDeviceDefinitionCommand = async (input, context) => {
524
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
353
+ const b = rb(input, context);
525
354
  const headers = {};
526
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
527
- "/greengrass/definition/devices/{DeviceDefinitionId}";
528
- resolvedPath = __resolvedPath(resolvedPath, input, "DeviceDefinitionId", () => input.DeviceDefinitionId, "{DeviceDefinitionId}", false);
355
+ b.bp("/greengrass/definition/devices/{DeviceDefinitionId}");
356
+ b.p("DeviceDefinitionId", () => input.DeviceDefinitionId, "{DeviceDefinitionId}", false);
529
357
  let body;
530
- return new __HttpRequest({
531
- protocol,
532
- hostname,
533
- port,
534
- method: "DELETE",
535
- headers,
536
- path: resolvedPath,
537
- body,
538
- });
358
+ b.m("DELETE").h(headers).b(body);
359
+ return b.build();
539
360
  };
540
361
  export const se_DeleteFunctionDefinitionCommand = async (input, context) => {
541
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
362
+ const b = rb(input, context);
542
363
  const headers = {};
543
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
544
- "/greengrass/definition/functions/{FunctionDefinitionId}";
545
- resolvedPath = __resolvedPath(resolvedPath, input, "FunctionDefinitionId", () => input.FunctionDefinitionId, "{FunctionDefinitionId}", false);
364
+ b.bp("/greengrass/definition/functions/{FunctionDefinitionId}");
365
+ b.p("FunctionDefinitionId", () => input.FunctionDefinitionId, "{FunctionDefinitionId}", false);
546
366
  let body;
547
- return new __HttpRequest({
548
- protocol,
549
- hostname,
550
- port,
551
- method: "DELETE",
552
- headers,
553
- path: resolvedPath,
554
- body,
555
- });
367
+ b.m("DELETE").h(headers).b(body);
368
+ return b.build();
556
369
  };
557
370
  export const se_DeleteGroupCommand = async (input, context) => {
558
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
371
+ const b = rb(input, context);
559
372
  const headers = {};
560
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/groups/{GroupId}";
561
- resolvedPath = __resolvedPath(resolvedPath, input, "GroupId", () => input.GroupId, "{GroupId}", false);
373
+ b.bp("/greengrass/groups/{GroupId}");
374
+ b.p("GroupId", () => input.GroupId, "{GroupId}", false);
562
375
  let body;
563
- return new __HttpRequest({
564
- protocol,
565
- hostname,
566
- port,
567
- method: "DELETE",
568
- headers,
569
- path: resolvedPath,
570
- body,
571
- });
376
+ b.m("DELETE").h(headers).b(body);
377
+ return b.build();
572
378
  };
573
379
  export const se_DeleteLoggerDefinitionCommand = async (input, context) => {
574
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
380
+ const b = rb(input, context);
575
381
  const headers = {};
576
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
577
- "/greengrass/definition/loggers/{LoggerDefinitionId}";
578
- resolvedPath = __resolvedPath(resolvedPath, input, "LoggerDefinitionId", () => input.LoggerDefinitionId, "{LoggerDefinitionId}", false);
382
+ b.bp("/greengrass/definition/loggers/{LoggerDefinitionId}");
383
+ b.p("LoggerDefinitionId", () => input.LoggerDefinitionId, "{LoggerDefinitionId}", false);
579
384
  let body;
580
- return new __HttpRequest({
581
- protocol,
582
- hostname,
583
- port,
584
- method: "DELETE",
585
- headers,
586
- path: resolvedPath,
587
- body,
588
- });
385
+ b.m("DELETE").h(headers).b(body);
386
+ return b.build();
589
387
  };
590
388
  export const se_DeleteResourceDefinitionCommand = async (input, context) => {
591
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
389
+ const b = rb(input, context);
592
390
  const headers = {};
593
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
594
- "/greengrass/definition/resources/{ResourceDefinitionId}";
595
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceDefinitionId", () => input.ResourceDefinitionId, "{ResourceDefinitionId}", false);
391
+ b.bp("/greengrass/definition/resources/{ResourceDefinitionId}");
392
+ b.p("ResourceDefinitionId", () => input.ResourceDefinitionId, "{ResourceDefinitionId}", false);
596
393
  let body;
597
- return new __HttpRequest({
598
- protocol,
599
- hostname,
600
- port,
601
- method: "DELETE",
602
- headers,
603
- path: resolvedPath,
604
- body,
605
- });
394
+ b.m("DELETE").h(headers).b(body);
395
+ return b.build();
606
396
  };
607
397
  export const se_DeleteSubscriptionDefinitionCommand = async (input, context) => {
608
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
398
+ const b = rb(input, context);
609
399
  const headers = {};
610
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
611
- "/greengrass/definition/subscriptions/{SubscriptionDefinitionId}";
612
- resolvedPath = __resolvedPath(resolvedPath, input, "SubscriptionDefinitionId", () => input.SubscriptionDefinitionId, "{SubscriptionDefinitionId}", false);
400
+ b.bp("/greengrass/definition/subscriptions/{SubscriptionDefinitionId}");
401
+ b.p("SubscriptionDefinitionId", () => input.SubscriptionDefinitionId, "{SubscriptionDefinitionId}", false);
613
402
  let body;
614
- return new __HttpRequest({
615
- protocol,
616
- hostname,
617
- port,
618
- method: "DELETE",
619
- headers,
620
- path: resolvedPath,
621
- body,
622
- });
403
+ b.m("DELETE").h(headers).b(body);
404
+ return b.build();
623
405
  };
624
406
  export const se_DisassociateRoleFromGroupCommand = async (input, context) => {
625
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
407
+ const b = rb(input, context);
626
408
  const headers = {};
627
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/groups/{GroupId}/role";
628
- resolvedPath = __resolvedPath(resolvedPath, input, "GroupId", () => input.GroupId, "{GroupId}", false);
409
+ b.bp("/greengrass/groups/{GroupId}/role");
410
+ b.p("GroupId", () => input.GroupId, "{GroupId}", false);
629
411
  let body;
630
- return new __HttpRequest({
631
- protocol,
632
- hostname,
633
- port,
634
- method: "DELETE",
635
- headers,
636
- path: resolvedPath,
637
- body,
638
- });
412
+ b.m("DELETE").h(headers).b(body);
413
+ return b.build();
639
414
  };
640
415
  export const se_DisassociateServiceRoleFromAccountCommand = async (input, context) => {
641
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
416
+ const b = rb(input, context);
642
417
  const headers = {
643
418
  "content-type": "application/json",
644
419
  };
645
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/servicerole";
420
+ b.bp("/greengrass/servicerole");
646
421
  let body;
647
422
  body = "";
648
- return new __HttpRequest({
649
- protocol,
650
- hostname,
651
- port,
652
- method: "DELETE",
653
- headers,
654
- path: resolvedPath,
655
- body,
656
- });
423
+ b.m("DELETE").h(headers).b(body);
424
+ return b.build();
657
425
  };
658
426
  export const se_GetAssociatedRoleCommand = async (input, context) => {
659
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
427
+ const b = rb(input, context);
660
428
  const headers = {};
661
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/groups/{GroupId}/role";
662
- resolvedPath = __resolvedPath(resolvedPath, input, "GroupId", () => input.GroupId, "{GroupId}", false);
429
+ b.bp("/greengrass/groups/{GroupId}/role");
430
+ b.p("GroupId", () => input.GroupId, "{GroupId}", false);
663
431
  let body;
664
- return new __HttpRequest({
665
- protocol,
666
- hostname,
667
- port,
668
- method: "GET",
669
- headers,
670
- path: resolvedPath,
671
- body,
672
- });
432
+ b.m("GET").h(headers).b(body);
433
+ return b.build();
673
434
  };
674
435
  export const se_GetBulkDeploymentStatusCommand = async (input, context) => {
675
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
436
+ const b = rb(input, context);
676
437
  const headers = {};
677
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
678
- "/greengrass/bulk/deployments/{BulkDeploymentId}/status";
679
- resolvedPath = __resolvedPath(resolvedPath, input, "BulkDeploymentId", () => input.BulkDeploymentId, "{BulkDeploymentId}", false);
438
+ b.bp("/greengrass/bulk/deployments/{BulkDeploymentId}/status");
439
+ b.p("BulkDeploymentId", () => input.BulkDeploymentId, "{BulkDeploymentId}", false);
680
440
  let body;
681
- return new __HttpRequest({
682
- protocol,
683
- hostname,
684
- port,
685
- method: "GET",
686
- headers,
687
- path: resolvedPath,
688
- body,
689
- });
441
+ b.m("GET").h(headers).b(body);
442
+ return b.build();
690
443
  };
691
444
  export const se_GetConnectivityInfoCommand = async (input, context) => {
692
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
445
+ const b = rb(input, context);
693
446
  const headers = {};
694
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
695
- "/greengrass/things/{ThingName}/connectivityInfo";
696
- resolvedPath = __resolvedPath(resolvedPath, input, "ThingName", () => input.ThingName, "{ThingName}", false);
447
+ b.bp("/greengrass/things/{ThingName}/connectivityInfo");
448
+ b.p("ThingName", () => input.ThingName, "{ThingName}", false);
697
449
  let body;
698
- return new __HttpRequest({
699
- protocol,
700
- hostname,
701
- port,
702
- method: "GET",
703
- headers,
704
- path: resolvedPath,
705
- body,
706
- });
450
+ b.m("GET").h(headers).b(body);
451
+ return b.build();
707
452
  };
708
453
  export const se_GetConnectorDefinitionCommand = async (input, context) => {
709
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
454
+ const b = rb(input, context);
710
455
  const headers = {};
711
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
712
- "/greengrass/definition/connectors/{ConnectorDefinitionId}";
713
- resolvedPath = __resolvedPath(resolvedPath, input, "ConnectorDefinitionId", () => input.ConnectorDefinitionId, "{ConnectorDefinitionId}", false);
456
+ b.bp("/greengrass/definition/connectors/{ConnectorDefinitionId}");
457
+ b.p("ConnectorDefinitionId", () => input.ConnectorDefinitionId, "{ConnectorDefinitionId}", false);
714
458
  let body;
715
- return new __HttpRequest({
716
- protocol,
717
- hostname,
718
- port,
719
- method: "GET",
720
- headers,
721
- path: resolvedPath,
722
- body,
723
- });
459
+ b.m("GET").h(headers).b(body);
460
+ return b.build();
724
461
  };
725
462
  export const se_GetConnectorDefinitionVersionCommand = async (input, context) => {
726
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
463
+ const b = rb(input, context);
727
464
  const headers = {};
728
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
729
- "/greengrass/definition/connectors/{ConnectorDefinitionId}/versions/{ConnectorDefinitionVersionId}";
730
- resolvedPath = __resolvedPath(resolvedPath, input, "ConnectorDefinitionId", () => input.ConnectorDefinitionId, "{ConnectorDefinitionId}", false);
731
- resolvedPath = __resolvedPath(resolvedPath, input, "ConnectorDefinitionVersionId", () => input.ConnectorDefinitionVersionId, "{ConnectorDefinitionVersionId}", false);
465
+ b.bp("/greengrass/definition/connectors/{ConnectorDefinitionId}/versions/{ConnectorDefinitionVersionId}");
466
+ b.p("ConnectorDefinitionId", () => input.ConnectorDefinitionId, "{ConnectorDefinitionId}", false);
467
+ b.p("ConnectorDefinitionVersionId", () => input.ConnectorDefinitionVersionId, "{ConnectorDefinitionVersionId}", false);
732
468
  const query = map({
733
- NextToken: [, input.NextToken],
469
+ [_NT]: [, input[_NT]],
734
470
  });
735
471
  let body;
736
- return new __HttpRequest({
737
- protocol,
738
- hostname,
739
- port,
740
- method: "GET",
741
- headers,
742
- path: resolvedPath,
743
- query,
744
- body,
745
- });
472
+ b.m("GET").h(headers).q(query).b(body);
473
+ return b.build();
746
474
  };
747
475
  export const se_GetCoreDefinitionCommand = async (input, context) => {
748
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
476
+ const b = rb(input, context);
749
477
  const headers = {};
750
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
751
- "/greengrass/definition/cores/{CoreDefinitionId}";
752
- resolvedPath = __resolvedPath(resolvedPath, input, "CoreDefinitionId", () => input.CoreDefinitionId, "{CoreDefinitionId}", false);
478
+ b.bp("/greengrass/definition/cores/{CoreDefinitionId}");
479
+ b.p("CoreDefinitionId", () => input.CoreDefinitionId, "{CoreDefinitionId}", false);
753
480
  let body;
754
- return new __HttpRequest({
755
- protocol,
756
- hostname,
757
- port,
758
- method: "GET",
759
- headers,
760
- path: resolvedPath,
761
- body,
762
- });
481
+ b.m("GET").h(headers).b(body);
482
+ return b.build();
763
483
  };
764
484
  export const se_GetCoreDefinitionVersionCommand = async (input, context) => {
765
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
485
+ const b = rb(input, context);
766
486
  const headers = {};
767
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
768
- "/greengrass/definition/cores/{CoreDefinitionId}/versions/{CoreDefinitionVersionId}";
769
- resolvedPath = __resolvedPath(resolvedPath, input, "CoreDefinitionId", () => input.CoreDefinitionId, "{CoreDefinitionId}", false);
770
- resolvedPath = __resolvedPath(resolvedPath, input, "CoreDefinitionVersionId", () => input.CoreDefinitionVersionId, "{CoreDefinitionVersionId}", false);
487
+ b.bp("/greengrass/definition/cores/{CoreDefinitionId}/versions/{CoreDefinitionVersionId}");
488
+ b.p("CoreDefinitionId", () => input.CoreDefinitionId, "{CoreDefinitionId}", false);
489
+ b.p("CoreDefinitionVersionId", () => input.CoreDefinitionVersionId, "{CoreDefinitionVersionId}", false);
771
490
  let body;
772
- return new __HttpRequest({
773
- protocol,
774
- hostname,
775
- port,
776
- method: "GET",
777
- headers,
778
- path: resolvedPath,
779
- body,
780
- });
491
+ b.m("GET").h(headers).b(body);
492
+ return b.build();
781
493
  };
782
494
  export const se_GetDeploymentStatusCommand = async (input, context) => {
783
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
495
+ const b = rb(input, context);
784
496
  const headers = {};
785
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
786
- "/greengrass/groups/{GroupId}/deployments/{DeploymentId}/status";
787
- resolvedPath = __resolvedPath(resolvedPath, input, "DeploymentId", () => input.DeploymentId, "{DeploymentId}", false);
788
- resolvedPath = __resolvedPath(resolvedPath, input, "GroupId", () => input.GroupId, "{GroupId}", false);
497
+ b.bp("/greengrass/groups/{GroupId}/deployments/{DeploymentId}/status");
498
+ b.p("DeploymentId", () => input.DeploymentId, "{DeploymentId}", false);
499
+ b.p("GroupId", () => input.GroupId, "{GroupId}", false);
789
500
  let body;
790
- return new __HttpRequest({
791
- protocol,
792
- hostname,
793
- port,
794
- method: "GET",
795
- headers,
796
- path: resolvedPath,
797
- body,
798
- });
501
+ b.m("GET").h(headers).b(body);
502
+ return b.build();
799
503
  };
800
504
  export const se_GetDeviceDefinitionCommand = async (input, context) => {
801
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
505
+ const b = rb(input, context);
802
506
  const headers = {};
803
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
804
- "/greengrass/definition/devices/{DeviceDefinitionId}";
805
- resolvedPath = __resolvedPath(resolvedPath, input, "DeviceDefinitionId", () => input.DeviceDefinitionId, "{DeviceDefinitionId}", false);
507
+ b.bp("/greengrass/definition/devices/{DeviceDefinitionId}");
508
+ b.p("DeviceDefinitionId", () => input.DeviceDefinitionId, "{DeviceDefinitionId}", false);
806
509
  let body;
807
- return new __HttpRequest({
808
- protocol,
809
- hostname,
810
- port,
811
- method: "GET",
812
- headers,
813
- path: resolvedPath,
814
- body,
815
- });
510
+ b.m("GET").h(headers).b(body);
511
+ return b.build();
816
512
  };
817
513
  export const se_GetDeviceDefinitionVersionCommand = async (input, context) => {
818
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
514
+ const b = rb(input, context);
819
515
  const headers = {};
820
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
821
- "/greengrass/definition/devices/{DeviceDefinitionId}/versions/{DeviceDefinitionVersionId}";
822
- resolvedPath = __resolvedPath(resolvedPath, input, "DeviceDefinitionId", () => input.DeviceDefinitionId, "{DeviceDefinitionId}", false);
823
- resolvedPath = __resolvedPath(resolvedPath, input, "DeviceDefinitionVersionId", () => input.DeviceDefinitionVersionId, "{DeviceDefinitionVersionId}", false);
516
+ b.bp("/greengrass/definition/devices/{DeviceDefinitionId}/versions/{DeviceDefinitionVersionId}");
517
+ b.p("DeviceDefinitionId", () => input.DeviceDefinitionId, "{DeviceDefinitionId}", false);
518
+ b.p("DeviceDefinitionVersionId", () => input.DeviceDefinitionVersionId, "{DeviceDefinitionVersionId}", false);
824
519
  const query = map({
825
- NextToken: [, input.NextToken],
520
+ [_NT]: [, input[_NT]],
826
521
  });
827
522
  let body;
828
- return new __HttpRequest({
829
- protocol,
830
- hostname,
831
- port,
832
- method: "GET",
833
- headers,
834
- path: resolvedPath,
835
- query,
836
- body,
837
- });
523
+ b.m("GET").h(headers).q(query).b(body);
524
+ return b.build();
838
525
  };
839
526
  export const se_GetFunctionDefinitionCommand = async (input, context) => {
840
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
527
+ const b = rb(input, context);
841
528
  const headers = {};
842
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
843
- "/greengrass/definition/functions/{FunctionDefinitionId}";
844
- resolvedPath = __resolvedPath(resolvedPath, input, "FunctionDefinitionId", () => input.FunctionDefinitionId, "{FunctionDefinitionId}", false);
529
+ b.bp("/greengrass/definition/functions/{FunctionDefinitionId}");
530
+ b.p("FunctionDefinitionId", () => input.FunctionDefinitionId, "{FunctionDefinitionId}", false);
845
531
  let body;
846
- return new __HttpRequest({
847
- protocol,
848
- hostname,
849
- port,
850
- method: "GET",
851
- headers,
852
- path: resolvedPath,
853
- body,
854
- });
532
+ b.m("GET").h(headers).b(body);
533
+ return b.build();
855
534
  };
856
535
  export const se_GetFunctionDefinitionVersionCommand = async (input, context) => {
857
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
536
+ const b = rb(input, context);
858
537
  const headers = {};
859
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
860
- "/greengrass/definition/functions/{FunctionDefinitionId}/versions/{FunctionDefinitionVersionId}";
861
- resolvedPath = __resolvedPath(resolvedPath, input, "FunctionDefinitionId", () => input.FunctionDefinitionId, "{FunctionDefinitionId}", false);
862
- resolvedPath = __resolvedPath(resolvedPath, input, "FunctionDefinitionVersionId", () => input.FunctionDefinitionVersionId, "{FunctionDefinitionVersionId}", false);
538
+ b.bp("/greengrass/definition/functions/{FunctionDefinitionId}/versions/{FunctionDefinitionVersionId}");
539
+ b.p("FunctionDefinitionId", () => input.FunctionDefinitionId, "{FunctionDefinitionId}", false);
540
+ b.p("FunctionDefinitionVersionId", () => input.FunctionDefinitionVersionId, "{FunctionDefinitionVersionId}", false);
863
541
  const query = map({
864
- NextToken: [, input.NextToken],
542
+ [_NT]: [, input[_NT]],
865
543
  });
866
544
  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
- });
545
+ b.m("GET").h(headers).q(query).b(body);
546
+ return b.build();
877
547
  };
878
548
  export const se_GetGroupCommand = async (input, context) => {
879
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
549
+ const b = rb(input, context);
880
550
  const headers = {};
881
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/groups/{GroupId}";
882
- resolvedPath = __resolvedPath(resolvedPath, input, "GroupId", () => input.GroupId, "{GroupId}", false);
551
+ b.bp("/greengrass/groups/{GroupId}");
552
+ b.p("GroupId", () => input.GroupId, "{GroupId}", false);
883
553
  let body;
884
- return new __HttpRequest({
885
- protocol,
886
- hostname,
887
- port,
888
- method: "GET",
889
- headers,
890
- path: resolvedPath,
891
- body,
892
- });
554
+ b.m("GET").h(headers).b(body);
555
+ return b.build();
893
556
  };
894
557
  export const se_GetGroupCertificateAuthorityCommand = async (input, context) => {
895
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
558
+ const b = rb(input, context);
896
559
  const headers = {};
897
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
898
- "/greengrass/groups/{GroupId}/certificateauthorities/{CertificateAuthorityId}";
899
- resolvedPath = __resolvedPath(resolvedPath, input, "CertificateAuthorityId", () => input.CertificateAuthorityId, "{CertificateAuthorityId}", false);
900
- resolvedPath = __resolvedPath(resolvedPath, input, "GroupId", () => input.GroupId, "{GroupId}", false);
560
+ b.bp("/greengrass/groups/{GroupId}/certificateauthorities/{CertificateAuthorityId}");
561
+ b.p("CertificateAuthorityId", () => input.CertificateAuthorityId, "{CertificateAuthorityId}", false);
562
+ b.p("GroupId", () => input.GroupId, "{GroupId}", false);
901
563
  let body;
902
- return new __HttpRequest({
903
- protocol,
904
- hostname,
905
- port,
906
- method: "GET",
907
- headers,
908
- path: resolvedPath,
909
- body,
910
- });
564
+ b.m("GET").h(headers).b(body);
565
+ return b.build();
911
566
  };
912
567
  export const se_GetGroupCertificateConfigurationCommand = async (input, context) => {
913
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
568
+ const b = rb(input, context);
914
569
  const headers = {};
915
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
916
- "/greengrass/groups/{GroupId}/certificateauthorities/configuration/expiry";
917
- resolvedPath = __resolvedPath(resolvedPath, input, "GroupId", () => input.GroupId, "{GroupId}", false);
570
+ b.bp("/greengrass/groups/{GroupId}/certificateauthorities/configuration/expiry");
571
+ b.p("GroupId", () => input.GroupId, "{GroupId}", false);
918
572
  let body;
919
- return new __HttpRequest({
920
- protocol,
921
- hostname,
922
- port,
923
- method: "GET",
924
- headers,
925
- path: resolvedPath,
926
- body,
927
- });
573
+ b.m("GET").h(headers).b(body);
574
+ return b.build();
928
575
  };
929
576
  export const se_GetGroupVersionCommand = async (input, context) => {
930
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
577
+ const b = rb(input, context);
931
578
  const headers = {};
932
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
933
- "/greengrass/groups/{GroupId}/versions/{GroupVersionId}";
934
- resolvedPath = __resolvedPath(resolvedPath, input, "GroupId", () => input.GroupId, "{GroupId}", false);
935
- resolvedPath = __resolvedPath(resolvedPath, input, "GroupVersionId", () => input.GroupVersionId, "{GroupVersionId}", false);
579
+ b.bp("/greengrass/groups/{GroupId}/versions/{GroupVersionId}");
580
+ b.p("GroupId", () => input.GroupId, "{GroupId}", false);
581
+ b.p("GroupVersionId", () => input.GroupVersionId, "{GroupVersionId}", false);
936
582
  let body;
937
- return new __HttpRequest({
938
- protocol,
939
- hostname,
940
- port,
941
- method: "GET",
942
- headers,
943
- path: resolvedPath,
944
- body,
945
- });
583
+ b.m("GET").h(headers).b(body);
584
+ return b.build();
946
585
  };
947
586
  export const se_GetLoggerDefinitionCommand = async (input, context) => {
948
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
587
+ const b = rb(input, context);
949
588
  const headers = {};
950
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
951
- "/greengrass/definition/loggers/{LoggerDefinitionId}";
952
- resolvedPath = __resolvedPath(resolvedPath, input, "LoggerDefinitionId", () => input.LoggerDefinitionId, "{LoggerDefinitionId}", false);
589
+ b.bp("/greengrass/definition/loggers/{LoggerDefinitionId}");
590
+ b.p("LoggerDefinitionId", () => input.LoggerDefinitionId, "{LoggerDefinitionId}", false);
953
591
  let body;
954
- return new __HttpRequest({
955
- protocol,
956
- hostname,
957
- port,
958
- method: "GET",
959
- headers,
960
- path: resolvedPath,
961
- body,
962
- });
592
+ b.m("GET").h(headers).b(body);
593
+ return b.build();
963
594
  };
964
595
  export const se_GetLoggerDefinitionVersionCommand = async (input, context) => {
965
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
596
+ const b = rb(input, context);
966
597
  const headers = {};
967
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
968
- "/greengrass/definition/loggers/{LoggerDefinitionId}/versions/{LoggerDefinitionVersionId}";
969
- resolvedPath = __resolvedPath(resolvedPath, input, "LoggerDefinitionId", () => input.LoggerDefinitionId, "{LoggerDefinitionId}", false);
970
- resolvedPath = __resolvedPath(resolvedPath, input, "LoggerDefinitionVersionId", () => input.LoggerDefinitionVersionId, "{LoggerDefinitionVersionId}", false);
598
+ b.bp("/greengrass/definition/loggers/{LoggerDefinitionId}/versions/{LoggerDefinitionVersionId}");
599
+ b.p("LoggerDefinitionId", () => input.LoggerDefinitionId, "{LoggerDefinitionId}", false);
600
+ b.p("LoggerDefinitionVersionId", () => input.LoggerDefinitionVersionId, "{LoggerDefinitionVersionId}", false);
971
601
  const query = map({
972
- NextToken: [, input.NextToken],
602
+ [_NT]: [, input[_NT]],
973
603
  });
974
604
  let body;
975
- return new __HttpRequest({
976
- protocol,
977
- hostname,
978
- port,
979
- method: "GET",
980
- headers,
981
- path: resolvedPath,
982
- query,
983
- body,
984
- });
605
+ b.m("GET").h(headers).q(query).b(body);
606
+ return b.build();
985
607
  };
986
608
  export const se_GetResourceDefinitionCommand = async (input, context) => {
987
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
609
+ const b = rb(input, context);
988
610
  const headers = {};
989
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
990
- "/greengrass/definition/resources/{ResourceDefinitionId}";
991
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceDefinitionId", () => input.ResourceDefinitionId, "{ResourceDefinitionId}", false);
611
+ b.bp("/greengrass/definition/resources/{ResourceDefinitionId}");
612
+ b.p("ResourceDefinitionId", () => input.ResourceDefinitionId, "{ResourceDefinitionId}", false);
992
613
  let body;
993
- return new __HttpRequest({
994
- protocol,
995
- hostname,
996
- port,
997
- method: "GET",
998
- headers,
999
- path: resolvedPath,
1000
- body,
1001
- });
614
+ b.m("GET").h(headers).b(body);
615
+ return b.build();
1002
616
  };
1003
617
  export const se_GetResourceDefinitionVersionCommand = async (input, context) => {
1004
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
618
+ const b = rb(input, context);
1005
619
  const headers = {};
1006
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1007
- "/greengrass/definition/resources/{ResourceDefinitionId}/versions/{ResourceDefinitionVersionId}";
1008
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceDefinitionId", () => input.ResourceDefinitionId, "{ResourceDefinitionId}", false);
1009
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceDefinitionVersionId", () => input.ResourceDefinitionVersionId, "{ResourceDefinitionVersionId}", false);
620
+ b.bp("/greengrass/definition/resources/{ResourceDefinitionId}/versions/{ResourceDefinitionVersionId}");
621
+ b.p("ResourceDefinitionId", () => input.ResourceDefinitionId, "{ResourceDefinitionId}", false);
622
+ b.p("ResourceDefinitionVersionId", () => input.ResourceDefinitionVersionId, "{ResourceDefinitionVersionId}", false);
1010
623
  let body;
1011
- return new __HttpRequest({
1012
- protocol,
1013
- hostname,
1014
- port,
1015
- method: "GET",
1016
- headers,
1017
- path: resolvedPath,
1018
- body,
1019
- });
624
+ b.m("GET").h(headers).b(body);
625
+ return b.build();
1020
626
  };
1021
627
  export const se_GetServiceRoleForAccountCommand = async (input, context) => {
1022
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
628
+ const b = rb(input, context);
1023
629
  const headers = {
1024
630
  "content-type": "application/json",
1025
631
  };
1026
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/servicerole";
632
+ b.bp("/greengrass/servicerole");
1027
633
  let body;
1028
634
  body = "";
1029
- return new __HttpRequest({
1030
- protocol,
1031
- hostname,
1032
- port,
1033
- method: "GET",
1034
- headers,
1035
- path: resolvedPath,
1036
- body,
1037
- });
635
+ b.m("GET").h(headers).b(body);
636
+ return b.build();
1038
637
  };
1039
638
  export const se_GetSubscriptionDefinitionCommand = async (input, context) => {
1040
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
639
+ const b = rb(input, context);
1041
640
  const headers = {};
1042
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1043
- "/greengrass/definition/subscriptions/{SubscriptionDefinitionId}";
1044
- resolvedPath = __resolvedPath(resolvedPath, input, "SubscriptionDefinitionId", () => input.SubscriptionDefinitionId, "{SubscriptionDefinitionId}", false);
641
+ b.bp("/greengrass/definition/subscriptions/{SubscriptionDefinitionId}");
642
+ b.p("SubscriptionDefinitionId", () => input.SubscriptionDefinitionId, "{SubscriptionDefinitionId}", false);
1045
643
  let body;
1046
- return new __HttpRequest({
1047
- protocol,
1048
- hostname,
1049
- port,
1050
- method: "GET",
1051
- headers,
1052
- path: resolvedPath,
1053
- body,
1054
- });
644
+ b.m("GET").h(headers).b(body);
645
+ return b.build();
1055
646
  };
1056
647
  export const se_GetSubscriptionDefinitionVersionCommand = async (input, context) => {
1057
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
648
+ const b = rb(input, context);
1058
649
  const headers = {};
1059
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1060
- "/greengrass/definition/subscriptions/{SubscriptionDefinitionId}/versions/{SubscriptionDefinitionVersionId}";
1061
- resolvedPath = __resolvedPath(resolvedPath, input, "SubscriptionDefinitionId", () => input.SubscriptionDefinitionId, "{SubscriptionDefinitionId}", false);
1062
- resolvedPath = __resolvedPath(resolvedPath, input, "SubscriptionDefinitionVersionId", () => input.SubscriptionDefinitionVersionId, "{SubscriptionDefinitionVersionId}", false);
650
+ b.bp("/greengrass/definition/subscriptions/{SubscriptionDefinitionId}/versions/{SubscriptionDefinitionVersionId}");
651
+ b.p("SubscriptionDefinitionId", () => input.SubscriptionDefinitionId, "{SubscriptionDefinitionId}", false);
652
+ b.p("SubscriptionDefinitionVersionId", () => input.SubscriptionDefinitionVersionId, "{SubscriptionDefinitionVersionId}", false);
1063
653
  const query = map({
1064
- NextToken: [, input.NextToken],
654
+ [_NT]: [, input[_NT]],
1065
655
  });
1066
656
  let body;
1067
- return new __HttpRequest({
1068
- protocol,
1069
- hostname,
1070
- port,
1071
- method: "GET",
1072
- headers,
1073
- path: resolvedPath,
1074
- query,
1075
- body,
1076
- });
657
+ b.m("GET").h(headers).q(query).b(body);
658
+ return b.build();
1077
659
  };
1078
660
  export const se_GetThingRuntimeConfigurationCommand = async (input, context) => {
1079
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
661
+ const b = rb(input, context);
1080
662
  const headers = {};
1081
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1082
- "/greengrass/things/{ThingName}/runtimeconfig";
1083
- resolvedPath = __resolvedPath(resolvedPath, input, "ThingName", () => input.ThingName, "{ThingName}", false);
663
+ b.bp("/greengrass/things/{ThingName}/runtimeconfig");
664
+ b.p("ThingName", () => input.ThingName, "{ThingName}", false);
1084
665
  let body;
1085
- return new __HttpRequest({
1086
- protocol,
1087
- hostname,
1088
- port,
1089
- method: "GET",
1090
- headers,
1091
- path: resolvedPath,
1092
- body,
1093
- });
666
+ b.m("GET").h(headers).b(body);
667
+ return b.build();
1094
668
  };
1095
669
  export const se_ListBulkDeploymentDetailedReportsCommand = async (input, context) => {
1096
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
670
+ const b = rb(input, context);
1097
671
  const headers = {};
1098
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1099
- "/greengrass/bulk/deployments/{BulkDeploymentId}/detailed-reports";
1100
- resolvedPath = __resolvedPath(resolvedPath, input, "BulkDeploymentId", () => input.BulkDeploymentId, "{BulkDeploymentId}", false);
672
+ b.bp("/greengrass/bulk/deployments/{BulkDeploymentId}/detailed-reports");
673
+ b.p("BulkDeploymentId", () => input.BulkDeploymentId, "{BulkDeploymentId}", false);
1101
674
  const query = map({
1102
- MaxResults: [, input.MaxResults],
1103
- NextToken: [, input.NextToken],
675
+ [_MR]: [, input[_MR]],
676
+ [_NT]: [, input[_NT]],
1104
677
  });
1105
678
  let body;
1106
- return new __HttpRequest({
1107
- protocol,
1108
- hostname,
1109
- port,
1110
- method: "GET",
1111
- headers,
1112
- path: resolvedPath,
1113
- query,
1114
- body,
1115
- });
679
+ b.m("GET").h(headers).q(query).b(body);
680
+ return b.build();
1116
681
  };
1117
682
  export const se_ListBulkDeploymentsCommand = async (input, context) => {
1118
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
683
+ const b = rb(input, context);
1119
684
  const headers = {};
1120
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/bulk/deployments";
685
+ b.bp("/greengrass/bulk/deployments");
1121
686
  const query = map({
1122
- MaxResults: [, input.MaxResults],
1123
- NextToken: [, input.NextToken],
687
+ [_MR]: [, input[_MR]],
688
+ [_NT]: [, input[_NT]],
1124
689
  });
1125
690
  let body;
1126
- return new __HttpRequest({
1127
- protocol,
1128
- hostname,
1129
- port,
1130
- method: "GET",
1131
- headers,
1132
- path: resolvedPath,
1133
- query,
1134
- body,
1135
- });
691
+ b.m("GET").h(headers).q(query).b(body);
692
+ return b.build();
1136
693
  };
1137
694
  export const se_ListConnectorDefinitionsCommand = async (input, context) => {
1138
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
695
+ const b = rb(input, context);
1139
696
  const headers = {};
1140
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/definition/connectors";
697
+ b.bp("/greengrass/definition/connectors");
1141
698
  const query = map({
1142
- MaxResults: [, input.MaxResults],
1143
- NextToken: [, input.NextToken],
699
+ [_MR]: [, input[_MR]],
700
+ [_NT]: [, input[_NT]],
1144
701
  });
1145
702
  let body;
1146
- return new __HttpRequest({
1147
- protocol,
1148
- hostname,
1149
- port,
1150
- method: "GET",
1151
- headers,
1152
- path: resolvedPath,
1153
- query,
1154
- body,
1155
- });
703
+ b.m("GET").h(headers).q(query).b(body);
704
+ return b.build();
1156
705
  };
1157
706
  export const se_ListConnectorDefinitionVersionsCommand = async (input, context) => {
1158
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
707
+ const b = rb(input, context);
1159
708
  const headers = {};
1160
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1161
- "/greengrass/definition/connectors/{ConnectorDefinitionId}/versions";
1162
- resolvedPath = __resolvedPath(resolvedPath, input, "ConnectorDefinitionId", () => input.ConnectorDefinitionId, "{ConnectorDefinitionId}", false);
709
+ b.bp("/greengrass/definition/connectors/{ConnectorDefinitionId}/versions");
710
+ b.p("ConnectorDefinitionId", () => input.ConnectorDefinitionId, "{ConnectorDefinitionId}", false);
1163
711
  const query = map({
1164
- MaxResults: [, input.MaxResults],
1165
- NextToken: [, input.NextToken],
712
+ [_MR]: [, input[_MR]],
713
+ [_NT]: [, input[_NT]],
1166
714
  });
1167
715
  let body;
1168
- return new __HttpRequest({
1169
- protocol,
1170
- hostname,
1171
- port,
1172
- method: "GET",
1173
- headers,
1174
- path: resolvedPath,
1175
- query,
1176
- body,
1177
- });
716
+ b.m("GET").h(headers).q(query).b(body);
717
+ return b.build();
1178
718
  };
1179
719
  export const se_ListCoreDefinitionsCommand = async (input, context) => {
1180
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
720
+ const b = rb(input, context);
1181
721
  const headers = {};
1182
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/definition/cores";
722
+ b.bp("/greengrass/definition/cores");
1183
723
  const query = map({
1184
- MaxResults: [, input.MaxResults],
1185
- NextToken: [, input.NextToken],
724
+ [_MR]: [, input[_MR]],
725
+ [_NT]: [, input[_NT]],
1186
726
  });
1187
727
  let body;
1188
- return new __HttpRequest({
1189
- protocol,
1190
- hostname,
1191
- port,
1192
- method: "GET",
1193
- headers,
1194
- path: resolvedPath,
1195
- query,
1196
- body,
1197
- });
728
+ b.m("GET").h(headers).q(query).b(body);
729
+ return b.build();
1198
730
  };
1199
731
  export const se_ListCoreDefinitionVersionsCommand = async (input, context) => {
1200
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
732
+ const b = rb(input, context);
1201
733
  const headers = {};
1202
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1203
- "/greengrass/definition/cores/{CoreDefinitionId}/versions";
1204
- resolvedPath = __resolvedPath(resolvedPath, input, "CoreDefinitionId", () => input.CoreDefinitionId, "{CoreDefinitionId}", false);
734
+ b.bp("/greengrass/definition/cores/{CoreDefinitionId}/versions");
735
+ b.p("CoreDefinitionId", () => input.CoreDefinitionId, "{CoreDefinitionId}", false);
1205
736
  const query = map({
1206
- MaxResults: [, input.MaxResults],
1207
- NextToken: [, input.NextToken],
737
+ [_MR]: [, input[_MR]],
738
+ [_NT]: [, input[_NT]],
1208
739
  });
1209
740
  let body;
1210
- return new __HttpRequest({
1211
- protocol,
1212
- hostname,
1213
- port,
1214
- method: "GET",
1215
- headers,
1216
- path: resolvedPath,
1217
- query,
1218
- body,
1219
- });
741
+ b.m("GET").h(headers).q(query).b(body);
742
+ return b.build();
1220
743
  };
1221
744
  export const se_ListDeploymentsCommand = async (input, context) => {
1222
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
745
+ const b = rb(input, context);
1223
746
  const headers = {};
1224
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/groups/{GroupId}/deployments";
1225
- resolvedPath = __resolvedPath(resolvedPath, input, "GroupId", () => input.GroupId, "{GroupId}", false);
747
+ b.bp("/greengrass/groups/{GroupId}/deployments");
748
+ b.p("GroupId", () => input.GroupId, "{GroupId}", false);
1226
749
  const query = map({
1227
- MaxResults: [, input.MaxResults],
1228
- NextToken: [, input.NextToken],
750
+ [_MR]: [, input[_MR]],
751
+ [_NT]: [, input[_NT]],
1229
752
  });
1230
753
  let body;
1231
- return new __HttpRequest({
1232
- protocol,
1233
- hostname,
1234
- port,
1235
- method: "GET",
1236
- headers,
1237
- path: resolvedPath,
1238
- query,
1239
- body,
1240
- });
754
+ b.m("GET").h(headers).q(query).b(body);
755
+ return b.build();
1241
756
  };
1242
757
  export const se_ListDeviceDefinitionsCommand = async (input, context) => {
1243
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
758
+ const b = rb(input, context);
1244
759
  const headers = {};
1245
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/definition/devices";
760
+ b.bp("/greengrass/definition/devices");
1246
761
  const query = map({
1247
- MaxResults: [, input.MaxResults],
1248
- NextToken: [, input.NextToken],
762
+ [_MR]: [, input[_MR]],
763
+ [_NT]: [, input[_NT]],
1249
764
  });
1250
765
  let body;
1251
- return new __HttpRequest({
1252
- protocol,
1253
- hostname,
1254
- port,
1255
- method: "GET",
1256
- headers,
1257
- path: resolvedPath,
1258
- query,
1259
- body,
1260
- });
766
+ b.m("GET").h(headers).q(query).b(body);
767
+ return b.build();
1261
768
  };
1262
769
  export const se_ListDeviceDefinitionVersionsCommand = async (input, context) => {
1263
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
770
+ const b = rb(input, context);
1264
771
  const headers = {};
1265
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1266
- "/greengrass/definition/devices/{DeviceDefinitionId}/versions";
1267
- resolvedPath = __resolvedPath(resolvedPath, input, "DeviceDefinitionId", () => input.DeviceDefinitionId, "{DeviceDefinitionId}", false);
772
+ b.bp("/greengrass/definition/devices/{DeviceDefinitionId}/versions");
773
+ b.p("DeviceDefinitionId", () => input.DeviceDefinitionId, "{DeviceDefinitionId}", false);
1268
774
  const query = map({
1269
- MaxResults: [, input.MaxResults],
1270
- NextToken: [, input.NextToken],
775
+ [_MR]: [, input[_MR]],
776
+ [_NT]: [, input[_NT]],
1271
777
  });
1272
778
  let body;
1273
- return new __HttpRequest({
1274
- protocol,
1275
- hostname,
1276
- port,
1277
- method: "GET",
1278
- headers,
1279
- path: resolvedPath,
1280
- query,
1281
- body,
1282
- });
779
+ b.m("GET").h(headers).q(query).b(body);
780
+ return b.build();
1283
781
  };
1284
782
  export const se_ListFunctionDefinitionsCommand = async (input, context) => {
1285
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
783
+ const b = rb(input, context);
1286
784
  const headers = {};
1287
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/definition/functions";
785
+ b.bp("/greengrass/definition/functions");
1288
786
  const query = map({
1289
- MaxResults: [, input.MaxResults],
1290
- NextToken: [, input.NextToken],
787
+ [_MR]: [, input[_MR]],
788
+ [_NT]: [, input[_NT]],
1291
789
  });
1292
790
  let body;
1293
- return new __HttpRequest({
1294
- protocol,
1295
- hostname,
1296
- port,
1297
- method: "GET",
1298
- headers,
1299
- path: resolvedPath,
1300
- query,
1301
- body,
1302
- });
791
+ b.m("GET").h(headers).q(query).b(body);
792
+ return b.build();
1303
793
  };
1304
794
  export const se_ListFunctionDefinitionVersionsCommand = async (input, context) => {
1305
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
795
+ const b = rb(input, context);
1306
796
  const headers = {};
1307
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1308
- "/greengrass/definition/functions/{FunctionDefinitionId}/versions";
1309
- resolvedPath = __resolvedPath(resolvedPath, input, "FunctionDefinitionId", () => input.FunctionDefinitionId, "{FunctionDefinitionId}", false);
797
+ b.bp("/greengrass/definition/functions/{FunctionDefinitionId}/versions");
798
+ b.p("FunctionDefinitionId", () => input.FunctionDefinitionId, "{FunctionDefinitionId}", false);
1310
799
  const query = map({
1311
- MaxResults: [, input.MaxResults],
1312
- NextToken: [, input.NextToken],
800
+ [_MR]: [, input[_MR]],
801
+ [_NT]: [, input[_NT]],
1313
802
  });
1314
803
  let body;
1315
- return new __HttpRequest({
1316
- protocol,
1317
- hostname,
1318
- port,
1319
- method: "GET",
1320
- headers,
1321
- path: resolvedPath,
1322
- query,
1323
- body,
1324
- });
804
+ b.m("GET").h(headers).q(query).b(body);
805
+ return b.build();
1325
806
  };
1326
807
  export const se_ListGroupCertificateAuthoritiesCommand = async (input, context) => {
1327
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
808
+ const b = rb(input, context);
1328
809
  const headers = {};
1329
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1330
- "/greengrass/groups/{GroupId}/certificateauthorities";
1331
- resolvedPath = __resolvedPath(resolvedPath, input, "GroupId", () => input.GroupId, "{GroupId}", false);
810
+ b.bp("/greengrass/groups/{GroupId}/certificateauthorities");
811
+ b.p("GroupId", () => input.GroupId, "{GroupId}", false);
1332
812
  let body;
1333
- return new __HttpRequest({
1334
- protocol,
1335
- hostname,
1336
- port,
1337
- method: "GET",
1338
- headers,
1339
- path: resolvedPath,
1340
- body,
1341
- });
813
+ b.m("GET").h(headers).b(body);
814
+ return b.build();
1342
815
  };
1343
816
  export const se_ListGroupsCommand = async (input, context) => {
1344
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
817
+ const b = rb(input, context);
1345
818
  const headers = {};
1346
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/groups";
819
+ b.bp("/greengrass/groups");
1347
820
  const query = map({
1348
- MaxResults: [, input.MaxResults],
1349
- NextToken: [, input.NextToken],
821
+ [_MR]: [, input[_MR]],
822
+ [_NT]: [, input[_NT]],
1350
823
  });
1351
824
  let body;
1352
- return new __HttpRequest({
1353
- protocol,
1354
- hostname,
1355
- port,
1356
- method: "GET",
1357
- headers,
1358
- path: resolvedPath,
1359
- query,
1360
- body,
1361
- });
825
+ b.m("GET").h(headers).q(query).b(body);
826
+ return b.build();
1362
827
  };
1363
828
  export const se_ListGroupVersionsCommand = async (input, context) => {
1364
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
829
+ const b = rb(input, context);
1365
830
  const headers = {};
1366
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/groups/{GroupId}/versions";
1367
- resolvedPath = __resolvedPath(resolvedPath, input, "GroupId", () => input.GroupId, "{GroupId}", false);
831
+ b.bp("/greengrass/groups/{GroupId}/versions");
832
+ b.p("GroupId", () => input.GroupId, "{GroupId}", false);
1368
833
  const query = map({
1369
- MaxResults: [, input.MaxResults],
1370
- NextToken: [, input.NextToken],
834
+ [_MR]: [, input[_MR]],
835
+ [_NT]: [, input[_NT]],
1371
836
  });
1372
837
  let body;
1373
- return new __HttpRequest({
1374
- protocol,
1375
- hostname,
1376
- port,
1377
- method: "GET",
1378
- headers,
1379
- path: resolvedPath,
1380
- query,
1381
- body,
1382
- });
838
+ b.m("GET").h(headers).q(query).b(body);
839
+ return b.build();
1383
840
  };
1384
841
  export const se_ListLoggerDefinitionsCommand = async (input, context) => {
1385
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
842
+ const b = rb(input, context);
1386
843
  const headers = {};
1387
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/definition/loggers";
844
+ b.bp("/greengrass/definition/loggers");
1388
845
  const query = map({
1389
- MaxResults: [, input.MaxResults],
1390
- NextToken: [, input.NextToken],
846
+ [_MR]: [, input[_MR]],
847
+ [_NT]: [, input[_NT]],
1391
848
  });
1392
849
  let body;
1393
- return new __HttpRequest({
1394
- protocol,
1395
- hostname,
1396
- port,
1397
- method: "GET",
1398
- headers,
1399
- path: resolvedPath,
1400
- query,
1401
- body,
1402
- });
850
+ b.m("GET").h(headers).q(query).b(body);
851
+ return b.build();
1403
852
  };
1404
853
  export const se_ListLoggerDefinitionVersionsCommand = async (input, context) => {
1405
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
854
+ const b = rb(input, context);
1406
855
  const headers = {};
1407
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1408
- "/greengrass/definition/loggers/{LoggerDefinitionId}/versions";
1409
- resolvedPath = __resolvedPath(resolvedPath, input, "LoggerDefinitionId", () => input.LoggerDefinitionId, "{LoggerDefinitionId}", false);
856
+ b.bp("/greengrass/definition/loggers/{LoggerDefinitionId}/versions");
857
+ b.p("LoggerDefinitionId", () => input.LoggerDefinitionId, "{LoggerDefinitionId}", false);
1410
858
  const query = map({
1411
- MaxResults: [, input.MaxResults],
1412
- NextToken: [, input.NextToken],
859
+ [_MR]: [, input[_MR]],
860
+ [_NT]: [, input[_NT]],
1413
861
  });
1414
862
  let body;
1415
- return new __HttpRequest({
1416
- protocol,
1417
- hostname,
1418
- port,
1419
- method: "GET",
1420
- headers,
1421
- path: resolvedPath,
1422
- query,
1423
- body,
1424
- });
863
+ b.m("GET").h(headers).q(query).b(body);
864
+ return b.build();
1425
865
  };
1426
866
  export const se_ListResourceDefinitionsCommand = async (input, context) => {
1427
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
867
+ const b = rb(input, context);
1428
868
  const headers = {};
1429
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/definition/resources";
869
+ b.bp("/greengrass/definition/resources");
1430
870
  const query = map({
1431
- MaxResults: [, input.MaxResults],
1432
- NextToken: [, input.NextToken],
871
+ [_MR]: [, input[_MR]],
872
+ [_NT]: [, input[_NT]],
1433
873
  });
1434
874
  let body;
1435
- return new __HttpRequest({
1436
- protocol,
1437
- hostname,
1438
- port,
1439
- method: "GET",
1440
- headers,
1441
- path: resolvedPath,
1442
- query,
1443
- body,
1444
- });
875
+ b.m("GET").h(headers).q(query).b(body);
876
+ return b.build();
1445
877
  };
1446
878
  export const se_ListResourceDefinitionVersionsCommand = async (input, context) => {
1447
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
879
+ const b = rb(input, context);
1448
880
  const headers = {};
1449
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1450
- "/greengrass/definition/resources/{ResourceDefinitionId}/versions";
1451
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceDefinitionId", () => input.ResourceDefinitionId, "{ResourceDefinitionId}", false);
881
+ b.bp("/greengrass/definition/resources/{ResourceDefinitionId}/versions");
882
+ b.p("ResourceDefinitionId", () => input.ResourceDefinitionId, "{ResourceDefinitionId}", false);
1452
883
  const query = map({
1453
- MaxResults: [, input.MaxResults],
1454
- NextToken: [, input.NextToken],
884
+ [_MR]: [, input[_MR]],
885
+ [_NT]: [, input[_NT]],
1455
886
  });
1456
887
  let body;
1457
- return new __HttpRequest({
1458
- protocol,
1459
- hostname,
1460
- port,
1461
- method: "GET",
1462
- headers,
1463
- path: resolvedPath,
1464
- query,
1465
- body,
1466
- });
888
+ b.m("GET").h(headers).q(query).b(body);
889
+ return b.build();
1467
890
  };
1468
891
  export const se_ListSubscriptionDefinitionsCommand = async (input, context) => {
1469
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
892
+ const b = rb(input, context);
1470
893
  const headers = {};
1471
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/definition/subscriptions";
894
+ b.bp("/greengrass/definition/subscriptions");
1472
895
  const query = map({
1473
- MaxResults: [, input.MaxResults],
1474
- NextToken: [, input.NextToken],
896
+ [_MR]: [, input[_MR]],
897
+ [_NT]: [, input[_NT]],
1475
898
  });
1476
899
  let body;
1477
- return new __HttpRequest({
1478
- protocol,
1479
- hostname,
1480
- port,
1481
- method: "GET",
1482
- headers,
1483
- path: resolvedPath,
1484
- query,
1485
- body,
1486
- });
900
+ b.m("GET").h(headers).q(query).b(body);
901
+ return b.build();
1487
902
  };
1488
903
  export const se_ListSubscriptionDefinitionVersionsCommand = async (input, context) => {
1489
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
904
+ const b = rb(input, context);
1490
905
  const headers = {};
1491
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1492
- "/greengrass/definition/subscriptions/{SubscriptionDefinitionId}/versions";
1493
- resolvedPath = __resolvedPath(resolvedPath, input, "SubscriptionDefinitionId", () => input.SubscriptionDefinitionId, "{SubscriptionDefinitionId}", false);
906
+ b.bp("/greengrass/definition/subscriptions/{SubscriptionDefinitionId}/versions");
907
+ b.p("SubscriptionDefinitionId", () => input.SubscriptionDefinitionId, "{SubscriptionDefinitionId}", false);
1494
908
  const query = map({
1495
- MaxResults: [, input.MaxResults],
1496
- NextToken: [, input.NextToken],
909
+ [_MR]: [, input[_MR]],
910
+ [_NT]: [, input[_NT]],
1497
911
  });
1498
912
  let body;
1499
- return new __HttpRequest({
1500
- protocol,
1501
- hostname,
1502
- port,
1503
- method: "GET",
1504
- headers,
1505
- path: resolvedPath,
1506
- query,
1507
- body,
1508
- });
913
+ b.m("GET").h(headers).q(query).b(body);
914
+ return b.build();
1509
915
  };
1510
916
  export const se_ListTagsForResourceCommand = async (input, context) => {
1511
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
917
+ const b = rb(input, context);
1512
918
  const headers = {};
1513
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{ResourceArn}";
1514
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
919
+ b.bp("/tags/{ResourceArn}");
920
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1515
921
  let body;
1516
- return new __HttpRequest({
1517
- protocol,
1518
- hostname,
1519
- port,
1520
- method: "GET",
1521
- headers,
1522
- path: resolvedPath,
1523
- body,
1524
- });
922
+ b.m("GET").h(headers).b(body);
923
+ return b.build();
1525
924
  };
1526
925
  export const se_ResetDeploymentsCommand = async (input, context) => {
1527
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
926
+ const b = rb(input, context);
1528
927
  const headers = map({}, isSerializableHeaderValue, {
1529
928
  "content-type": "application/json",
1530
- "x-amzn-client-token": input.AmznClientToken,
929
+ [_xact]: input[_ACT],
1531
930
  });
1532
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1533
- "/greengrass/groups/{GroupId}/deployments/$reset";
1534
- resolvedPath = __resolvedPath(resolvedPath, input, "GroupId", () => input.GroupId, "{GroupId}", false);
931
+ b.bp("/greengrass/groups/{GroupId}/deployments/$reset");
932
+ b.p("GroupId", () => input.GroupId, "{GroupId}", false);
1535
933
  let body;
1536
934
  body = JSON.stringify(take(input, {
1537
935
  Force: [],
1538
936
  }));
1539
- return new __HttpRequest({
1540
- protocol,
1541
- hostname,
1542
- port,
1543
- method: "POST",
1544
- headers,
1545
- path: resolvedPath,
1546
- body,
1547
- });
937
+ b.m("POST").h(headers).b(body);
938
+ return b.build();
1548
939
  };
1549
940
  export const se_StartBulkDeploymentCommand = async (input, context) => {
1550
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
941
+ const b = rb(input, context);
1551
942
  const headers = map({}, isSerializableHeaderValue, {
1552
943
  "content-type": "application/json",
1553
- "x-amzn-client-token": input.AmznClientToken,
944
+ [_xact]: input[_ACT],
1554
945
  });
1555
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/bulk/deployments";
946
+ b.bp("/greengrass/bulk/deployments");
1556
947
  let body;
1557
948
  body = JSON.stringify(take(input, {
1558
949
  ExecutionRoleArn: [],
1559
950
  InputFileUri: [],
1560
951
  tags: (_) => _json(_),
1561
952
  }));
1562
- return new __HttpRequest({
1563
- protocol,
1564
- hostname,
1565
- port,
1566
- method: "POST",
1567
- headers,
1568
- path: resolvedPath,
1569
- body,
1570
- });
953
+ b.m("POST").h(headers).b(body);
954
+ return b.build();
1571
955
  };
1572
956
  export const se_StopBulkDeploymentCommand = async (input, context) => {
1573
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
957
+ const b = rb(input, context);
1574
958
  const headers = {};
1575
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1576
- "/greengrass/bulk/deployments/{BulkDeploymentId}/$stop";
1577
- resolvedPath = __resolvedPath(resolvedPath, input, "BulkDeploymentId", () => input.BulkDeploymentId, "{BulkDeploymentId}", false);
959
+ b.bp("/greengrass/bulk/deployments/{BulkDeploymentId}/$stop");
960
+ b.p("BulkDeploymentId", () => input.BulkDeploymentId, "{BulkDeploymentId}", false);
1578
961
  let body;
1579
- return new __HttpRequest({
1580
- protocol,
1581
- hostname,
1582
- port,
1583
- method: "PUT",
1584
- headers,
1585
- path: resolvedPath,
1586
- body,
1587
- });
962
+ b.m("PUT").h(headers).b(body);
963
+ return b.build();
1588
964
  };
1589
965
  export const se_TagResourceCommand = async (input, context) => {
1590
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
966
+ const b = rb(input, context);
1591
967
  const headers = {
1592
968
  "content-type": "application/json",
1593
969
  };
1594
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{ResourceArn}";
1595
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
970
+ b.bp("/tags/{ResourceArn}");
971
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1596
972
  let body;
1597
973
  body = JSON.stringify(take(input, {
1598
974
  tags: (_) => _json(_),
1599
975
  }));
1600
- return new __HttpRequest({
1601
- protocol,
1602
- hostname,
1603
- port,
1604
- method: "POST",
1605
- headers,
1606
- path: resolvedPath,
1607
- body,
1608
- });
976
+ b.m("POST").h(headers).b(body);
977
+ return b.build();
1609
978
  };
1610
979
  export const se_UntagResourceCommand = async (input, context) => {
1611
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
980
+ const b = rb(input, context);
1612
981
  const headers = {};
1613
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{ResourceArn}";
1614
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
982
+ b.bp("/tags/{ResourceArn}");
983
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1615
984
  const query = map({
1616
- tagKeys: [
985
+ [_tK]: [
1617
986
  __expectNonNull(input.TagKeys, `TagKeys`) != null,
1618
- () => (input.TagKeys || []).map((_entry) => _entry),
987
+ () => (input[_TK] || []).map((_entry) => _entry),
1619
988
  ],
1620
989
  });
1621
990
  let body;
1622
- return new __HttpRequest({
1623
- protocol,
1624
- hostname,
1625
- port,
1626
- method: "DELETE",
1627
- headers,
1628
- path: resolvedPath,
1629
- query,
1630
- body,
1631
- });
991
+ b.m("DELETE").h(headers).q(query).b(body);
992
+ return b.build();
1632
993
  };
1633
994
  export const se_UpdateConnectivityInfoCommand = async (input, context) => {
1634
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
995
+ const b = rb(input, context);
1635
996
  const headers = {
1636
997
  "content-type": "application/json",
1637
998
  };
1638
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1639
- "/greengrass/things/{ThingName}/connectivityInfo";
1640
- resolvedPath = __resolvedPath(resolvedPath, input, "ThingName", () => input.ThingName, "{ThingName}", false);
999
+ b.bp("/greengrass/things/{ThingName}/connectivityInfo");
1000
+ b.p("ThingName", () => input.ThingName, "{ThingName}", false);
1641
1001
  let body;
1642
1002
  body = JSON.stringify(take(input, {
1643
1003
  ConnectivityInfo: (_) => _json(_),
1644
1004
  }));
1645
- return new __HttpRequest({
1646
- protocol,
1647
- hostname,
1648
- port,
1649
- method: "PUT",
1650
- headers,
1651
- path: resolvedPath,
1652
- body,
1653
- });
1005
+ b.m("PUT").h(headers).b(body);
1006
+ return b.build();
1654
1007
  };
1655
1008
  export const se_UpdateConnectorDefinitionCommand = async (input, context) => {
1656
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1009
+ const b = rb(input, context);
1657
1010
  const headers = {
1658
1011
  "content-type": "application/json",
1659
1012
  };
1660
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1661
- "/greengrass/definition/connectors/{ConnectorDefinitionId}";
1662
- resolvedPath = __resolvedPath(resolvedPath, input, "ConnectorDefinitionId", () => input.ConnectorDefinitionId, "{ConnectorDefinitionId}", false);
1013
+ b.bp("/greengrass/definition/connectors/{ConnectorDefinitionId}");
1014
+ b.p("ConnectorDefinitionId", () => input.ConnectorDefinitionId, "{ConnectorDefinitionId}", false);
1663
1015
  let body;
1664
1016
  body = JSON.stringify(take(input, {
1665
1017
  Name: [],
1666
1018
  }));
1667
- return new __HttpRequest({
1668
- protocol,
1669
- hostname,
1670
- port,
1671
- method: "PUT",
1672
- headers,
1673
- path: resolvedPath,
1674
- body,
1675
- });
1019
+ b.m("PUT").h(headers).b(body);
1020
+ return b.build();
1676
1021
  };
1677
1022
  export const se_UpdateCoreDefinitionCommand = async (input, context) => {
1678
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1023
+ const b = rb(input, context);
1679
1024
  const headers = {
1680
1025
  "content-type": "application/json",
1681
1026
  };
1682
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1683
- "/greengrass/definition/cores/{CoreDefinitionId}";
1684
- resolvedPath = __resolvedPath(resolvedPath, input, "CoreDefinitionId", () => input.CoreDefinitionId, "{CoreDefinitionId}", false);
1027
+ b.bp("/greengrass/definition/cores/{CoreDefinitionId}");
1028
+ b.p("CoreDefinitionId", () => input.CoreDefinitionId, "{CoreDefinitionId}", false);
1685
1029
  let body;
1686
1030
  body = JSON.stringify(take(input, {
1687
1031
  Name: [],
1688
1032
  }));
1689
- return new __HttpRequest({
1690
- protocol,
1691
- hostname,
1692
- port,
1693
- method: "PUT",
1694
- headers,
1695
- path: resolvedPath,
1696
- body,
1697
- });
1033
+ b.m("PUT").h(headers).b(body);
1034
+ return b.build();
1698
1035
  };
1699
1036
  export const se_UpdateDeviceDefinitionCommand = async (input, context) => {
1700
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1037
+ const b = rb(input, context);
1701
1038
  const headers = {
1702
1039
  "content-type": "application/json",
1703
1040
  };
1704
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1705
- "/greengrass/definition/devices/{DeviceDefinitionId}";
1706
- resolvedPath = __resolvedPath(resolvedPath, input, "DeviceDefinitionId", () => input.DeviceDefinitionId, "{DeviceDefinitionId}", false);
1041
+ b.bp("/greengrass/definition/devices/{DeviceDefinitionId}");
1042
+ b.p("DeviceDefinitionId", () => input.DeviceDefinitionId, "{DeviceDefinitionId}", false);
1707
1043
  let body;
1708
1044
  body = JSON.stringify(take(input, {
1709
1045
  Name: [],
1710
1046
  }));
1711
- return new __HttpRequest({
1712
- protocol,
1713
- hostname,
1714
- port,
1715
- method: "PUT",
1716
- headers,
1717
- path: resolvedPath,
1718
- body,
1719
- });
1047
+ b.m("PUT").h(headers).b(body);
1048
+ return b.build();
1720
1049
  };
1721
1050
  export const se_UpdateFunctionDefinitionCommand = async (input, context) => {
1722
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1051
+ const b = rb(input, context);
1723
1052
  const headers = {
1724
1053
  "content-type": "application/json",
1725
1054
  };
1726
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1727
- "/greengrass/definition/functions/{FunctionDefinitionId}";
1728
- resolvedPath = __resolvedPath(resolvedPath, input, "FunctionDefinitionId", () => input.FunctionDefinitionId, "{FunctionDefinitionId}", false);
1055
+ b.bp("/greengrass/definition/functions/{FunctionDefinitionId}");
1056
+ b.p("FunctionDefinitionId", () => input.FunctionDefinitionId, "{FunctionDefinitionId}", false);
1729
1057
  let body;
1730
1058
  body = JSON.stringify(take(input, {
1731
1059
  Name: [],
1732
1060
  }));
1733
- return new __HttpRequest({
1734
- protocol,
1735
- hostname,
1736
- port,
1737
- method: "PUT",
1738
- headers,
1739
- path: resolvedPath,
1740
- body,
1741
- });
1061
+ b.m("PUT").h(headers).b(body);
1062
+ return b.build();
1742
1063
  };
1743
1064
  export const se_UpdateGroupCommand = async (input, context) => {
1744
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1065
+ const b = rb(input, context);
1745
1066
  const headers = {
1746
1067
  "content-type": "application/json",
1747
1068
  };
1748
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/greengrass/groups/{GroupId}";
1749
- resolvedPath = __resolvedPath(resolvedPath, input, "GroupId", () => input.GroupId, "{GroupId}", false);
1069
+ b.bp("/greengrass/groups/{GroupId}");
1070
+ b.p("GroupId", () => input.GroupId, "{GroupId}", false);
1750
1071
  let body;
1751
1072
  body = JSON.stringify(take(input, {
1752
1073
  Name: [],
1753
1074
  }));
1754
- return new __HttpRequest({
1755
- protocol,
1756
- hostname,
1757
- port,
1758
- method: "PUT",
1759
- headers,
1760
- path: resolvedPath,
1761
- body,
1762
- });
1075
+ b.m("PUT").h(headers).b(body);
1076
+ return b.build();
1763
1077
  };
1764
1078
  export const se_UpdateGroupCertificateConfigurationCommand = async (input, context) => {
1765
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1079
+ const b = rb(input, context);
1766
1080
  const headers = {
1767
1081
  "content-type": "application/json",
1768
1082
  };
1769
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1770
- "/greengrass/groups/{GroupId}/certificateauthorities/configuration/expiry";
1771
- resolvedPath = __resolvedPath(resolvedPath, input, "GroupId", () => input.GroupId, "{GroupId}", false);
1083
+ b.bp("/greengrass/groups/{GroupId}/certificateauthorities/configuration/expiry");
1084
+ b.p("GroupId", () => input.GroupId, "{GroupId}", false);
1772
1085
  let body;
1773
1086
  body = JSON.stringify(take(input, {
1774
1087
  CertificateExpiryInMilliseconds: [],
1775
1088
  }));
1776
- return new __HttpRequest({
1777
- protocol,
1778
- hostname,
1779
- port,
1780
- method: "PUT",
1781
- headers,
1782
- path: resolvedPath,
1783
- body,
1784
- });
1089
+ b.m("PUT").h(headers).b(body);
1090
+ return b.build();
1785
1091
  };
1786
1092
  export const se_UpdateLoggerDefinitionCommand = async (input, context) => {
1787
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1093
+ const b = rb(input, context);
1788
1094
  const headers = {
1789
1095
  "content-type": "application/json",
1790
1096
  };
1791
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1792
- "/greengrass/definition/loggers/{LoggerDefinitionId}";
1793
- resolvedPath = __resolvedPath(resolvedPath, input, "LoggerDefinitionId", () => input.LoggerDefinitionId, "{LoggerDefinitionId}", false);
1097
+ b.bp("/greengrass/definition/loggers/{LoggerDefinitionId}");
1098
+ b.p("LoggerDefinitionId", () => input.LoggerDefinitionId, "{LoggerDefinitionId}", false);
1794
1099
  let body;
1795
1100
  body = JSON.stringify(take(input, {
1796
1101
  Name: [],
1797
1102
  }));
1798
- return new __HttpRequest({
1799
- protocol,
1800
- hostname,
1801
- port,
1802
- method: "PUT",
1803
- headers,
1804
- path: resolvedPath,
1805
- body,
1806
- });
1103
+ b.m("PUT").h(headers).b(body);
1104
+ return b.build();
1807
1105
  };
1808
1106
  export const se_UpdateResourceDefinitionCommand = async (input, context) => {
1809
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1107
+ const b = rb(input, context);
1810
1108
  const headers = {
1811
1109
  "content-type": "application/json",
1812
1110
  };
1813
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1814
- "/greengrass/definition/resources/{ResourceDefinitionId}";
1815
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceDefinitionId", () => input.ResourceDefinitionId, "{ResourceDefinitionId}", false);
1111
+ b.bp("/greengrass/definition/resources/{ResourceDefinitionId}");
1112
+ b.p("ResourceDefinitionId", () => input.ResourceDefinitionId, "{ResourceDefinitionId}", false);
1816
1113
  let body;
1817
1114
  body = JSON.stringify(take(input, {
1818
1115
  Name: [],
1819
1116
  }));
1820
- return new __HttpRequest({
1821
- protocol,
1822
- hostname,
1823
- port,
1824
- method: "PUT",
1825
- headers,
1826
- path: resolvedPath,
1827
- body,
1828
- });
1117
+ b.m("PUT").h(headers).b(body);
1118
+ return b.build();
1829
1119
  };
1830
1120
  export const se_UpdateSubscriptionDefinitionCommand = async (input, context) => {
1831
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1121
+ const b = rb(input, context);
1832
1122
  const headers = {
1833
1123
  "content-type": "application/json",
1834
1124
  };
1835
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1836
- "/greengrass/definition/subscriptions/{SubscriptionDefinitionId}";
1837
- resolvedPath = __resolvedPath(resolvedPath, input, "SubscriptionDefinitionId", () => input.SubscriptionDefinitionId, "{SubscriptionDefinitionId}", false);
1125
+ b.bp("/greengrass/definition/subscriptions/{SubscriptionDefinitionId}");
1126
+ b.p("SubscriptionDefinitionId", () => input.SubscriptionDefinitionId, "{SubscriptionDefinitionId}", false);
1838
1127
  let body;
1839
1128
  body = JSON.stringify(take(input, {
1840
1129
  Name: [],
1841
1130
  }));
1842
- return new __HttpRequest({
1843
- protocol,
1844
- hostname,
1845
- port,
1846
- method: "PUT",
1847
- headers,
1848
- path: resolvedPath,
1849
- body,
1850
- });
1131
+ b.m("PUT").h(headers).b(body);
1132
+ return b.build();
1851
1133
  };
1852
1134
  export const se_UpdateThingRuntimeConfigurationCommand = async (input, context) => {
1853
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1135
+ const b = rb(input, context);
1854
1136
  const headers = {
1855
1137
  "content-type": "application/json",
1856
1138
  };
1857
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1858
- "/greengrass/things/{ThingName}/runtimeconfig";
1859
- resolvedPath = __resolvedPath(resolvedPath, input, "ThingName", () => input.ThingName, "{ThingName}", false);
1139
+ b.bp("/greengrass/things/{ThingName}/runtimeconfig");
1140
+ b.p("ThingName", () => input.ThingName, "{ThingName}", false);
1860
1141
  let body;
1861
1142
  body = JSON.stringify(take(input, {
1862
1143
  TelemetryConfiguration: (_) => _json(_),
1863
1144
  }));
1864
- return new __HttpRequest({
1865
- protocol,
1866
- hostname,
1867
- port,
1868
- method: "PUT",
1869
- headers,
1870
- path: resolvedPath,
1871
- body,
1872
- });
1145
+ b.m("PUT").h(headers).b(body);
1146
+ return b.build();
1873
1147
  };
1874
1148
  export const de_AssociateRoleToGroupCommand = async (output, context) => {
1875
1149
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -5090,6 +4364,12 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
5090
4364
  value !== "" &&
5091
4365
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
5092
4366
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
4367
+ const _ACT = "AmznClientToken";
4368
+ const _MR = "MaxResults";
4369
+ const _NT = "NextToken";
4370
+ const _TK = "TagKeys";
4371
+ const _tK = "tagKeys";
4372
+ const _xact = "x-amzn-client-token";
5093
4373
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
5094
4374
  if (encoded.length) {
5095
4375
  return JSON.parse(encoded);