@aws-sdk/client-iot-wireless 3.474.0 → 3.477.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist-cjs/protocols/Aws_restJson1.js +623 -1397
  2. package/dist-es/protocols/Aws_restJson1.js +624 -1398
  3. package/package.json +5 -4
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,179 +1,123 @@
1
- import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
2
- import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, limitedParseFloat32 as __limitedParseFloat32, map, parseEpochTimestamp as __parseEpochTimestamp, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, resolvedPath as __resolvedPath, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
1
+ import { requestBuilder as rb } from "@smithy/core";
2
+ import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, limitedParseFloat32 as __limitedParseFloat32, map, parseEpochTimestamp as __parseEpochTimestamp, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
3
3
  import { v4 as generateIdempotencyToken } from "uuid";
4
4
  import { IoTWirelessServiceException as __BaseException } from "../models/IoTWirelessServiceException";
5
5
  import { AccessDeniedException, ConflictException, InternalServerException, ResourceNotFoundException, ThrottlingException, ValidationException, } from "../models/models_0";
6
6
  import { TooManyTagsException, } from "../models/models_1";
7
7
  export const se_AssociateAwsAccountWithPartnerAccountCommand = async (input, context) => {
8
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
8
+ const b = rb(input, context);
9
9
  const headers = {
10
10
  "content-type": "application/json",
11
11
  };
12
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/partner-accounts";
12
+ b.bp("/partner-accounts");
13
13
  let body;
14
14
  body = JSON.stringify(take(input, {
15
15
  ClientRequestToken: [true, (_) => _ ?? generateIdempotencyToken()],
16
16
  Sidewalk: (_) => _json(_),
17
17
  Tags: (_) => _json(_),
18
18
  }));
19
- return new __HttpRequest({
20
- protocol,
21
- hostname,
22
- port,
23
- method: "POST",
24
- headers,
25
- path: resolvedPath,
26
- body,
27
- });
19
+ b.m("POST").h(headers).b(body);
20
+ return b.build();
28
21
  };
29
22
  export const se_AssociateMulticastGroupWithFuotaTaskCommand = async (input, context) => {
30
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
23
+ const b = rb(input, context);
31
24
  const headers = {
32
25
  "content-type": "application/json",
33
26
  };
34
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/fuota-tasks/{Id}/multicast-group";
35
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
27
+ b.bp("/fuota-tasks/{Id}/multicast-group");
28
+ b.p("Id", () => input.Id, "{Id}", false);
36
29
  let body;
37
30
  body = JSON.stringify(take(input, {
38
31
  MulticastGroupId: [],
39
32
  }));
40
- return new __HttpRequest({
41
- protocol,
42
- hostname,
43
- port,
44
- method: "PUT",
45
- headers,
46
- path: resolvedPath,
47
- body,
48
- });
33
+ b.m("PUT").h(headers).b(body);
34
+ return b.build();
49
35
  };
50
36
  export const se_AssociateWirelessDeviceWithFuotaTaskCommand = async (input, context) => {
51
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
37
+ const b = rb(input, context);
52
38
  const headers = {
53
39
  "content-type": "application/json",
54
40
  };
55
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/fuota-tasks/{Id}/wireless-device";
56
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
41
+ b.bp("/fuota-tasks/{Id}/wireless-device");
42
+ b.p("Id", () => input.Id, "{Id}", false);
57
43
  let body;
58
44
  body = JSON.stringify(take(input, {
59
45
  WirelessDeviceId: [],
60
46
  }));
61
- return new __HttpRequest({
62
- protocol,
63
- hostname,
64
- port,
65
- method: "PUT",
66
- headers,
67
- path: resolvedPath,
68
- body,
69
- });
47
+ b.m("PUT").h(headers).b(body);
48
+ return b.build();
70
49
  };
71
50
  export const se_AssociateWirelessDeviceWithMulticastGroupCommand = async (input, context) => {
72
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
51
+ const b = rb(input, context);
73
52
  const headers = {
74
53
  "content-type": "application/json",
75
54
  };
76
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/multicast-groups/{Id}/wireless-device";
77
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
55
+ b.bp("/multicast-groups/{Id}/wireless-device");
56
+ b.p("Id", () => input.Id, "{Id}", false);
78
57
  let body;
79
58
  body = JSON.stringify(take(input, {
80
59
  WirelessDeviceId: [],
81
60
  }));
82
- return new __HttpRequest({
83
- protocol,
84
- hostname,
85
- port,
86
- method: "PUT",
87
- headers,
88
- path: resolvedPath,
89
- body,
90
- });
61
+ b.m("PUT").h(headers).b(body);
62
+ return b.build();
91
63
  };
92
64
  export const se_AssociateWirelessDeviceWithThingCommand = async (input, context) => {
93
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
65
+ const b = rb(input, context);
94
66
  const headers = {
95
67
  "content-type": "application/json",
96
68
  };
97
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-devices/{Id}/thing";
98
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
69
+ b.bp("/wireless-devices/{Id}/thing");
70
+ b.p("Id", () => input.Id, "{Id}", false);
99
71
  let body;
100
72
  body = JSON.stringify(take(input, {
101
73
  ThingArn: [],
102
74
  }));
103
- return new __HttpRequest({
104
- protocol,
105
- hostname,
106
- port,
107
- method: "PUT",
108
- headers,
109
- path: resolvedPath,
110
- body,
111
- });
75
+ b.m("PUT").h(headers).b(body);
76
+ return b.build();
112
77
  };
113
78
  export const se_AssociateWirelessGatewayWithCertificateCommand = async (input, context) => {
114
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
79
+ const b = rb(input, context);
115
80
  const headers = {
116
81
  "content-type": "application/json",
117
82
  };
118
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-gateways/{Id}/certificate";
119
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
83
+ b.bp("/wireless-gateways/{Id}/certificate");
84
+ b.p("Id", () => input.Id, "{Id}", false);
120
85
  let body;
121
86
  body = JSON.stringify(take(input, {
122
87
  IotCertificateId: [],
123
88
  }));
124
- return new __HttpRequest({
125
- protocol,
126
- hostname,
127
- port,
128
- method: "PUT",
129
- headers,
130
- path: resolvedPath,
131
- body,
132
- });
89
+ b.m("PUT").h(headers).b(body);
90
+ return b.build();
133
91
  };
134
92
  export const se_AssociateWirelessGatewayWithThingCommand = async (input, context) => {
135
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
93
+ const b = rb(input, context);
136
94
  const headers = {
137
95
  "content-type": "application/json",
138
96
  };
139
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-gateways/{Id}/thing";
140
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
97
+ b.bp("/wireless-gateways/{Id}/thing");
98
+ b.p("Id", () => input.Id, "{Id}", false);
141
99
  let body;
142
100
  body = JSON.stringify(take(input, {
143
101
  ThingArn: [],
144
102
  }));
145
- return new __HttpRequest({
146
- protocol,
147
- hostname,
148
- port,
149
- method: "PUT",
150
- headers,
151
- path: resolvedPath,
152
- body,
153
- });
103
+ b.m("PUT").h(headers).b(body);
104
+ return b.build();
154
105
  };
155
106
  export const se_CancelMulticastGroupSessionCommand = async (input, context) => {
156
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
107
+ const b = rb(input, context);
157
108
  const headers = {};
158
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/multicast-groups/{Id}/session";
159
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
109
+ b.bp("/multicast-groups/{Id}/session");
110
+ b.p("Id", () => input.Id, "{Id}", false);
160
111
  let body;
161
- return new __HttpRequest({
162
- protocol,
163
- hostname,
164
- port,
165
- method: "DELETE",
166
- headers,
167
- path: resolvedPath,
168
- body,
169
- });
112
+ b.m("DELETE").h(headers).b(body);
113
+ return b.build();
170
114
  };
171
115
  export const se_CreateDestinationCommand = async (input, context) => {
172
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
116
+ const b = rb(input, context);
173
117
  const headers = {
174
118
  "content-type": "application/json",
175
119
  };
176
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/destinations";
120
+ b.bp("/destinations");
177
121
  let body;
178
122
  body = JSON.stringify(take(input, {
179
123
  ClientRequestToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -184,22 +128,15 @@ export const se_CreateDestinationCommand = async (input, context) => {
184
128
  RoleArn: [],
185
129
  Tags: (_) => _json(_),
186
130
  }));
187
- return new __HttpRequest({
188
- protocol,
189
- hostname,
190
- port,
191
- method: "POST",
192
- headers,
193
- path: resolvedPath,
194
- body,
195
- });
131
+ b.m("POST").h(headers).b(body);
132
+ return b.build();
196
133
  };
197
134
  export const se_CreateDeviceProfileCommand = async (input, context) => {
198
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
135
+ const b = rb(input, context);
199
136
  const headers = {
200
137
  "content-type": "application/json",
201
138
  };
202
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/device-profiles";
139
+ b.bp("/device-profiles");
203
140
  let body;
204
141
  body = JSON.stringify(take(input, {
205
142
  ClientRequestToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -208,22 +145,15 @@ export const se_CreateDeviceProfileCommand = async (input, context) => {
208
145
  Sidewalk: (_) => _json(_),
209
146
  Tags: (_) => _json(_),
210
147
  }));
211
- return new __HttpRequest({
212
- protocol,
213
- hostname,
214
- port,
215
- method: "POST",
216
- headers,
217
- path: resolvedPath,
218
- body,
219
- });
148
+ b.m("POST").h(headers).b(body);
149
+ return b.build();
220
150
  };
221
151
  export const se_CreateFuotaTaskCommand = async (input, context) => {
222
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
152
+ const b = rb(input, context);
223
153
  const headers = {
224
154
  "content-type": "application/json",
225
155
  };
226
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/fuota-tasks";
156
+ b.bp("/fuota-tasks");
227
157
  let body;
228
158
  body = JSON.stringify(take(input, {
229
159
  ClientRequestToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -237,22 +167,15 @@ export const se_CreateFuotaTaskCommand = async (input, context) => {
237
167
  RedundancyPercent: [],
238
168
  Tags: (_) => _json(_),
239
169
  }));
240
- return new __HttpRequest({
241
- protocol,
242
- hostname,
243
- port,
244
- method: "POST",
245
- headers,
246
- path: resolvedPath,
247
- body,
248
- });
170
+ b.m("POST").h(headers).b(body);
171
+ return b.build();
249
172
  };
250
173
  export const se_CreateMulticastGroupCommand = async (input, context) => {
251
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
174
+ const b = rb(input, context);
252
175
  const headers = {
253
176
  "content-type": "application/json",
254
177
  };
255
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/multicast-groups";
178
+ b.bp("/multicast-groups");
256
179
  let body;
257
180
  body = JSON.stringify(take(input, {
258
181
  ClientRequestToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -261,22 +184,15 @@ export const se_CreateMulticastGroupCommand = async (input, context) => {
261
184
  Name: [],
262
185
  Tags: (_) => _json(_),
263
186
  }));
264
- return new __HttpRequest({
265
- protocol,
266
- hostname,
267
- port,
268
- method: "POST",
269
- headers,
270
- path: resolvedPath,
271
- body,
272
- });
187
+ b.m("POST").h(headers).b(body);
188
+ return b.build();
273
189
  };
274
190
  export const se_CreateNetworkAnalyzerConfigurationCommand = async (input, context) => {
275
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
191
+ const b = rb(input, context);
276
192
  const headers = {
277
193
  "content-type": "application/json",
278
194
  };
279
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/network-analyzer-configurations";
195
+ b.bp("/network-analyzer-configurations");
280
196
  let body;
281
197
  body = JSON.stringify(take(input, {
282
198
  ClientRequestToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -288,22 +204,15 @@ export const se_CreateNetworkAnalyzerConfigurationCommand = async (input, contex
288
204
  WirelessDevices: (_) => _json(_),
289
205
  WirelessGateways: (_) => _json(_),
290
206
  }));
291
- return new __HttpRequest({
292
- protocol,
293
- hostname,
294
- port,
295
- method: "POST",
296
- headers,
297
- path: resolvedPath,
298
- body,
299
- });
207
+ b.m("POST").h(headers).b(body);
208
+ return b.build();
300
209
  };
301
210
  export const se_CreateServiceProfileCommand = async (input, context) => {
302
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
211
+ const b = rb(input, context);
303
212
  const headers = {
304
213
  "content-type": "application/json",
305
214
  };
306
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/service-profiles";
215
+ b.bp("/service-profiles");
307
216
  let body;
308
217
  body = JSON.stringify(take(input, {
309
218
  ClientRequestToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -311,22 +220,15 @@ export const se_CreateServiceProfileCommand = async (input, context) => {
311
220
  Name: [],
312
221
  Tags: (_) => _json(_),
313
222
  }));
314
- return new __HttpRequest({
315
- protocol,
316
- hostname,
317
- port,
318
- method: "POST",
319
- headers,
320
- path: resolvedPath,
321
- body,
322
- });
223
+ b.m("POST").h(headers).b(body);
224
+ return b.build();
323
225
  };
324
226
  export const se_CreateWirelessDeviceCommand = async (input, context) => {
325
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
227
+ const b = rb(input, context);
326
228
  const headers = {
327
229
  "content-type": "application/json",
328
230
  };
329
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-devices";
231
+ b.bp("/wireless-devices");
330
232
  let body;
331
233
  body = JSON.stringify(take(input, {
332
234
  ClientRequestToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -339,22 +241,15 @@ export const se_CreateWirelessDeviceCommand = async (input, context) => {
339
241
  Tags: (_) => _json(_),
340
242
  Type: [],
341
243
  }));
342
- return new __HttpRequest({
343
- protocol,
344
- hostname,
345
- port,
346
- method: "POST",
347
- headers,
348
- path: resolvedPath,
349
- body,
350
- });
244
+ b.m("POST").h(headers).b(body);
245
+ return b.build();
351
246
  };
352
247
  export const se_CreateWirelessGatewayCommand = async (input, context) => {
353
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
248
+ const b = rb(input, context);
354
249
  const headers = {
355
250
  "content-type": "application/json",
356
251
  };
357
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-gateways";
252
+ b.bp("/wireless-gateways");
358
253
  let body;
359
254
  body = JSON.stringify(take(input, {
360
255
  ClientRequestToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -363,43 +258,29 @@ export const se_CreateWirelessGatewayCommand = async (input, context) => {
363
258
  Name: [],
364
259
  Tags: (_) => _json(_),
365
260
  }));
366
- return new __HttpRequest({
367
- protocol,
368
- hostname,
369
- port,
370
- method: "POST",
371
- headers,
372
- path: resolvedPath,
373
- body,
374
- });
261
+ b.m("POST").h(headers).b(body);
262
+ return b.build();
375
263
  };
376
264
  export const se_CreateWirelessGatewayTaskCommand = async (input, context) => {
377
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
265
+ const b = rb(input, context);
378
266
  const headers = {
379
267
  "content-type": "application/json",
380
268
  };
381
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-gateways/{Id}/tasks";
382
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
269
+ b.bp("/wireless-gateways/{Id}/tasks");
270
+ b.p("Id", () => input.Id, "{Id}", false);
383
271
  let body;
384
272
  body = JSON.stringify(take(input, {
385
273
  WirelessGatewayTaskDefinitionId: [],
386
274
  }));
387
- return new __HttpRequest({
388
- protocol,
389
- hostname,
390
- port,
391
- method: "POST",
392
- headers,
393
- path: resolvedPath,
394
- body,
395
- });
275
+ b.m("POST").h(headers).b(body);
276
+ return b.build();
396
277
  };
397
278
  export const se_CreateWirelessGatewayTaskDefinitionCommand = async (input, context) => {
398
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
279
+ const b = rb(input, context);
399
280
  const headers = {
400
281
  "content-type": "application/json",
401
282
  };
402
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-gateway-task-definitions";
283
+ b.bp("/wireless-gateway-task-definitions");
403
284
  let body;
404
285
  body = JSON.stringify(take(input, {
405
286
  AutoCreateTasks: [],
@@ -408,556 +289,320 @@ export const se_CreateWirelessGatewayTaskDefinitionCommand = async (input, conte
408
289
  Tags: (_) => _json(_),
409
290
  Update: (_) => _json(_),
410
291
  }));
411
- return new __HttpRequest({
412
- protocol,
413
- hostname,
414
- port,
415
- method: "POST",
416
- headers,
417
- path: resolvedPath,
418
- body,
419
- });
292
+ b.m("POST").h(headers).b(body);
293
+ return b.build();
420
294
  };
421
295
  export const se_DeleteDestinationCommand = async (input, context) => {
422
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
296
+ const b = rb(input, context);
423
297
  const headers = {};
424
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/destinations/{Name}";
425
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
298
+ b.bp("/destinations/{Name}");
299
+ b.p("Name", () => input.Name, "{Name}", false);
426
300
  let body;
427
- return new __HttpRequest({
428
- protocol,
429
- hostname,
430
- port,
431
- method: "DELETE",
432
- headers,
433
- path: resolvedPath,
434
- body,
435
- });
301
+ b.m("DELETE").h(headers).b(body);
302
+ return b.build();
436
303
  };
437
304
  export const se_DeleteDeviceProfileCommand = async (input, context) => {
438
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
305
+ const b = rb(input, context);
439
306
  const headers = {};
440
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/device-profiles/{Id}";
441
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
307
+ b.bp("/device-profiles/{Id}");
308
+ b.p("Id", () => input.Id, "{Id}", false);
442
309
  let body;
443
- return new __HttpRequest({
444
- protocol,
445
- hostname,
446
- port,
447
- method: "DELETE",
448
- headers,
449
- path: resolvedPath,
450
- body,
451
- });
310
+ b.m("DELETE").h(headers).b(body);
311
+ return b.build();
452
312
  };
453
313
  export const se_DeleteFuotaTaskCommand = async (input, context) => {
454
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
314
+ const b = rb(input, context);
455
315
  const headers = {};
456
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/fuota-tasks/{Id}";
457
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
316
+ b.bp("/fuota-tasks/{Id}");
317
+ b.p("Id", () => input.Id, "{Id}", false);
458
318
  let body;
459
- return new __HttpRequest({
460
- protocol,
461
- hostname,
462
- port,
463
- method: "DELETE",
464
- headers,
465
- path: resolvedPath,
466
- body,
467
- });
319
+ b.m("DELETE").h(headers).b(body);
320
+ return b.build();
468
321
  };
469
322
  export const se_DeleteMulticastGroupCommand = async (input, context) => {
470
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
323
+ const b = rb(input, context);
471
324
  const headers = {};
472
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/multicast-groups/{Id}";
473
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
325
+ b.bp("/multicast-groups/{Id}");
326
+ b.p("Id", () => input.Id, "{Id}", false);
474
327
  let body;
475
- return new __HttpRequest({
476
- protocol,
477
- hostname,
478
- port,
479
- method: "DELETE",
480
- headers,
481
- path: resolvedPath,
482
- body,
483
- });
328
+ b.m("DELETE").h(headers).b(body);
329
+ return b.build();
484
330
  };
485
331
  export const se_DeleteNetworkAnalyzerConfigurationCommand = async (input, context) => {
486
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
332
+ const b = rb(input, context);
487
333
  const headers = {};
488
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
489
- "/network-analyzer-configurations/{ConfigurationName}";
490
- resolvedPath = __resolvedPath(resolvedPath, input, "ConfigurationName", () => input.ConfigurationName, "{ConfigurationName}", false);
334
+ b.bp("/network-analyzer-configurations/{ConfigurationName}");
335
+ b.p("ConfigurationName", () => input.ConfigurationName, "{ConfigurationName}", false);
491
336
  let body;
492
- return new __HttpRequest({
493
- protocol,
494
- hostname,
495
- port,
496
- method: "DELETE",
497
- headers,
498
- path: resolvedPath,
499
- body,
500
- });
337
+ b.m("DELETE").h(headers).b(body);
338
+ return b.build();
501
339
  };
502
340
  export const se_DeleteQueuedMessagesCommand = async (input, context) => {
503
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
341
+ const b = rb(input, context);
504
342
  const headers = {};
505
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-devices/{Id}/data";
506
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
343
+ b.bp("/wireless-devices/{Id}/data");
344
+ b.p("Id", () => input.Id, "{Id}", false);
507
345
  const query = map({
508
- messageId: [, __expectNonNull(input.MessageId, `MessageId`)],
509
- WirelessDeviceType: [, input.WirelessDeviceType],
346
+ [_mI]: [, __expectNonNull(input[_MI], `MessageId`)],
347
+ [_WDT]: [, input[_WDT]],
510
348
  });
511
349
  let body;
512
- return new __HttpRequest({
513
- protocol,
514
- hostname,
515
- port,
516
- method: "DELETE",
517
- headers,
518
- path: resolvedPath,
519
- query,
520
- body,
521
- });
350
+ b.m("DELETE").h(headers).q(query).b(body);
351
+ return b.build();
522
352
  };
523
353
  export const se_DeleteServiceProfileCommand = async (input, context) => {
524
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
354
+ const b = rb(input, context);
525
355
  const headers = {};
526
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/service-profiles/{Id}";
527
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
356
+ b.bp("/service-profiles/{Id}");
357
+ b.p("Id", () => input.Id, "{Id}", false);
528
358
  let body;
529
- return new __HttpRequest({
530
- protocol,
531
- hostname,
532
- port,
533
- method: "DELETE",
534
- headers,
535
- path: resolvedPath,
536
- body,
537
- });
359
+ b.m("DELETE").h(headers).b(body);
360
+ return b.build();
538
361
  };
539
362
  export const se_DeleteWirelessDeviceCommand = async (input, context) => {
540
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
363
+ const b = rb(input, context);
541
364
  const headers = {};
542
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-devices/{Id}";
543
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
365
+ b.bp("/wireless-devices/{Id}");
366
+ b.p("Id", () => input.Id, "{Id}", false);
544
367
  let body;
545
- return new __HttpRequest({
546
- protocol,
547
- hostname,
548
- port,
549
- method: "DELETE",
550
- headers,
551
- path: resolvedPath,
552
- body,
553
- });
368
+ b.m("DELETE").h(headers).b(body);
369
+ return b.build();
554
370
  };
555
371
  export const se_DeleteWirelessDeviceImportTaskCommand = async (input, context) => {
556
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
372
+ const b = rb(input, context);
557
373
  const headers = {};
558
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless_device_import_task/{Id}";
559
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
374
+ b.bp("/wireless_device_import_task/{Id}");
375
+ b.p("Id", () => input.Id, "{Id}", false);
560
376
  let body;
561
- return new __HttpRequest({
562
- protocol,
563
- hostname,
564
- port,
565
- method: "DELETE",
566
- headers,
567
- path: resolvedPath,
568
- body,
569
- });
377
+ b.m("DELETE").h(headers).b(body);
378
+ return b.build();
570
379
  };
571
380
  export const se_DeleteWirelessGatewayCommand = async (input, context) => {
572
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
381
+ const b = rb(input, context);
573
382
  const headers = {};
574
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-gateways/{Id}";
575
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
383
+ b.bp("/wireless-gateways/{Id}");
384
+ b.p("Id", () => input.Id, "{Id}", false);
576
385
  let body;
577
- return new __HttpRequest({
578
- protocol,
579
- hostname,
580
- port,
581
- method: "DELETE",
582
- headers,
583
- path: resolvedPath,
584
- body,
585
- });
386
+ b.m("DELETE").h(headers).b(body);
387
+ return b.build();
586
388
  };
587
389
  export const se_DeleteWirelessGatewayTaskCommand = async (input, context) => {
588
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
390
+ const b = rb(input, context);
589
391
  const headers = {};
590
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-gateways/{Id}/tasks";
591
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
392
+ b.bp("/wireless-gateways/{Id}/tasks");
393
+ b.p("Id", () => input.Id, "{Id}", false);
592
394
  let body;
593
- return new __HttpRequest({
594
- protocol,
595
- hostname,
596
- port,
597
- method: "DELETE",
598
- headers,
599
- path: resolvedPath,
600
- body,
601
- });
395
+ b.m("DELETE").h(headers).b(body);
396
+ return b.build();
602
397
  };
603
398
  export const se_DeleteWirelessGatewayTaskDefinitionCommand = async (input, context) => {
604
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
399
+ const b = rb(input, context);
605
400
  const headers = {};
606
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-gateway-task-definitions/{Id}";
607
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
401
+ b.bp("/wireless-gateway-task-definitions/{Id}");
402
+ b.p("Id", () => input.Id, "{Id}", false);
608
403
  let body;
609
- return new __HttpRequest({
610
- protocol,
611
- hostname,
612
- port,
613
- method: "DELETE",
614
- headers,
615
- path: resolvedPath,
616
- body,
617
- });
404
+ b.m("DELETE").h(headers).b(body);
405
+ return b.build();
618
406
  };
619
407
  export const se_DeregisterWirelessDeviceCommand = async (input, context) => {
620
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
408
+ const b = rb(input, context);
621
409
  const headers = {};
622
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-devices/{Identifier}/deregister";
623
- resolvedPath = __resolvedPath(resolvedPath, input, "Identifier", () => input.Identifier, "{Identifier}", false);
410
+ b.bp("/wireless-devices/{Identifier}/deregister");
411
+ b.p("Identifier", () => input.Identifier, "{Identifier}", false);
624
412
  const query = map({
625
- WirelessDeviceType: [, input.WirelessDeviceType],
413
+ [_WDT]: [, input[_WDT]],
626
414
  });
627
415
  let body;
628
- return new __HttpRequest({
629
- protocol,
630
- hostname,
631
- port,
632
- method: "PATCH",
633
- headers,
634
- path: resolvedPath,
635
- query,
636
- body,
637
- });
416
+ b.m("PATCH").h(headers).q(query).b(body);
417
+ return b.build();
638
418
  };
639
419
  export const se_DisassociateAwsAccountFromPartnerAccountCommand = async (input, context) => {
640
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
420
+ const b = rb(input, context);
641
421
  const headers = {};
642
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/partner-accounts/{PartnerAccountId}";
643
- resolvedPath = __resolvedPath(resolvedPath, input, "PartnerAccountId", () => input.PartnerAccountId, "{PartnerAccountId}", false);
422
+ b.bp("/partner-accounts/{PartnerAccountId}");
423
+ b.p("PartnerAccountId", () => input.PartnerAccountId, "{PartnerAccountId}", false);
644
424
  const query = map({
645
- partnerType: [, __expectNonNull(input.PartnerType, `PartnerType`)],
425
+ [_pT]: [, __expectNonNull(input[_PT], `PartnerType`)],
646
426
  });
647
427
  let body;
648
- return new __HttpRequest({
649
- protocol,
650
- hostname,
651
- port,
652
- method: "DELETE",
653
- headers,
654
- path: resolvedPath,
655
- query,
656
- body,
657
- });
428
+ b.m("DELETE").h(headers).q(query).b(body);
429
+ return b.build();
658
430
  };
659
431
  export const se_DisassociateMulticastGroupFromFuotaTaskCommand = async (input, context) => {
660
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
432
+ const b = rb(input, context);
661
433
  const headers = {};
662
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
663
- "/fuota-tasks/{Id}/multicast-groups/{MulticastGroupId}";
664
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
665
- resolvedPath = __resolvedPath(resolvedPath, input, "MulticastGroupId", () => input.MulticastGroupId, "{MulticastGroupId}", false);
434
+ b.bp("/fuota-tasks/{Id}/multicast-groups/{MulticastGroupId}");
435
+ b.p("Id", () => input.Id, "{Id}", false);
436
+ b.p("MulticastGroupId", () => input.MulticastGroupId, "{MulticastGroupId}", false);
666
437
  let body;
667
- return new __HttpRequest({
668
- protocol,
669
- hostname,
670
- port,
671
- method: "DELETE",
672
- headers,
673
- path: resolvedPath,
674
- body,
675
- });
438
+ b.m("DELETE").h(headers).b(body);
439
+ return b.build();
676
440
  };
677
441
  export const se_DisassociateWirelessDeviceFromFuotaTaskCommand = async (input, context) => {
678
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
442
+ const b = rb(input, context);
679
443
  const headers = {};
680
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
681
- "/fuota-tasks/{Id}/wireless-devices/{WirelessDeviceId}";
682
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
683
- resolvedPath = __resolvedPath(resolvedPath, input, "WirelessDeviceId", () => input.WirelessDeviceId, "{WirelessDeviceId}", false);
444
+ b.bp("/fuota-tasks/{Id}/wireless-devices/{WirelessDeviceId}");
445
+ b.p("Id", () => input.Id, "{Id}", false);
446
+ b.p("WirelessDeviceId", () => input.WirelessDeviceId, "{WirelessDeviceId}", false);
684
447
  let body;
685
- return new __HttpRequest({
686
- protocol,
687
- hostname,
688
- port,
689
- method: "DELETE",
690
- headers,
691
- path: resolvedPath,
692
- body,
693
- });
448
+ b.m("DELETE").h(headers).b(body);
449
+ return b.build();
694
450
  };
695
451
  export const se_DisassociateWirelessDeviceFromMulticastGroupCommand = async (input, context) => {
696
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
452
+ const b = rb(input, context);
697
453
  const headers = {};
698
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
699
- "/multicast-groups/{Id}/wireless-devices/{WirelessDeviceId}";
700
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
701
- resolvedPath = __resolvedPath(resolvedPath, input, "WirelessDeviceId", () => input.WirelessDeviceId, "{WirelessDeviceId}", false);
454
+ b.bp("/multicast-groups/{Id}/wireless-devices/{WirelessDeviceId}");
455
+ b.p("Id", () => input.Id, "{Id}", false);
456
+ b.p("WirelessDeviceId", () => input.WirelessDeviceId, "{WirelessDeviceId}", false);
702
457
  let body;
703
- return new __HttpRequest({
704
- protocol,
705
- hostname,
706
- port,
707
- method: "DELETE",
708
- headers,
709
- path: resolvedPath,
710
- body,
711
- });
458
+ b.m("DELETE").h(headers).b(body);
459
+ return b.build();
712
460
  };
713
461
  export const se_DisassociateWirelessDeviceFromThingCommand = async (input, context) => {
714
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
462
+ const b = rb(input, context);
715
463
  const headers = {};
716
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-devices/{Id}/thing";
717
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
464
+ b.bp("/wireless-devices/{Id}/thing");
465
+ b.p("Id", () => input.Id, "{Id}", false);
718
466
  let body;
719
- return new __HttpRequest({
720
- protocol,
721
- hostname,
722
- port,
723
- method: "DELETE",
724
- headers,
725
- path: resolvedPath,
726
- body,
727
- });
467
+ b.m("DELETE").h(headers).b(body);
468
+ return b.build();
728
469
  };
729
470
  export const se_DisassociateWirelessGatewayFromCertificateCommand = async (input, context) => {
730
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
471
+ const b = rb(input, context);
731
472
  const headers = {};
732
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-gateways/{Id}/certificate";
733
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
473
+ b.bp("/wireless-gateways/{Id}/certificate");
474
+ b.p("Id", () => input.Id, "{Id}", false);
734
475
  let body;
735
- return new __HttpRequest({
736
- protocol,
737
- hostname,
738
- port,
739
- method: "DELETE",
740
- headers,
741
- path: resolvedPath,
742
- body,
743
- });
476
+ b.m("DELETE").h(headers).b(body);
477
+ return b.build();
744
478
  };
745
479
  export const se_DisassociateWirelessGatewayFromThingCommand = async (input, context) => {
746
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
480
+ const b = rb(input, context);
747
481
  const headers = {};
748
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-gateways/{Id}/thing";
749
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
482
+ b.bp("/wireless-gateways/{Id}/thing");
483
+ b.p("Id", () => input.Id, "{Id}", false);
750
484
  let body;
751
- return new __HttpRequest({
752
- protocol,
753
- hostname,
754
- port,
755
- method: "DELETE",
756
- headers,
757
- path: resolvedPath,
758
- body,
759
- });
485
+ b.m("DELETE").h(headers).b(body);
486
+ return b.build();
760
487
  };
761
488
  export const se_GetDestinationCommand = async (input, context) => {
762
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
489
+ const b = rb(input, context);
763
490
  const headers = {};
764
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/destinations/{Name}";
765
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
491
+ b.bp("/destinations/{Name}");
492
+ b.p("Name", () => input.Name, "{Name}", false);
766
493
  let body;
767
- return new __HttpRequest({
768
- protocol,
769
- hostname,
770
- port,
771
- method: "GET",
772
- headers,
773
- path: resolvedPath,
774
- body,
775
- });
494
+ b.m("GET").h(headers).b(body);
495
+ return b.build();
776
496
  };
777
497
  export const se_GetDeviceProfileCommand = async (input, context) => {
778
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
498
+ const b = rb(input, context);
779
499
  const headers = {};
780
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/device-profiles/{Id}";
781
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
500
+ b.bp("/device-profiles/{Id}");
501
+ b.p("Id", () => input.Id, "{Id}", false);
782
502
  let body;
783
- return new __HttpRequest({
784
- protocol,
785
- hostname,
786
- port,
787
- method: "GET",
788
- headers,
789
- path: resolvedPath,
790
- body,
791
- });
503
+ b.m("GET").h(headers).b(body);
504
+ return b.build();
792
505
  };
793
506
  export const se_GetEventConfigurationByResourceTypesCommand = async (input, context) => {
794
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
507
+ const b = rb(input, context);
795
508
  const headers = {
796
509
  "content-type": "application/json",
797
510
  };
798
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/event-configurations-resource-types";
511
+ b.bp("/event-configurations-resource-types");
799
512
  let body;
800
513
  body = "";
801
- return new __HttpRequest({
802
- protocol,
803
- hostname,
804
- port,
805
- method: "GET",
806
- headers,
807
- path: resolvedPath,
808
- body,
809
- });
514
+ b.m("GET").h(headers).b(body);
515
+ return b.build();
810
516
  };
811
517
  export const se_GetFuotaTaskCommand = async (input, context) => {
812
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
518
+ const b = rb(input, context);
813
519
  const headers = {};
814
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/fuota-tasks/{Id}";
815
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
520
+ b.bp("/fuota-tasks/{Id}");
521
+ b.p("Id", () => input.Id, "{Id}", false);
816
522
  let body;
817
- return new __HttpRequest({
818
- protocol,
819
- hostname,
820
- port,
821
- method: "GET",
822
- headers,
823
- path: resolvedPath,
824
- body,
825
- });
523
+ b.m("GET").h(headers).b(body);
524
+ return b.build();
826
525
  };
827
526
  export const se_GetLogLevelsByResourceTypesCommand = async (input, context) => {
828
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
527
+ const b = rb(input, context);
829
528
  const headers = {
830
529
  "content-type": "application/json",
831
530
  };
832
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/log-levels";
531
+ b.bp("/log-levels");
833
532
  let body;
834
533
  body = "";
835
- return new __HttpRequest({
836
- protocol,
837
- hostname,
838
- port,
839
- method: "GET",
840
- headers,
841
- path: resolvedPath,
842
- body,
843
- });
534
+ b.m("GET").h(headers).b(body);
535
+ return b.build();
844
536
  };
845
537
  export const se_GetMulticastGroupCommand = async (input, context) => {
846
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
538
+ const b = rb(input, context);
847
539
  const headers = {};
848
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/multicast-groups/{Id}";
849
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
540
+ b.bp("/multicast-groups/{Id}");
541
+ b.p("Id", () => input.Id, "{Id}", false);
850
542
  let body;
851
- return new __HttpRequest({
852
- protocol,
853
- hostname,
854
- port,
855
- method: "GET",
856
- headers,
857
- path: resolvedPath,
858
- body,
859
- });
543
+ b.m("GET").h(headers).b(body);
544
+ return b.build();
860
545
  };
861
546
  export const se_GetMulticastGroupSessionCommand = async (input, context) => {
862
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
547
+ const b = rb(input, context);
863
548
  const headers = {};
864
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/multicast-groups/{Id}/session";
865
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
549
+ b.bp("/multicast-groups/{Id}/session");
550
+ b.p("Id", () => input.Id, "{Id}", false);
866
551
  let body;
867
- return new __HttpRequest({
868
- protocol,
869
- hostname,
870
- port,
871
- method: "GET",
872
- headers,
873
- path: resolvedPath,
874
- body,
875
- });
552
+ b.m("GET").h(headers).b(body);
553
+ return b.build();
876
554
  };
877
555
  export const se_GetNetworkAnalyzerConfigurationCommand = async (input, context) => {
878
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
556
+ const b = rb(input, context);
879
557
  const headers = {};
880
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
881
- "/network-analyzer-configurations/{ConfigurationName}";
882
- resolvedPath = __resolvedPath(resolvedPath, input, "ConfigurationName", () => input.ConfigurationName, "{ConfigurationName}", false);
558
+ b.bp("/network-analyzer-configurations/{ConfigurationName}");
559
+ b.p("ConfigurationName", () => input.ConfigurationName, "{ConfigurationName}", false);
883
560
  let body;
884
- return new __HttpRequest({
885
- protocol,
886
- hostname,
887
- port,
888
- method: "GET",
889
- headers,
890
- path: resolvedPath,
891
- body,
892
- });
561
+ b.m("GET").h(headers).b(body);
562
+ return b.build();
893
563
  };
894
564
  export const se_GetPartnerAccountCommand = async (input, context) => {
895
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
565
+ const b = rb(input, context);
896
566
  const headers = {};
897
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/partner-accounts/{PartnerAccountId}";
898
- resolvedPath = __resolvedPath(resolvedPath, input, "PartnerAccountId", () => input.PartnerAccountId, "{PartnerAccountId}", false);
567
+ b.bp("/partner-accounts/{PartnerAccountId}");
568
+ b.p("PartnerAccountId", () => input.PartnerAccountId, "{PartnerAccountId}", false);
899
569
  const query = map({
900
- partnerType: [, __expectNonNull(input.PartnerType, `PartnerType`)],
570
+ [_pT]: [, __expectNonNull(input[_PT], `PartnerType`)],
901
571
  });
902
572
  let body;
903
- return new __HttpRequest({
904
- protocol,
905
- hostname,
906
- port,
907
- method: "GET",
908
- headers,
909
- path: resolvedPath,
910
- query,
911
- body,
912
- });
573
+ b.m("GET").h(headers).q(query).b(body);
574
+ return b.build();
913
575
  };
914
576
  export const se_GetPositionCommand = async (input, context) => {
915
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
577
+ const b = rb(input, context);
916
578
  const headers = {};
917
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/positions/{ResourceIdentifier}";
918
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceIdentifier", () => input.ResourceIdentifier, "{ResourceIdentifier}", false);
579
+ b.bp("/positions/{ResourceIdentifier}");
580
+ b.p("ResourceIdentifier", () => input.ResourceIdentifier, "{ResourceIdentifier}", false);
919
581
  const query = map({
920
- resourceType: [, __expectNonNull(input.ResourceType, `ResourceType`)],
582
+ [_rT]: [, __expectNonNull(input[_RT], `ResourceType`)],
921
583
  });
922
584
  let body;
923
- return new __HttpRequest({
924
- protocol,
925
- hostname,
926
- port,
927
- method: "GET",
928
- headers,
929
- path: resolvedPath,
930
- query,
931
- body,
932
- });
585
+ b.m("GET").h(headers).q(query).b(body);
586
+ return b.build();
933
587
  };
934
588
  export const se_GetPositionConfigurationCommand = async (input, context) => {
935
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
589
+ const b = rb(input, context);
936
590
  const headers = {};
937
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
938
- "/position-configurations/{ResourceIdentifier}";
939
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceIdentifier", () => input.ResourceIdentifier, "{ResourceIdentifier}", false);
591
+ b.bp("/position-configurations/{ResourceIdentifier}");
592
+ b.p("ResourceIdentifier", () => input.ResourceIdentifier, "{ResourceIdentifier}", false);
940
593
  const query = map({
941
- resourceType: [, __expectNonNull(input.ResourceType, `ResourceType`)],
594
+ [_rT]: [, __expectNonNull(input[_RT], `ResourceType`)],
942
595
  });
943
596
  let body;
944
- return new __HttpRequest({
945
- protocol,
946
- hostname,
947
- port,
948
- method: "GET",
949
- headers,
950
- path: resolvedPath,
951
- query,
952
- body,
953
- });
597
+ b.m("GET").h(headers).q(query).b(body);
598
+ return b.build();
954
599
  };
955
600
  export const se_GetPositionEstimateCommand = async (input, context) => {
956
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
601
+ const b = rb(input, context);
957
602
  const headers = {
958
603
  "content-type": "application/json",
959
604
  };
960
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/position-estimate";
605
+ b.bp("/position-estimate");
961
606
  let body;
962
607
  body = JSON.stringify(take(input, {
963
608
  CellTowers: (_) => se_CellTowers(_, context),
@@ -966,848 +611,524 @@ export const se_GetPositionEstimateCommand = async (input, context) => {
966
611
  Timestamp: (_) => Math.round(_.getTime() / 1000),
967
612
  WiFiAccessPoints: (_) => _json(_),
968
613
  }));
969
- return new __HttpRequest({
970
- protocol,
971
- hostname,
972
- port,
973
- method: "POST",
974
- headers,
975
- path: resolvedPath,
976
- body,
977
- });
614
+ b.m("POST").h(headers).b(body);
615
+ return b.build();
978
616
  };
979
617
  export const se_GetResourceEventConfigurationCommand = async (input, context) => {
980
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
618
+ const b = rb(input, context);
981
619
  const headers = {};
982
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/event-configurations/{Identifier}";
983
- resolvedPath = __resolvedPath(resolvedPath, input, "Identifier", () => input.Identifier, "{Identifier}", false);
620
+ b.bp("/event-configurations/{Identifier}");
621
+ b.p("Identifier", () => input.Identifier, "{Identifier}", false);
984
622
  const query = map({
985
- identifierType: [, __expectNonNull(input.IdentifierType, `IdentifierType`)],
986
- partnerType: [, input.PartnerType],
623
+ [_iT]: [, __expectNonNull(input[_IT], `IdentifierType`)],
624
+ [_pT]: [, input[_PT]],
987
625
  });
988
626
  let body;
989
- return new __HttpRequest({
990
- protocol,
991
- hostname,
992
- port,
993
- method: "GET",
994
- headers,
995
- path: resolvedPath,
996
- query,
997
- body,
998
- });
627
+ b.m("GET").h(headers).q(query).b(body);
628
+ return b.build();
999
629
  };
1000
630
  export const se_GetResourceLogLevelCommand = async (input, context) => {
1001
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
631
+ const b = rb(input, context);
1002
632
  const headers = {};
1003
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/log-levels/{ResourceIdentifier}";
1004
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceIdentifier", () => input.ResourceIdentifier, "{ResourceIdentifier}", false);
633
+ b.bp("/log-levels/{ResourceIdentifier}");
634
+ b.p("ResourceIdentifier", () => input.ResourceIdentifier, "{ResourceIdentifier}", false);
1005
635
  const query = map({
1006
- resourceType: [, __expectNonNull(input.ResourceType, `ResourceType`)],
636
+ [_rT]: [, __expectNonNull(input[_RT], `ResourceType`)],
1007
637
  });
1008
638
  let body;
1009
- return new __HttpRequest({
1010
- protocol,
1011
- hostname,
1012
- port,
1013
- method: "GET",
1014
- headers,
1015
- path: resolvedPath,
1016
- query,
1017
- body,
1018
- });
639
+ b.m("GET").h(headers).q(query).b(body);
640
+ return b.build();
1019
641
  };
1020
642
  export const se_GetResourcePositionCommand = async (input, context) => {
1021
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
643
+ const b = rb(input, context);
1022
644
  const headers = {};
1023
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/resource-positions/{ResourceIdentifier}";
1024
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceIdentifier", () => input.ResourceIdentifier, "{ResourceIdentifier}", false);
645
+ b.bp("/resource-positions/{ResourceIdentifier}");
646
+ b.p("ResourceIdentifier", () => input.ResourceIdentifier, "{ResourceIdentifier}", false);
1025
647
  const query = map({
1026
- resourceType: [, __expectNonNull(input.ResourceType, `ResourceType`)],
648
+ [_rT]: [, __expectNonNull(input[_RT], `ResourceType`)],
1027
649
  });
1028
650
  let body;
1029
- return new __HttpRequest({
1030
- protocol,
1031
- hostname,
1032
- port,
1033
- method: "GET",
1034
- headers,
1035
- path: resolvedPath,
1036
- query,
1037
- body,
1038
- });
651
+ b.m("GET").h(headers).q(query).b(body);
652
+ return b.build();
1039
653
  };
1040
654
  export const se_GetServiceEndpointCommand = async (input, context) => {
1041
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
655
+ const b = rb(input, context);
1042
656
  const headers = {};
1043
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/service-endpoint";
657
+ b.bp("/service-endpoint");
1044
658
  const query = map({
1045
- serviceType: [, input.ServiceType],
659
+ [_sT]: [, input[_ST]],
1046
660
  });
1047
661
  let body;
1048
- return new __HttpRequest({
1049
- protocol,
1050
- hostname,
1051
- port,
1052
- method: "GET",
1053
- headers,
1054
- path: resolvedPath,
1055
- query,
1056
- body,
1057
- });
662
+ b.m("GET").h(headers).q(query).b(body);
663
+ return b.build();
1058
664
  };
1059
665
  export const se_GetServiceProfileCommand = async (input, context) => {
1060
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
666
+ const b = rb(input, context);
1061
667
  const headers = {};
1062
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/service-profiles/{Id}";
1063
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
668
+ b.bp("/service-profiles/{Id}");
669
+ b.p("Id", () => input.Id, "{Id}", false);
1064
670
  let body;
1065
- return new __HttpRequest({
1066
- protocol,
1067
- hostname,
1068
- port,
1069
- method: "GET",
1070
- headers,
1071
- path: resolvedPath,
1072
- body,
1073
- });
671
+ b.m("GET").h(headers).b(body);
672
+ return b.build();
1074
673
  };
1075
674
  export const se_GetWirelessDeviceCommand = async (input, context) => {
1076
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
675
+ const b = rb(input, context);
1077
676
  const headers = {};
1078
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-devices/{Identifier}";
1079
- resolvedPath = __resolvedPath(resolvedPath, input, "Identifier", () => input.Identifier, "{Identifier}", false);
677
+ b.bp("/wireless-devices/{Identifier}");
678
+ b.p("Identifier", () => input.Identifier, "{Identifier}", false);
1080
679
  const query = map({
1081
- identifierType: [, __expectNonNull(input.IdentifierType, `IdentifierType`)],
680
+ [_iT]: [, __expectNonNull(input[_IT], `IdentifierType`)],
1082
681
  });
1083
682
  let body;
1084
- return new __HttpRequest({
1085
- protocol,
1086
- hostname,
1087
- port,
1088
- method: "GET",
1089
- headers,
1090
- path: resolvedPath,
1091
- query,
1092
- body,
1093
- });
683
+ b.m("GET").h(headers).q(query).b(body);
684
+ return b.build();
1094
685
  };
1095
686
  export const se_GetWirelessDeviceImportTaskCommand = async (input, context) => {
1096
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
687
+ const b = rb(input, context);
1097
688
  const headers = {};
1098
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless_device_import_task/{Id}";
1099
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
689
+ b.bp("/wireless_device_import_task/{Id}");
690
+ b.p("Id", () => input.Id, "{Id}", false);
1100
691
  let body;
1101
- return new __HttpRequest({
1102
- protocol,
1103
- hostname,
1104
- port,
1105
- method: "GET",
1106
- headers,
1107
- path: resolvedPath,
1108
- body,
1109
- });
692
+ b.m("GET").h(headers).b(body);
693
+ return b.build();
1110
694
  };
1111
695
  export const se_GetWirelessDeviceStatisticsCommand = async (input, context) => {
1112
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
696
+ const b = rb(input, context);
1113
697
  const headers = {};
1114
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1115
- "/wireless-devices/{WirelessDeviceId}/statistics";
1116
- resolvedPath = __resolvedPath(resolvedPath, input, "WirelessDeviceId", () => input.WirelessDeviceId, "{WirelessDeviceId}", false);
698
+ b.bp("/wireless-devices/{WirelessDeviceId}/statistics");
699
+ b.p("WirelessDeviceId", () => input.WirelessDeviceId, "{WirelessDeviceId}", false);
1117
700
  let body;
1118
- return new __HttpRequest({
1119
- protocol,
1120
- hostname,
1121
- port,
1122
- method: "GET",
1123
- headers,
1124
- path: resolvedPath,
1125
- body,
1126
- });
701
+ b.m("GET").h(headers).b(body);
702
+ return b.build();
1127
703
  };
1128
704
  export const se_GetWirelessGatewayCommand = async (input, context) => {
1129
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
705
+ const b = rb(input, context);
1130
706
  const headers = {};
1131
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-gateways/{Identifier}";
1132
- resolvedPath = __resolvedPath(resolvedPath, input, "Identifier", () => input.Identifier, "{Identifier}", false);
707
+ b.bp("/wireless-gateways/{Identifier}");
708
+ b.p("Identifier", () => input.Identifier, "{Identifier}", false);
1133
709
  const query = map({
1134
- identifierType: [, __expectNonNull(input.IdentifierType, `IdentifierType`)],
710
+ [_iT]: [, __expectNonNull(input[_IT], `IdentifierType`)],
1135
711
  });
1136
712
  let body;
1137
- return new __HttpRequest({
1138
- protocol,
1139
- hostname,
1140
- port,
1141
- method: "GET",
1142
- headers,
1143
- path: resolvedPath,
1144
- query,
1145
- body,
1146
- });
713
+ b.m("GET").h(headers).q(query).b(body);
714
+ return b.build();
1147
715
  };
1148
716
  export const se_GetWirelessGatewayCertificateCommand = async (input, context) => {
1149
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
717
+ const b = rb(input, context);
1150
718
  const headers = {};
1151
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-gateways/{Id}/certificate";
1152
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
719
+ b.bp("/wireless-gateways/{Id}/certificate");
720
+ b.p("Id", () => input.Id, "{Id}", false);
1153
721
  let body;
1154
- return new __HttpRequest({
1155
- protocol,
1156
- hostname,
1157
- port,
1158
- method: "GET",
1159
- headers,
1160
- path: resolvedPath,
1161
- body,
1162
- });
722
+ b.m("GET").h(headers).b(body);
723
+ return b.build();
1163
724
  };
1164
725
  export const se_GetWirelessGatewayFirmwareInformationCommand = async (input, context) => {
1165
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
726
+ const b = rb(input, context);
1166
727
  const headers = {};
1167
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1168
- "/wireless-gateways/{Id}/firmware-information";
1169
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
728
+ b.bp("/wireless-gateways/{Id}/firmware-information");
729
+ b.p("Id", () => input.Id, "{Id}", false);
1170
730
  let body;
1171
- return new __HttpRequest({
1172
- protocol,
1173
- hostname,
1174
- port,
1175
- method: "GET",
1176
- headers,
1177
- path: resolvedPath,
1178
- body,
1179
- });
731
+ b.m("GET").h(headers).b(body);
732
+ return b.build();
1180
733
  };
1181
734
  export const se_GetWirelessGatewayStatisticsCommand = async (input, context) => {
1182
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
735
+ const b = rb(input, context);
1183
736
  const headers = {};
1184
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1185
- "/wireless-gateways/{WirelessGatewayId}/statistics";
1186
- resolvedPath = __resolvedPath(resolvedPath, input, "WirelessGatewayId", () => input.WirelessGatewayId, "{WirelessGatewayId}", false);
737
+ b.bp("/wireless-gateways/{WirelessGatewayId}/statistics");
738
+ b.p("WirelessGatewayId", () => input.WirelessGatewayId, "{WirelessGatewayId}", false);
1187
739
  let body;
1188
- return new __HttpRequest({
1189
- protocol,
1190
- hostname,
1191
- port,
1192
- method: "GET",
1193
- headers,
1194
- path: resolvedPath,
1195
- body,
1196
- });
740
+ b.m("GET").h(headers).b(body);
741
+ return b.build();
1197
742
  };
1198
743
  export const se_GetWirelessGatewayTaskCommand = async (input, context) => {
1199
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
744
+ const b = rb(input, context);
1200
745
  const headers = {};
1201
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-gateways/{Id}/tasks";
1202
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
746
+ b.bp("/wireless-gateways/{Id}/tasks");
747
+ b.p("Id", () => input.Id, "{Id}", false);
1203
748
  let body;
1204
- return new __HttpRequest({
1205
- protocol,
1206
- hostname,
1207
- port,
1208
- method: "GET",
1209
- headers,
1210
- path: resolvedPath,
1211
- body,
1212
- });
749
+ b.m("GET").h(headers).b(body);
750
+ return b.build();
1213
751
  };
1214
752
  export const se_GetWirelessGatewayTaskDefinitionCommand = async (input, context) => {
1215
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
753
+ const b = rb(input, context);
1216
754
  const headers = {};
1217
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-gateway-task-definitions/{Id}";
1218
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
755
+ b.bp("/wireless-gateway-task-definitions/{Id}");
756
+ b.p("Id", () => input.Id, "{Id}", false);
1219
757
  let body;
1220
- return new __HttpRequest({
1221
- protocol,
1222
- hostname,
1223
- port,
1224
- method: "GET",
1225
- headers,
1226
- path: resolvedPath,
1227
- body,
1228
- });
758
+ b.m("GET").h(headers).b(body);
759
+ return b.build();
1229
760
  };
1230
761
  export const se_ListDestinationsCommand = async (input, context) => {
1231
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
762
+ const b = rb(input, context);
1232
763
  const headers = {};
1233
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/destinations";
764
+ b.bp("/destinations");
1234
765
  const query = map({
1235
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1236
- nextToken: [, input.NextToken],
766
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
767
+ [_nT]: [, input[_NT]],
1237
768
  });
1238
769
  let body;
1239
- return new __HttpRequest({
1240
- protocol,
1241
- hostname,
1242
- port,
1243
- method: "GET",
1244
- headers,
1245
- path: resolvedPath,
1246
- query,
1247
- body,
1248
- });
770
+ b.m("GET").h(headers).q(query).b(body);
771
+ return b.build();
1249
772
  };
1250
773
  export const se_ListDeviceProfilesCommand = async (input, context) => {
1251
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
774
+ const b = rb(input, context);
1252
775
  const headers = {};
1253
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/device-profiles";
776
+ b.bp("/device-profiles");
1254
777
  const query = map({
1255
- nextToken: [, input.NextToken],
1256
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1257
- deviceProfileType: [, input.DeviceProfileType],
778
+ [_nT]: [, input[_NT]],
779
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
780
+ [_dPT]: [, input[_DPT]],
1258
781
  });
1259
782
  let body;
1260
- return new __HttpRequest({
1261
- protocol,
1262
- hostname,
1263
- port,
1264
- method: "GET",
1265
- headers,
1266
- path: resolvedPath,
1267
- query,
1268
- body,
1269
- });
783
+ b.m("GET").h(headers).q(query).b(body);
784
+ return b.build();
1270
785
  };
1271
786
  export const se_ListDevicesForWirelessDeviceImportTaskCommand = async (input, context) => {
1272
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
787
+ const b = rb(input, context);
1273
788
  const headers = {};
1274
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless_device_import_task";
789
+ b.bp("/wireless_device_import_task");
1275
790
  const query = map({
1276
- id: [, __expectNonNull(input.Id, `Id`)],
1277
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1278
- nextToken: [, input.NextToken],
1279
- status: [, input.Status],
791
+ [_i]: [, __expectNonNull(input[_I], `Id`)],
792
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
793
+ [_nT]: [, input[_NT]],
794
+ [_s]: [, input[_S]],
1280
795
  });
1281
796
  let body;
1282
- return new __HttpRequest({
1283
- protocol,
1284
- hostname,
1285
- port,
1286
- method: "GET",
1287
- headers,
1288
- path: resolvedPath,
1289
- query,
1290
- body,
1291
- });
797
+ b.m("GET").h(headers).q(query).b(body);
798
+ return b.build();
1292
799
  };
1293
800
  export const se_ListEventConfigurationsCommand = async (input, context) => {
1294
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
801
+ const b = rb(input, context);
1295
802
  const headers = {};
1296
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/event-configurations";
803
+ b.bp("/event-configurations");
1297
804
  const query = map({
1298
- resourceType: [, __expectNonNull(input.ResourceType, `ResourceType`)],
1299
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1300
- nextToken: [, input.NextToken],
805
+ [_rT]: [, __expectNonNull(input[_RT], `ResourceType`)],
806
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
807
+ [_nT]: [, input[_NT]],
1301
808
  });
1302
809
  let body;
1303
- return new __HttpRequest({
1304
- protocol,
1305
- hostname,
1306
- port,
1307
- method: "GET",
1308
- headers,
1309
- path: resolvedPath,
1310
- query,
1311
- body,
1312
- });
810
+ b.m("GET").h(headers).q(query).b(body);
811
+ return b.build();
1313
812
  };
1314
813
  export const se_ListFuotaTasksCommand = async (input, context) => {
1315
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
814
+ const b = rb(input, context);
1316
815
  const headers = {};
1317
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/fuota-tasks";
816
+ b.bp("/fuota-tasks");
1318
817
  const query = map({
1319
- nextToken: [, input.NextToken],
1320
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
818
+ [_nT]: [, input[_NT]],
819
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1321
820
  });
1322
821
  let body;
1323
- return new __HttpRequest({
1324
- protocol,
1325
- hostname,
1326
- port,
1327
- method: "GET",
1328
- headers,
1329
- path: resolvedPath,
1330
- query,
1331
- body,
1332
- });
822
+ b.m("GET").h(headers).q(query).b(body);
823
+ return b.build();
1333
824
  };
1334
825
  export const se_ListMulticastGroupsCommand = async (input, context) => {
1335
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
826
+ const b = rb(input, context);
1336
827
  const headers = {};
1337
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/multicast-groups";
828
+ b.bp("/multicast-groups");
1338
829
  const query = map({
1339
- nextToken: [, input.NextToken],
1340
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
830
+ [_nT]: [, input[_NT]],
831
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1341
832
  });
1342
833
  let body;
1343
- return new __HttpRequest({
1344
- protocol,
1345
- hostname,
1346
- port,
1347
- method: "GET",
1348
- headers,
1349
- path: resolvedPath,
1350
- query,
1351
- body,
1352
- });
834
+ b.m("GET").h(headers).q(query).b(body);
835
+ return b.build();
1353
836
  };
1354
837
  export const se_ListMulticastGroupsByFuotaTaskCommand = async (input, context) => {
1355
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
838
+ const b = rb(input, context);
1356
839
  const headers = {};
1357
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/fuota-tasks/{Id}/multicast-groups";
1358
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
840
+ b.bp("/fuota-tasks/{Id}/multicast-groups");
841
+ b.p("Id", () => input.Id, "{Id}", false);
1359
842
  const query = map({
1360
- nextToken: [, input.NextToken],
1361
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
843
+ [_nT]: [, input[_NT]],
844
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1362
845
  });
1363
846
  let body;
1364
- return new __HttpRequest({
1365
- protocol,
1366
- hostname,
1367
- port,
1368
- method: "GET",
1369
- headers,
1370
- path: resolvedPath,
1371
- query,
1372
- body,
1373
- });
847
+ b.m("GET").h(headers).q(query).b(body);
848
+ return b.build();
1374
849
  };
1375
850
  export const se_ListNetworkAnalyzerConfigurationsCommand = async (input, context) => {
1376
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
851
+ const b = rb(input, context);
1377
852
  const headers = {};
1378
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/network-analyzer-configurations";
853
+ b.bp("/network-analyzer-configurations");
1379
854
  const query = map({
1380
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1381
- nextToken: [, input.NextToken],
855
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
856
+ [_nT]: [, input[_NT]],
1382
857
  });
1383
858
  let body;
1384
- return new __HttpRequest({
1385
- protocol,
1386
- hostname,
1387
- port,
1388
- method: "GET",
1389
- headers,
1390
- path: resolvedPath,
1391
- query,
1392
- body,
1393
- });
859
+ b.m("GET").h(headers).q(query).b(body);
860
+ return b.build();
1394
861
  };
1395
862
  export const se_ListPartnerAccountsCommand = async (input, context) => {
1396
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
863
+ const b = rb(input, context);
1397
864
  const headers = {};
1398
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/partner-accounts";
865
+ b.bp("/partner-accounts");
1399
866
  const query = map({
1400
- nextToken: [, input.NextToken],
1401
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
867
+ [_nT]: [, input[_NT]],
868
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1402
869
  });
1403
870
  let body;
1404
- return new __HttpRequest({
1405
- protocol,
1406
- hostname,
1407
- port,
1408
- method: "GET",
1409
- headers,
1410
- path: resolvedPath,
1411
- query,
1412
- body,
1413
- });
871
+ b.m("GET").h(headers).q(query).b(body);
872
+ return b.build();
1414
873
  };
1415
874
  export const se_ListPositionConfigurationsCommand = async (input, context) => {
1416
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
875
+ const b = rb(input, context);
1417
876
  const headers = {};
1418
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/position-configurations";
877
+ b.bp("/position-configurations");
1419
878
  const query = map({
1420
- resourceType: [, input.ResourceType],
1421
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1422
- nextToken: [, input.NextToken],
879
+ [_rT]: [, input[_RT]],
880
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
881
+ [_nT]: [, input[_NT]],
1423
882
  });
1424
883
  let body;
1425
- return new __HttpRequest({
1426
- protocol,
1427
- hostname,
1428
- port,
1429
- method: "GET",
1430
- headers,
1431
- path: resolvedPath,
1432
- query,
1433
- body,
1434
- });
884
+ b.m("GET").h(headers).q(query).b(body);
885
+ return b.build();
1435
886
  };
1436
887
  export const se_ListQueuedMessagesCommand = async (input, context) => {
1437
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
888
+ const b = rb(input, context);
1438
889
  const headers = {};
1439
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-devices/{Id}/data";
1440
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
890
+ b.bp("/wireless-devices/{Id}/data");
891
+ b.p("Id", () => input.Id, "{Id}", false);
1441
892
  const query = map({
1442
- nextToken: [, input.NextToken],
1443
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1444
- WirelessDeviceType: [, input.WirelessDeviceType],
893
+ [_nT]: [, input[_NT]],
894
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
895
+ [_WDT]: [, input[_WDT]],
1445
896
  });
1446
897
  let body;
1447
- return new __HttpRequest({
1448
- protocol,
1449
- hostname,
1450
- port,
1451
- method: "GET",
1452
- headers,
1453
- path: resolvedPath,
1454
- query,
1455
- body,
1456
- });
898
+ b.m("GET").h(headers).q(query).b(body);
899
+ return b.build();
1457
900
  };
1458
901
  export const se_ListServiceProfilesCommand = async (input, context) => {
1459
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
902
+ const b = rb(input, context);
1460
903
  const headers = {};
1461
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/service-profiles";
904
+ b.bp("/service-profiles");
1462
905
  const query = map({
1463
- nextToken: [, input.NextToken],
1464
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
906
+ [_nT]: [, input[_NT]],
907
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1465
908
  });
1466
909
  let body;
1467
- return new __HttpRequest({
1468
- protocol,
1469
- hostname,
1470
- port,
1471
- method: "GET",
1472
- headers,
1473
- path: resolvedPath,
1474
- query,
1475
- body,
1476
- });
910
+ b.m("GET").h(headers).q(query).b(body);
911
+ return b.build();
1477
912
  };
1478
913
  export const se_ListTagsForResourceCommand = async (input, context) => {
1479
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
914
+ const b = rb(input, context);
1480
915
  const headers = {};
1481
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags";
916
+ b.bp("/tags");
1482
917
  const query = map({
1483
- resourceArn: [, __expectNonNull(input.ResourceArn, `ResourceArn`)],
918
+ [_rA]: [, __expectNonNull(input[_RA], `ResourceArn`)],
1484
919
  });
1485
920
  let body;
1486
- return new __HttpRequest({
1487
- protocol,
1488
- hostname,
1489
- port,
1490
- method: "GET",
1491
- headers,
1492
- path: resolvedPath,
1493
- query,
1494
- body,
1495
- });
921
+ b.m("GET").h(headers).q(query).b(body);
922
+ return b.build();
1496
923
  };
1497
924
  export const se_ListWirelessDeviceImportTasksCommand = async (input, context) => {
1498
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
925
+ const b = rb(input, context);
1499
926
  const headers = {};
1500
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless_device_import_tasks";
927
+ b.bp("/wireless_device_import_tasks");
1501
928
  const query = map({
1502
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1503
- nextToken: [, input.NextToken],
929
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
930
+ [_nT]: [, input[_NT]],
1504
931
  });
1505
932
  let body;
1506
- return new __HttpRequest({
1507
- protocol,
1508
- hostname,
1509
- port,
1510
- method: "GET",
1511
- headers,
1512
- path: resolvedPath,
1513
- query,
1514
- body,
1515
- });
933
+ b.m("GET").h(headers).q(query).b(body);
934
+ return b.build();
1516
935
  };
1517
936
  export const se_ListWirelessDevicesCommand = async (input, context) => {
1518
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
937
+ const b = rb(input, context);
1519
938
  const headers = {};
1520
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-devices";
939
+ b.bp("/wireless-devices");
1521
940
  const query = map({
1522
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1523
- nextToken: [, input.NextToken],
1524
- destinationName: [, input.DestinationName],
1525
- deviceProfileId: [, input.DeviceProfileId],
1526
- serviceProfileId: [, input.ServiceProfileId],
1527
- wirelessDeviceType: [, input.WirelessDeviceType],
1528
- fuotaTaskId: [, input.FuotaTaskId],
1529
- multicastGroupId: [, input.MulticastGroupId],
941
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
942
+ [_nT]: [, input[_NT]],
943
+ [_dN]: [, input[_DN]],
944
+ [_dPI]: [, input[_DPI]],
945
+ [_sPI]: [, input[_SPI]],
946
+ [_wDT]: [, input[_WDT]],
947
+ [_fTI]: [, input[_FTI]],
948
+ [_mGI]: [, input[_MGI]],
1530
949
  });
1531
950
  let body;
1532
- return new __HttpRequest({
1533
- protocol,
1534
- hostname,
1535
- port,
1536
- method: "GET",
1537
- headers,
1538
- path: resolvedPath,
1539
- query,
1540
- body,
1541
- });
951
+ b.m("GET").h(headers).q(query).b(body);
952
+ return b.build();
1542
953
  };
1543
954
  export const se_ListWirelessGatewaysCommand = async (input, context) => {
1544
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
955
+ const b = rb(input, context);
1545
956
  const headers = {};
1546
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-gateways";
957
+ b.bp("/wireless-gateways");
1547
958
  const query = map({
1548
- nextToken: [, input.NextToken],
1549
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
959
+ [_nT]: [, input[_NT]],
960
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1550
961
  });
1551
962
  let body;
1552
- return new __HttpRequest({
1553
- protocol,
1554
- hostname,
1555
- port,
1556
- method: "GET",
1557
- headers,
1558
- path: resolvedPath,
1559
- query,
1560
- body,
1561
- });
963
+ b.m("GET").h(headers).q(query).b(body);
964
+ return b.build();
1562
965
  };
1563
966
  export const se_ListWirelessGatewayTaskDefinitionsCommand = async (input, context) => {
1564
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
967
+ const b = rb(input, context);
1565
968
  const headers = {};
1566
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-gateway-task-definitions";
969
+ b.bp("/wireless-gateway-task-definitions");
1567
970
  const query = map({
1568
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1569
- nextToken: [, input.NextToken],
1570
- taskDefinitionType: [, input.TaskDefinitionType],
971
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
972
+ [_nT]: [, input[_NT]],
973
+ [_tDT]: [, input[_TDT]],
1571
974
  });
1572
975
  let body;
1573
- return new __HttpRequest({
1574
- protocol,
1575
- hostname,
1576
- port,
1577
- method: "GET",
1578
- headers,
1579
- path: resolvedPath,
1580
- query,
1581
- body,
1582
- });
976
+ b.m("GET").h(headers).q(query).b(body);
977
+ return b.build();
1583
978
  };
1584
979
  export const se_PutPositionConfigurationCommand = async (input, context) => {
1585
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
980
+ const b = rb(input, context);
1586
981
  const headers = {
1587
982
  "content-type": "application/json",
1588
983
  };
1589
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1590
- "/position-configurations/{ResourceIdentifier}";
1591
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceIdentifier", () => input.ResourceIdentifier, "{ResourceIdentifier}", false);
984
+ b.bp("/position-configurations/{ResourceIdentifier}");
985
+ b.p("ResourceIdentifier", () => input.ResourceIdentifier, "{ResourceIdentifier}", false);
1592
986
  const query = map({
1593
- resourceType: [, __expectNonNull(input.ResourceType, `ResourceType`)],
987
+ [_rT]: [, __expectNonNull(input[_RT], `ResourceType`)],
1594
988
  });
1595
989
  let body;
1596
990
  body = JSON.stringify(take(input, {
1597
991
  Destination: [],
1598
992
  Solvers: (_) => _json(_),
1599
993
  }));
1600
- return new __HttpRequest({
1601
- protocol,
1602
- hostname,
1603
- port,
1604
- method: "PUT",
1605
- headers,
1606
- path: resolvedPath,
1607
- query,
1608
- body,
1609
- });
994
+ b.m("PUT").h(headers).q(query).b(body);
995
+ return b.build();
1610
996
  };
1611
997
  export const se_PutResourceLogLevelCommand = async (input, context) => {
1612
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
998
+ const b = rb(input, context);
1613
999
  const headers = {
1614
1000
  "content-type": "application/json",
1615
1001
  };
1616
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/log-levels/{ResourceIdentifier}";
1617
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceIdentifier", () => input.ResourceIdentifier, "{ResourceIdentifier}", false);
1002
+ b.bp("/log-levels/{ResourceIdentifier}");
1003
+ b.p("ResourceIdentifier", () => input.ResourceIdentifier, "{ResourceIdentifier}", false);
1618
1004
  const query = map({
1619
- resourceType: [, __expectNonNull(input.ResourceType, `ResourceType`)],
1005
+ [_rT]: [, __expectNonNull(input[_RT], `ResourceType`)],
1620
1006
  });
1621
1007
  let body;
1622
1008
  body = JSON.stringify(take(input, {
1623
1009
  LogLevel: [],
1624
1010
  }));
1625
- return new __HttpRequest({
1626
- protocol,
1627
- hostname,
1628
- port,
1629
- method: "PUT",
1630
- headers,
1631
- path: resolvedPath,
1632
- query,
1633
- body,
1634
- });
1011
+ b.m("PUT").h(headers).q(query).b(body);
1012
+ return b.build();
1635
1013
  };
1636
1014
  export const se_ResetAllResourceLogLevelsCommand = async (input, context) => {
1637
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1015
+ const b = rb(input, context);
1638
1016
  const headers = {
1639
1017
  "content-type": "application/json",
1640
1018
  };
1641
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/log-levels";
1019
+ b.bp("/log-levels");
1642
1020
  let body;
1643
1021
  body = "";
1644
- return new __HttpRequest({
1645
- protocol,
1646
- hostname,
1647
- port,
1648
- method: "DELETE",
1649
- headers,
1650
- path: resolvedPath,
1651
- body,
1652
- });
1022
+ b.m("DELETE").h(headers).b(body);
1023
+ return b.build();
1653
1024
  };
1654
1025
  export const se_ResetResourceLogLevelCommand = async (input, context) => {
1655
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1026
+ const b = rb(input, context);
1656
1027
  const headers = {};
1657
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/log-levels/{ResourceIdentifier}";
1658
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceIdentifier", () => input.ResourceIdentifier, "{ResourceIdentifier}", false);
1028
+ b.bp("/log-levels/{ResourceIdentifier}");
1029
+ b.p("ResourceIdentifier", () => input.ResourceIdentifier, "{ResourceIdentifier}", false);
1659
1030
  const query = map({
1660
- resourceType: [, __expectNonNull(input.ResourceType, `ResourceType`)],
1031
+ [_rT]: [, __expectNonNull(input[_RT], `ResourceType`)],
1661
1032
  });
1662
1033
  let body;
1663
- return new __HttpRequest({
1664
- protocol,
1665
- hostname,
1666
- port,
1667
- method: "DELETE",
1668
- headers,
1669
- path: resolvedPath,
1670
- query,
1671
- body,
1672
- });
1034
+ b.m("DELETE").h(headers).q(query).b(body);
1035
+ return b.build();
1673
1036
  };
1674
1037
  export const se_SendDataToMulticastGroupCommand = async (input, context) => {
1675
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1038
+ const b = rb(input, context);
1676
1039
  const headers = {
1677
1040
  "content-type": "application/json",
1678
1041
  };
1679
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/multicast-groups/{Id}/data";
1680
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
1042
+ b.bp("/multicast-groups/{Id}/data");
1043
+ b.p("Id", () => input.Id, "{Id}", false);
1681
1044
  let body;
1682
1045
  body = JSON.stringify(take(input, {
1683
1046
  PayloadData: [],
1684
1047
  WirelessMetadata: (_) => _json(_),
1685
1048
  }));
1686
- return new __HttpRequest({
1687
- protocol,
1688
- hostname,
1689
- port,
1690
- method: "POST",
1691
- headers,
1692
- path: resolvedPath,
1693
- body,
1694
- });
1049
+ b.m("POST").h(headers).b(body);
1050
+ return b.build();
1695
1051
  };
1696
1052
  export const se_SendDataToWirelessDeviceCommand = async (input, context) => {
1697
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1053
+ const b = rb(input, context);
1698
1054
  const headers = {
1699
1055
  "content-type": "application/json",
1700
1056
  };
1701
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-devices/{Id}/data";
1702
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
1057
+ b.bp("/wireless-devices/{Id}/data");
1058
+ b.p("Id", () => input.Id, "{Id}", false);
1703
1059
  let body;
1704
1060
  body = JSON.stringify(take(input, {
1705
1061
  PayloadData: [],
1706
1062
  TransmitMode: [],
1707
1063
  WirelessMetadata: (_) => _json(_),
1708
1064
  }));
1709
- return new __HttpRequest({
1710
- protocol,
1711
- hostname,
1712
- port,
1713
- method: "POST",
1714
- headers,
1715
- path: resolvedPath,
1716
- body,
1717
- });
1065
+ b.m("POST").h(headers).b(body);
1066
+ return b.build();
1718
1067
  };
1719
1068
  export const se_StartBulkAssociateWirelessDeviceWithMulticastGroupCommand = async (input, context) => {
1720
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1069
+ const b = rb(input, context);
1721
1070
  const headers = {
1722
1071
  "content-type": "application/json",
1723
1072
  };
1724
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/multicast-groups/{Id}/bulk";
1725
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
1073
+ b.bp("/multicast-groups/{Id}/bulk");
1074
+ b.p("Id", () => input.Id, "{Id}", false);
1726
1075
  let body;
1727
1076
  body = JSON.stringify(take(input, {
1728
1077
  QueryString: [],
1729
1078
  Tags: (_) => _json(_),
1730
1079
  }));
1731
- return new __HttpRequest({
1732
- protocol,
1733
- hostname,
1734
- port,
1735
- method: "PATCH",
1736
- headers,
1737
- path: resolvedPath,
1738
- body,
1739
- });
1080
+ b.m("PATCH").h(headers).b(body);
1081
+ return b.build();
1740
1082
  };
1741
1083
  export const se_StartBulkDisassociateWirelessDeviceFromMulticastGroupCommand = async (input, context) => {
1742
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1084
+ const b = rb(input, context);
1743
1085
  const headers = {
1744
1086
  "content-type": "application/json",
1745
1087
  };
1746
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/multicast-groups/{Id}/bulk";
1747
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
1088
+ b.bp("/multicast-groups/{Id}/bulk");
1089
+ b.p("Id", () => input.Id, "{Id}", false);
1748
1090
  let body;
1749
1091
  body = JSON.stringify(take(input, {
1750
1092
  QueryString: [],
1751
1093
  Tags: (_) => _json(_),
1752
1094
  }));
1753
- return new __HttpRequest({
1754
- protocol,
1755
- hostname,
1756
- port,
1757
- method: "POST",
1758
- headers,
1759
- path: resolvedPath,
1760
- body,
1761
- });
1095
+ b.m("POST").h(headers).b(body);
1096
+ return b.build();
1762
1097
  };
1763
1098
  export const se_StartFuotaTaskCommand = async (input, context) => {
1764
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1099
+ const b = rb(input, context);
1765
1100
  const headers = {
1766
1101
  "content-type": "application/json",
1767
1102
  };
1768
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/fuota-tasks/{Id}";
1769
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
1103
+ b.bp("/fuota-tasks/{Id}");
1104
+ b.p("Id", () => input.Id, "{Id}", false);
1770
1105
  let body;
1771
1106
  body = JSON.stringify(take(input, {
1772
1107
  LoRaWAN: (_) => se_LoRaWANStartFuotaTask(_, context),
1773
1108
  }));
1774
- return new __HttpRequest({
1775
- protocol,
1776
- hostname,
1777
- port,
1778
- method: "PUT",
1779
- headers,
1780
- path: resolvedPath,
1781
- body,
1782
- });
1109
+ b.m("PUT").h(headers).b(body);
1110
+ return b.build();
1783
1111
  };
1784
1112
  export const se_StartMulticastGroupSessionCommand = async (input, context) => {
1785
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1113
+ const b = rb(input, context);
1786
1114
  const headers = {
1787
1115
  "content-type": "application/json",
1788
1116
  };
1789
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/multicast-groups/{Id}/session";
1790
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
1117
+ b.bp("/multicast-groups/{Id}/session");
1118
+ b.p("Id", () => input.Id, "{Id}", false);
1791
1119
  let body;
1792
1120
  body = JSON.stringify(take(input, {
1793
1121
  LoRaWAN: (_) => se_LoRaWANMulticastSession(_, context),
1794
1122
  }));
1795
- return new __HttpRequest({
1796
- protocol,
1797
- hostname,
1798
- port,
1799
- method: "PUT",
1800
- headers,
1801
- path: resolvedPath,
1802
- body,
1803
- });
1123
+ b.m("PUT").h(headers).b(body);
1124
+ return b.build();
1804
1125
  };
1805
1126
  export const se_StartSingleWirelessDeviceImportTaskCommand = async (input, context) => {
1806
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1127
+ const b = rb(input, context);
1807
1128
  const headers = {
1808
1129
  "content-type": "application/json",
1809
1130
  };
1810
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless_single_device_import_task";
1131
+ b.bp("/wireless_single_device_import_task");
1811
1132
  let body;
1812
1133
  body = JSON.stringify(take(input, {
1813
1134
  ClientRequestToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -1816,22 +1137,15 @@ export const se_StartSingleWirelessDeviceImportTaskCommand = async (input, conte
1816
1137
  Sidewalk: (_) => _json(_),
1817
1138
  Tags: (_) => _json(_),
1818
1139
  }));
1819
- return new __HttpRequest({
1820
- protocol,
1821
- hostname,
1822
- port,
1823
- method: "POST",
1824
- headers,
1825
- path: resolvedPath,
1826
- body,
1827
- });
1140
+ b.m("POST").h(headers).b(body);
1141
+ return b.build();
1828
1142
  };
1829
1143
  export const se_StartWirelessDeviceImportTaskCommand = async (input, context) => {
1830
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1144
+ const b = rb(input, context);
1831
1145
  const headers = {
1832
1146
  "content-type": "application/json",
1833
1147
  };
1834
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless_device_import_task";
1148
+ b.bp("/wireless_device_import_task");
1835
1149
  let body;
1836
1150
  body = JSON.stringify(take(input, {
1837
1151
  ClientRequestToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -1839,86 +1153,56 @@ export const se_StartWirelessDeviceImportTaskCommand = async (input, context) =>
1839
1153
  Sidewalk: (_) => _json(_),
1840
1154
  Tags: (_) => _json(_),
1841
1155
  }));
1842
- return new __HttpRequest({
1843
- protocol,
1844
- hostname,
1845
- port,
1846
- method: "POST",
1847
- headers,
1848
- path: resolvedPath,
1849
- body,
1850
- });
1156
+ b.m("POST").h(headers).b(body);
1157
+ return b.build();
1851
1158
  };
1852
1159
  export const se_TagResourceCommand = async (input, context) => {
1853
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1160
+ const b = rb(input, context);
1854
1161
  const headers = {
1855
1162
  "content-type": "application/json",
1856
1163
  };
1857
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags";
1164
+ b.bp("/tags");
1858
1165
  const query = map({
1859
- resourceArn: [, __expectNonNull(input.ResourceArn, `ResourceArn`)],
1166
+ [_rA]: [, __expectNonNull(input[_RA], `ResourceArn`)],
1860
1167
  });
1861
1168
  let body;
1862
1169
  body = JSON.stringify(take(input, {
1863
1170
  Tags: (_) => _json(_),
1864
1171
  }));
1865
- return new __HttpRequest({
1866
- protocol,
1867
- hostname,
1868
- port,
1869
- method: "POST",
1870
- headers,
1871
- path: resolvedPath,
1872
- query,
1873
- body,
1874
- });
1172
+ b.m("POST").h(headers).q(query).b(body);
1173
+ return b.build();
1875
1174
  };
1876
1175
  export const se_TestWirelessDeviceCommand = async (input, context) => {
1877
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1176
+ const b = rb(input, context);
1878
1177
  const headers = {};
1879
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-devices/{Id}/test";
1880
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
1178
+ b.bp("/wireless-devices/{Id}/test");
1179
+ b.p("Id", () => input.Id, "{Id}", false);
1881
1180
  let body;
1882
- return new __HttpRequest({
1883
- protocol,
1884
- hostname,
1885
- port,
1886
- method: "POST",
1887
- headers,
1888
- path: resolvedPath,
1889
- body,
1890
- });
1181
+ b.m("POST").h(headers).b(body);
1182
+ return b.build();
1891
1183
  };
1892
1184
  export const se_UntagResourceCommand = async (input, context) => {
1893
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1185
+ const b = rb(input, context);
1894
1186
  const headers = {};
1895
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags";
1187
+ b.bp("/tags");
1896
1188
  const query = map({
1897
- resourceArn: [, __expectNonNull(input.ResourceArn, `ResourceArn`)],
1898
- tagKeys: [
1189
+ [_rA]: [, __expectNonNull(input[_RA], `ResourceArn`)],
1190
+ [_tK]: [
1899
1191
  __expectNonNull(input.TagKeys, `TagKeys`) != null,
1900
- () => (input.TagKeys || []).map((_entry) => _entry),
1192
+ () => (input[_TK] || []).map((_entry) => _entry),
1901
1193
  ],
1902
1194
  });
1903
1195
  let body;
1904
- return new __HttpRequest({
1905
- protocol,
1906
- hostname,
1907
- port,
1908
- method: "DELETE",
1909
- headers,
1910
- path: resolvedPath,
1911
- query,
1912
- body,
1913
- });
1196
+ b.m("DELETE").h(headers).q(query).b(body);
1197
+ return b.build();
1914
1198
  };
1915
1199
  export const se_UpdateDestinationCommand = async (input, context) => {
1916
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1200
+ const b = rb(input, context);
1917
1201
  const headers = {
1918
1202
  "content-type": "application/json",
1919
1203
  };
1920
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/destinations/{Name}";
1921
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
1204
+ b.bp("/destinations/{Name}");
1205
+ b.p("Name", () => input.Name, "{Name}", false);
1922
1206
  let body;
1923
1207
  body = JSON.stringify(take(input, {
1924
1208
  Description: [],
@@ -1926,22 +1210,15 @@ export const se_UpdateDestinationCommand = async (input, context) => {
1926
1210
  ExpressionType: [],
1927
1211
  RoleArn: [],
1928
1212
  }));
1929
- return new __HttpRequest({
1930
- protocol,
1931
- hostname,
1932
- port,
1933
- method: "PATCH",
1934
- headers,
1935
- path: resolvedPath,
1936
- body,
1937
- });
1213
+ b.m("PATCH").h(headers).b(body);
1214
+ return b.build();
1938
1215
  };
1939
1216
  export const se_UpdateEventConfigurationByResourceTypesCommand = async (input, context) => {
1940
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1217
+ const b = rb(input, context);
1941
1218
  const headers = {
1942
1219
  "content-type": "application/json",
1943
1220
  };
1944
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/event-configurations-resource-types";
1221
+ b.bp("/event-configurations-resource-types");
1945
1222
  let body;
1946
1223
  body = JSON.stringify(take(input, {
1947
1224
  ConnectionStatus: (_) => _json(_),
@@ -1950,23 +1227,16 @@ export const se_UpdateEventConfigurationByResourceTypesCommand = async (input, c
1950
1227
  MessageDeliveryStatus: (_) => _json(_),
1951
1228
  Proximity: (_) => _json(_),
1952
1229
  }));
1953
- return new __HttpRequest({
1954
- protocol,
1955
- hostname,
1956
- port,
1957
- method: "PATCH",
1958
- headers,
1959
- path: resolvedPath,
1960
- body,
1961
- });
1230
+ b.m("PATCH").h(headers).b(body);
1231
+ return b.build();
1962
1232
  };
1963
1233
  export const se_UpdateFuotaTaskCommand = async (input, context) => {
1964
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1234
+ const b = rb(input, context);
1965
1235
  const headers = {
1966
1236
  "content-type": "application/json",
1967
1237
  };
1968
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/fuota-tasks/{Id}";
1969
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
1238
+ b.bp("/fuota-tasks/{Id}");
1239
+ b.p("Id", () => input.Id, "{Id}", false);
1970
1240
  let body;
1971
1241
  body = JSON.stringify(take(input, {
1972
1242
  Description: [],
@@ -1978,69 +1248,47 @@ export const se_UpdateFuotaTaskCommand = async (input, context) => {
1978
1248
  Name: [],
1979
1249
  RedundancyPercent: [],
1980
1250
  }));
1981
- return new __HttpRequest({
1982
- protocol,
1983
- hostname,
1984
- port,
1985
- method: "PATCH",
1986
- headers,
1987
- path: resolvedPath,
1988
- body,
1989
- });
1251
+ b.m("PATCH").h(headers).b(body);
1252
+ return b.build();
1990
1253
  };
1991
1254
  export const se_UpdateLogLevelsByResourceTypesCommand = async (input, context) => {
1992
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1255
+ const b = rb(input, context);
1993
1256
  const headers = {
1994
1257
  "content-type": "application/json",
1995
1258
  };
1996
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/log-levels";
1259
+ b.bp("/log-levels");
1997
1260
  let body;
1998
1261
  body = JSON.stringify(take(input, {
1999
1262
  DefaultLogLevel: [],
2000
1263
  WirelessDeviceLogOptions: (_) => _json(_),
2001
1264
  WirelessGatewayLogOptions: (_) => _json(_),
2002
1265
  }));
2003
- return new __HttpRequest({
2004
- protocol,
2005
- hostname,
2006
- port,
2007
- method: "POST",
2008
- headers,
2009
- path: resolvedPath,
2010
- body,
2011
- });
1266
+ b.m("POST").h(headers).b(body);
1267
+ return b.build();
2012
1268
  };
2013
1269
  export const se_UpdateMulticastGroupCommand = async (input, context) => {
2014
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1270
+ const b = rb(input, context);
2015
1271
  const headers = {
2016
1272
  "content-type": "application/json",
2017
1273
  };
2018
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/multicast-groups/{Id}";
2019
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
1274
+ b.bp("/multicast-groups/{Id}");
1275
+ b.p("Id", () => input.Id, "{Id}", false);
2020
1276
  let body;
2021
1277
  body = JSON.stringify(take(input, {
2022
1278
  Description: [],
2023
1279
  LoRaWAN: (_) => _json(_),
2024
1280
  Name: [],
2025
1281
  }));
2026
- return new __HttpRequest({
2027
- protocol,
2028
- hostname,
2029
- port,
2030
- method: "PATCH",
2031
- headers,
2032
- path: resolvedPath,
2033
- body,
2034
- });
1282
+ b.m("PATCH").h(headers).b(body);
1283
+ return b.build();
2035
1284
  };
2036
1285
  export const se_UpdateNetworkAnalyzerConfigurationCommand = async (input, context) => {
2037
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1286
+ const b = rb(input, context);
2038
1287
  const headers = {
2039
1288
  "content-type": "application/json",
2040
1289
  };
2041
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2042
- "/network-analyzer-configurations/{ConfigurationName}";
2043
- resolvedPath = __resolvedPath(resolvedPath, input, "ConfigurationName", () => input.ConfigurationName, "{ConfigurationName}", false);
1290
+ b.bp("/network-analyzer-configurations/{ConfigurationName}");
1291
+ b.p("ConfigurationName", () => input.ConfigurationName, "{ConfigurationName}", false);
2044
1292
  let body;
2045
1293
  body = JSON.stringify(take(input, {
2046
1294
  Description: [],
@@ -2052,76 +1300,53 @@ export const se_UpdateNetworkAnalyzerConfigurationCommand = async (input, contex
2052
1300
  WirelessGatewaysToAdd: (_) => _json(_),
2053
1301
  WirelessGatewaysToRemove: (_) => _json(_),
2054
1302
  }));
2055
- return new __HttpRequest({
2056
- protocol,
2057
- hostname,
2058
- port,
2059
- method: "PATCH",
2060
- headers,
2061
- path: resolvedPath,
2062
- body,
2063
- });
1303
+ b.m("PATCH").h(headers).b(body);
1304
+ return b.build();
2064
1305
  };
2065
1306
  export const se_UpdatePartnerAccountCommand = async (input, context) => {
2066
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1307
+ const b = rb(input, context);
2067
1308
  const headers = {
2068
1309
  "content-type": "application/json",
2069
1310
  };
2070
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/partner-accounts/{PartnerAccountId}";
2071
- resolvedPath = __resolvedPath(resolvedPath, input, "PartnerAccountId", () => input.PartnerAccountId, "{PartnerAccountId}", false);
1311
+ b.bp("/partner-accounts/{PartnerAccountId}");
1312
+ b.p("PartnerAccountId", () => input.PartnerAccountId, "{PartnerAccountId}", false);
2072
1313
  const query = map({
2073
- partnerType: [, __expectNonNull(input.PartnerType, `PartnerType`)],
1314
+ [_pT]: [, __expectNonNull(input[_PT], `PartnerType`)],
2074
1315
  });
2075
1316
  let body;
2076
1317
  body = JSON.stringify(take(input, {
2077
1318
  Sidewalk: (_) => _json(_),
2078
1319
  }));
2079
- return new __HttpRequest({
2080
- protocol,
2081
- hostname,
2082
- port,
2083
- method: "PATCH",
2084
- headers,
2085
- path: resolvedPath,
2086
- query,
2087
- body,
2088
- });
1320
+ b.m("PATCH").h(headers).q(query).b(body);
1321
+ return b.build();
2089
1322
  };
2090
1323
  export const se_UpdatePositionCommand = async (input, context) => {
2091
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1324
+ const b = rb(input, context);
2092
1325
  const headers = {
2093
1326
  "content-type": "application/json",
2094
1327
  };
2095
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/positions/{ResourceIdentifier}";
2096
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceIdentifier", () => input.ResourceIdentifier, "{ResourceIdentifier}", false);
1328
+ b.bp("/positions/{ResourceIdentifier}");
1329
+ b.p("ResourceIdentifier", () => input.ResourceIdentifier, "{ResourceIdentifier}", false);
2097
1330
  const query = map({
2098
- resourceType: [, __expectNonNull(input.ResourceType, `ResourceType`)],
1331
+ [_rT]: [, __expectNonNull(input[_RT], `ResourceType`)],
2099
1332
  });
2100
1333
  let body;
2101
1334
  body = JSON.stringify(take(input, {
2102
1335
  Position: (_) => se_PositionCoordinate(_, context),
2103
1336
  }));
2104
- return new __HttpRequest({
2105
- protocol,
2106
- hostname,
2107
- port,
2108
- method: "PATCH",
2109
- headers,
2110
- path: resolvedPath,
2111
- query,
2112
- body,
2113
- });
1337
+ b.m("PATCH").h(headers).q(query).b(body);
1338
+ return b.build();
2114
1339
  };
2115
1340
  export const se_UpdateResourceEventConfigurationCommand = async (input, context) => {
2116
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1341
+ const b = rb(input, context);
2117
1342
  const headers = {
2118
1343
  "content-type": "application/json",
2119
1344
  };
2120
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/event-configurations/{Identifier}";
2121
- resolvedPath = __resolvedPath(resolvedPath, input, "Identifier", () => input.Identifier, "{Identifier}", false);
1345
+ b.bp("/event-configurations/{Identifier}");
1346
+ b.p("Identifier", () => input.Identifier, "{Identifier}", false);
2122
1347
  const query = map({
2123
- identifierType: [, __expectNonNull(input.IdentifierType, `IdentifierType`)],
2124
- partnerType: [, input.PartnerType],
1348
+ [_iT]: [, __expectNonNull(input[_IT], `IdentifierType`)],
1349
+ [_pT]: [, input[_PT]],
2125
1350
  });
2126
1351
  let body;
2127
1352
  body = JSON.stringify(take(input, {
@@ -2131,49 +1356,33 @@ export const se_UpdateResourceEventConfigurationCommand = async (input, context)
2131
1356
  MessageDeliveryStatus: (_) => _json(_),
2132
1357
  Proximity: (_) => _json(_),
2133
1358
  }));
2134
- return new __HttpRequest({
2135
- protocol,
2136
- hostname,
2137
- port,
2138
- method: "PATCH",
2139
- headers,
2140
- path: resolvedPath,
2141
- query,
2142
- body,
2143
- });
1359
+ b.m("PATCH").h(headers).q(query).b(body);
1360
+ return b.build();
2144
1361
  };
2145
1362
  export const se_UpdateResourcePositionCommand = async (input, context) => {
2146
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1363
+ const b = rb(input, context);
2147
1364
  const headers = {
2148
1365
  "content-type": "application/octet-stream",
2149
1366
  };
2150
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/resource-positions/{ResourceIdentifier}";
2151
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceIdentifier", () => input.ResourceIdentifier, "{ResourceIdentifier}", false);
1367
+ b.bp("/resource-positions/{ResourceIdentifier}");
1368
+ b.p("ResourceIdentifier", () => input.ResourceIdentifier, "{ResourceIdentifier}", false);
2152
1369
  const query = map({
2153
- resourceType: [, __expectNonNull(input.ResourceType, `ResourceType`)],
1370
+ [_rT]: [, __expectNonNull(input[_RT], `ResourceType`)],
2154
1371
  });
2155
1372
  let body;
2156
1373
  if (input.GeoJsonPayload !== undefined) {
2157
1374
  body = input.GeoJsonPayload;
2158
1375
  }
2159
- return new __HttpRequest({
2160
- protocol,
2161
- hostname,
2162
- port,
2163
- method: "PATCH",
2164
- headers,
2165
- path: resolvedPath,
2166
- query,
2167
- body,
2168
- });
1376
+ b.m("PATCH").h(headers).q(query).b(body);
1377
+ return b.build();
2169
1378
  };
2170
1379
  export const se_UpdateWirelessDeviceCommand = async (input, context) => {
2171
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1380
+ const b = rb(input, context);
2172
1381
  const headers = {
2173
1382
  "content-type": "application/json",
2174
1383
  };
2175
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-devices/{Id}";
2176
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
1384
+ b.bp("/wireless-devices/{Id}");
1385
+ b.p("Id", () => input.Id, "{Id}", false);
2177
1386
  let body;
2178
1387
  body = JSON.stringify(take(input, {
2179
1388
  Description: [],
@@ -2182,44 +1391,30 @@ export const se_UpdateWirelessDeviceCommand = async (input, context) => {
2182
1391
  Name: [],
2183
1392
  Positioning: [],
2184
1393
  }));
2185
- return new __HttpRequest({
2186
- protocol,
2187
- hostname,
2188
- port,
2189
- method: "PATCH",
2190
- headers,
2191
- path: resolvedPath,
2192
- body,
2193
- });
1394
+ b.m("PATCH").h(headers).b(body);
1395
+ return b.build();
2194
1396
  };
2195
1397
  export const se_UpdateWirelessDeviceImportTaskCommand = async (input, context) => {
2196
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1398
+ const b = rb(input, context);
2197
1399
  const headers = {
2198
1400
  "content-type": "application/json",
2199
1401
  };
2200
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless_device_import_task/{Id}";
2201
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
1402
+ b.bp("/wireless_device_import_task/{Id}");
1403
+ b.p("Id", () => input.Id, "{Id}", false);
2202
1404
  let body;
2203
1405
  body = JSON.stringify(take(input, {
2204
1406
  Sidewalk: (_) => _json(_),
2205
1407
  }));
2206
- return new __HttpRequest({
2207
- protocol,
2208
- hostname,
2209
- port,
2210
- method: "PATCH",
2211
- headers,
2212
- path: resolvedPath,
2213
- body,
2214
- });
1408
+ b.m("PATCH").h(headers).b(body);
1409
+ return b.build();
2215
1410
  };
2216
1411
  export const se_UpdateWirelessGatewayCommand = async (input, context) => {
2217
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1412
+ const b = rb(input, context);
2218
1413
  const headers = {
2219
1414
  "content-type": "application/json",
2220
1415
  };
2221
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-gateways/{Id}";
2222
- resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
1416
+ b.bp("/wireless-gateways/{Id}");
1417
+ b.p("Id", () => input.Id, "{Id}", false);
2223
1418
  let body;
2224
1419
  body = JSON.stringify(take(input, {
2225
1420
  Description: [],
@@ -2228,15 +1423,8 @@ export const se_UpdateWirelessGatewayCommand = async (input, context) => {
2228
1423
  Name: [],
2229
1424
  NetIdFilters: (_) => _json(_),
2230
1425
  }));
2231
- return new __HttpRequest({
2232
- protocol,
2233
- hostname,
2234
- port,
2235
- method: "PATCH",
2236
- headers,
2237
- path: resolvedPath,
2238
- body,
2239
- });
1426
+ b.m("PATCH").h(headers).b(body);
1427
+ return b.build();
2240
1428
  };
2241
1429
  export const de_AssociateAwsAccountWithPartnerAccountCommand = async (output, context) => {
2242
1430
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -7463,6 +6651,44 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
7463
6651
  value !== "" &&
7464
6652
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
7465
6653
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
6654
+ const _DN = "DestinationName";
6655
+ const _DPI = "DeviceProfileId";
6656
+ const _DPT = "DeviceProfileType";
6657
+ const _FTI = "FuotaTaskId";
6658
+ const _I = "Id";
6659
+ const _IT = "IdentifierType";
6660
+ const _MGI = "MulticastGroupId";
6661
+ const _MI = "MessageId";
6662
+ const _MR = "MaxResults";
6663
+ const _NT = "NextToken";
6664
+ const _PT = "PartnerType";
6665
+ const _RA = "ResourceArn";
6666
+ const _RT = "ResourceType";
6667
+ const _S = "Status";
6668
+ const _SPI = "ServiceProfileId";
6669
+ const _ST = "ServiceType";
6670
+ const _TDT = "TaskDefinitionType";
6671
+ const _TK = "TagKeys";
6672
+ const _WDT = "WirelessDeviceType";
6673
+ const _dN = "destinationName";
6674
+ const _dPI = "deviceProfileId";
6675
+ const _dPT = "deviceProfileType";
6676
+ const _fTI = "fuotaTaskId";
6677
+ const _i = "id";
6678
+ const _iT = "identifierType";
6679
+ const _mGI = "multicastGroupId";
6680
+ const _mI = "messageId";
6681
+ const _mR = "maxResults";
6682
+ const _nT = "nextToken";
6683
+ const _pT = "partnerType";
6684
+ const _rA = "resourceArn";
6685
+ const _rT = "resourceType";
6686
+ const _s = "status";
6687
+ const _sPI = "serviceProfileId";
6688
+ const _sT = "serviceType";
6689
+ const _tDT = "taskDefinitionType";
6690
+ const _tK = "tagKeys";
6691
+ const _wDT = "wirelessDeviceType";
7466
6692
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
7467
6693
  if (encoded.length) {
7468
6694
  return JSON.parse(encoded);