@aws-sdk/client-iottwinmaker 3.476.0 → 3.477.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist-cjs/protocols/Aws_restJson1.js +256 -513
  2. package/dist-es/protocols/Aws_restJson1.js +258 -515
  3. package/package.json +5 -4
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,15 +1,15 @@
1
- import { HttpRequest as __HttpRequest, isValidHostname as __isValidHostname, } 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, map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
1
+ import { requestBuilder as rb } from "@smithy/core";
2
+ import { isValidHostname as __isValidHostname, } from "@smithy/protocol-http";
3
+ import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseEpochTimestamp as __parseEpochTimestamp, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
3
4
  import { IoTTwinMakerServiceException as __BaseException } from "../models/IoTTwinMakerServiceException";
4
5
  import { AccessDeniedException, ConflictException, ConnectorFailureException, ConnectorTimeoutException, InternalServerException, QueryTimeoutException, ResourceNotFoundException, ServiceQuotaExceededException, ThrottlingException, TooManyTagsException, ValidationException, } from "../models/models_0";
5
6
  export const se_BatchPutPropertyValuesCommand = async (input, context) => {
6
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
7
+ const b = rb(input, context);
7
8
  const headers = {
8
9
  "content-type": "application/json",
9
10
  };
10
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
11
- "/workspaces/{workspaceId}/entity-properties";
12
- resolvedPath = __resolvedPath(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
11
+ b.bp("/workspaces/{workspaceId}/entity-properties");
12
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
13
13
  let body;
14
14
  body = JSON.stringify(take(input, {
15
15
  entries: (_) => se_Entries(_, context),
@@ -21,22 +21,15 @@ export const se_BatchPutPropertyValuesCommand = async (input, context) => {
21
21
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
22
22
  }
23
23
  }
24
- return new __HttpRequest({
25
- protocol,
26
- hostname: resolvedHostname,
27
- port,
28
- method: "POST",
29
- headers,
30
- path: resolvedPath,
31
- body,
32
- });
24
+ b.hn(resolvedHostname);
25
+ b.m("POST").h(headers).b(body);
26
+ return b.build();
33
27
  };
34
28
  export const se_CancelMetadataTransferJobCommand = async (input, context) => {
35
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
29
+ const b = rb(input, context);
36
30
  const headers = {};
37
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
38
- "/metadata-transfer-jobs/{metadataTransferJobId}/cancel";
39
- resolvedPath = __resolvedPath(resolvedPath, input, "metadataTransferJobId", () => input.metadataTransferJobId, "{metadataTransferJobId}", false);
31
+ b.bp("/metadata-transfer-jobs/{metadataTransferJobId}/cancel");
32
+ b.p("metadataTransferJobId", () => input.metadataTransferJobId, "{metadataTransferJobId}", false);
40
33
  let body;
41
34
  let { hostname: resolvedHostname } = await context.endpoint();
42
35
  if (context.disableHostPrefix !== true) {
@@ -45,25 +38,18 @@ export const se_CancelMetadataTransferJobCommand = async (input, context) => {
45
38
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
46
39
  }
47
40
  }
48
- return new __HttpRequest({
49
- protocol,
50
- hostname: resolvedHostname,
51
- port,
52
- method: "PUT",
53
- headers,
54
- path: resolvedPath,
55
- body,
56
- });
41
+ b.hn(resolvedHostname);
42
+ b.m("PUT").h(headers).b(body);
43
+ return b.build();
57
44
  };
58
45
  export const se_CreateComponentTypeCommand = async (input, context) => {
59
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
46
+ const b = rb(input, context);
60
47
  const headers = {
61
48
  "content-type": "application/json",
62
49
  };
63
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
64
- "/workspaces/{workspaceId}/component-types/{componentTypeId}";
65
- resolvedPath = __resolvedPath(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
66
- resolvedPath = __resolvedPath(resolvedPath, input, "componentTypeId", () => input.componentTypeId, "{componentTypeId}", false);
50
+ b.bp("/workspaces/{workspaceId}/component-types/{componentTypeId}");
51
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
52
+ b.p("componentTypeId", () => input.componentTypeId, "{componentTypeId}", false);
67
53
  let body;
68
54
  body = JSON.stringify(take(input, {
69
55
  componentTypeName: [],
@@ -83,23 +69,17 @@ export const se_CreateComponentTypeCommand = async (input, context) => {
83
69
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
84
70
  }
85
71
  }
86
- return new __HttpRequest({
87
- protocol,
88
- hostname: resolvedHostname,
89
- port,
90
- method: "POST",
91
- headers,
92
- path: resolvedPath,
93
- body,
94
- });
72
+ b.hn(resolvedHostname);
73
+ b.m("POST").h(headers).b(body);
74
+ return b.build();
95
75
  };
96
76
  export const se_CreateEntityCommand = async (input, context) => {
97
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
77
+ const b = rb(input, context);
98
78
  const headers = {
99
79
  "content-type": "application/json",
100
80
  };
101
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces/{workspaceId}/entities";
102
- resolvedPath = __resolvedPath(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
81
+ b.bp("/workspaces/{workspaceId}/entities");
82
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
103
83
  let body;
104
84
  body = JSON.stringify(take(input, {
105
85
  components: (_) => se_ComponentsMapRequest(_, context),
@@ -117,22 +97,16 @@ export const se_CreateEntityCommand = async (input, context) => {
117
97
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
118
98
  }
119
99
  }
120
- return new __HttpRequest({
121
- protocol,
122
- hostname: resolvedHostname,
123
- port,
124
- method: "POST",
125
- headers,
126
- path: resolvedPath,
127
- body,
128
- });
100
+ b.hn(resolvedHostname);
101
+ b.m("POST").h(headers).b(body);
102
+ return b.build();
129
103
  };
130
104
  export const se_CreateMetadataTransferJobCommand = async (input, context) => {
131
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
105
+ const b = rb(input, context);
132
106
  const headers = {
133
107
  "content-type": "application/json",
134
108
  };
135
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/metadata-transfer-jobs";
109
+ b.bp("/metadata-transfer-jobs");
136
110
  let body;
137
111
  body = JSON.stringify(take(input, {
138
112
  description: [],
@@ -147,23 +121,17 @@ export const se_CreateMetadataTransferJobCommand = async (input, context) => {
147
121
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
148
122
  }
149
123
  }
150
- return new __HttpRequest({
151
- protocol,
152
- hostname: resolvedHostname,
153
- port,
154
- method: "POST",
155
- headers,
156
- path: resolvedPath,
157
- body,
158
- });
124
+ b.hn(resolvedHostname);
125
+ b.m("POST").h(headers).b(body);
126
+ return b.build();
159
127
  };
160
128
  export const se_CreateSceneCommand = async (input, context) => {
161
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
129
+ const b = rb(input, context);
162
130
  const headers = {
163
131
  "content-type": "application/json",
164
132
  };
165
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces/{workspaceId}/scenes";
166
- resolvedPath = __resolvedPath(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
133
+ b.bp("/workspaces/{workspaceId}/scenes");
134
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
167
135
  let body;
168
136
  body = JSON.stringify(take(input, {
169
137
  capabilities: (_) => _json(_),
@@ -180,25 +148,18 @@ export const se_CreateSceneCommand = async (input, context) => {
180
148
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
181
149
  }
182
150
  }
183
- return new __HttpRequest({
184
- protocol,
185
- hostname: resolvedHostname,
186
- port,
187
- method: "POST",
188
- headers,
189
- path: resolvedPath,
190
- body,
191
- });
151
+ b.hn(resolvedHostname);
152
+ b.m("POST").h(headers).b(body);
153
+ return b.build();
192
154
  };
193
155
  export const se_CreateSyncJobCommand = async (input, context) => {
194
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
156
+ const b = rb(input, context);
195
157
  const headers = {
196
158
  "content-type": "application/json",
197
159
  };
198
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
199
- "/workspaces/{workspaceId}/sync-jobs/{syncSource}";
200
- resolvedPath = __resolvedPath(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
201
- resolvedPath = __resolvedPath(resolvedPath, input, "syncSource", () => input.syncSource, "{syncSource}", false);
160
+ b.bp("/workspaces/{workspaceId}/sync-jobs/{syncSource}");
161
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
162
+ b.p("syncSource", () => input.syncSource, "{syncSource}", false);
202
163
  let body;
203
164
  body = JSON.stringify(take(input, {
204
165
  syncRole: [],
@@ -211,23 +172,17 @@ export const se_CreateSyncJobCommand = async (input, context) => {
211
172
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
212
173
  }
213
174
  }
214
- return new __HttpRequest({
215
- protocol,
216
- hostname: resolvedHostname,
217
- port,
218
- method: "POST",
219
- headers,
220
- path: resolvedPath,
221
- body,
222
- });
175
+ b.hn(resolvedHostname);
176
+ b.m("POST").h(headers).b(body);
177
+ return b.build();
223
178
  };
224
179
  export const se_CreateWorkspaceCommand = async (input, context) => {
225
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
180
+ const b = rb(input, context);
226
181
  const headers = {
227
182
  "content-type": "application/json",
228
183
  };
229
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces/{workspaceId}";
230
- resolvedPath = __resolvedPath(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
184
+ b.bp("/workspaces/{workspaceId}");
185
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
231
186
  let body;
232
187
  body = JSON.stringify(take(input, {
233
188
  description: [],
@@ -242,23 +197,16 @@ export const se_CreateWorkspaceCommand = async (input, context) => {
242
197
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
243
198
  }
244
199
  }
245
- return new __HttpRequest({
246
- protocol,
247
- hostname: resolvedHostname,
248
- port,
249
- method: "POST",
250
- headers,
251
- path: resolvedPath,
252
- body,
253
- });
200
+ b.hn(resolvedHostname);
201
+ b.m("POST").h(headers).b(body);
202
+ return b.build();
254
203
  };
255
204
  export const se_DeleteComponentTypeCommand = async (input, context) => {
256
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
205
+ const b = rb(input, context);
257
206
  const headers = {};
258
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
259
- "/workspaces/{workspaceId}/component-types/{componentTypeId}";
260
- resolvedPath = __resolvedPath(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
261
- resolvedPath = __resolvedPath(resolvedPath, input, "componentTypeId", () => input.componentTypeId, "{componentTypeId}", false);
207
+ b.bp("/workspaces/{workspaceId}/component-types/{componentTypeId}");
208
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
209
+ b.p("componentTypeId", () => input.componentTypeId, "{componentTypeId}", false);
262
210
  let body;
263
211
  let { hostname: resolvedHostname } = await context.endpoint();
264
212
  if (context.disableHostPrefix !== true) {
@@ -267,25 +215,18 @@ export const se_DeleteComponentTypeCommand = async (input, context) => {
267
215
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
268
216
  }
269
217
  }
270
- return new __HttpRequest({
271
- protocol,
272
- hostname: resolvedHostname,
273
- port,
274
- method: "DELETE",
275
- headers,
276
- path: resolvedPath,
277
- body,
278
- });
218
+ b.hn(resolvedHostname);
219
+ b.m("DELETE").h(headers).b(body);
220
+ return b.build();
279
221
  };
280
222
  export const se_DeleteEntityCommand = async (input, context) => {
281
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
223
+ const b = rb(input, context);
282
224
  const headers = {};
283
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
284
- "/workspaces/{workspaceId}/entities/{entityId}";
285
- resolvedPath = __resolvedPath(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
286
- resolvedPath = __resolvedPath(resolvedPath, input, "entityId", () => input.entityId, "{entityId}", false);
225
+ b.bp("/workspaces/{workspaceId}/entities/{entityId}");
226
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
227
+ b.p("entityId", () => input.entityId, "{entityId}", false);
287
228
  const query = map({
288
- isRecursive: [() => input.isRecursive !== void 0, () => input.isRecursive.toString()],
229
+ [_iR]: [() => input.isRecursive !== void 0, () => input[_iR].toString()],
289
230
  });
290
231
  let body;
291
232
  let { hostname: resolvedHostname } = await context.endpoint();
@@ -295,24 +236,16 @@ export const se_DeleteEntityCommand = async (input, context) => {
295
236
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
296
237
  }
297
238
  }
298
- return new __HttpRequest({
299
- protocol,
300
- hostname: resolvedHostname,
301
- port,
302
- method: "DELETE",
303
- headers,
304
- path: resolvedPath,
305
- query,
306
- body,
307
- });
239
+ b.hn(resolvedHostname);
240
+ b.m("DELETE").h(headers).q(query).b(body);
241
+ return b.build();
308
242
  };
309
243
  export const se_DeleteSceneCommand = async (input, context) => {
310
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
244
+ const b = rb(input, context);
311
245
  const headers = {};
312
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
313
- "/workspaces/{workspaceId}/scenes/{sceneId}";
314
- resolvedPath = __resolvedPath(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
315
- resolvedPath = __resolvedPath(resolvedPath, input, "sceneId", () => input.sceneId, "{sceneId}", false);
246
+ b.bp("/workspaces/{workspaceId}/scenes/{sceneId}");
247
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
248
+ b.p("sceneId", () => input.sceneId, "{sceneId}", false);
316
249
  let body;
317
250
  let { hostname: resolvedHostname } = await context.endpoint();
318
251
  if (context.disableHostPrefix !== true) {
@@ -321,23 +254,16 @@ export const se_DeleteSceneCommand = async (input, context) => {
321
254
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
322
255
  }
323
256
  }
324
- return new __HttpRequest({
325
- protocol,
326
- hostname: resolvedHostname,
327
- port,
328
- method: "DELETE",
329
- headers,
330
- path: resolvedPath,
331
- body,
332
- });
257
+ b.hn(resolvedHostname);
258
+ b.m("DELETE").h(headers).b(body);
259
+ return b.build();
333
260
  };
334
261
  export const se_DeleteSyncJobCommand = async (input, context) => {
335
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
262
+ const b = rb(input, context);
336
263
  const headers = {};
337
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
338
- "/workspaces/{workspaceId}/sync-jobs/{syncSource}";
339
- resolvedPath = __resolvedPath(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
340
- resolvedPath = __resolvedPath(resolvedPath, input, "syncSource", () => input.syncSource, "{syncSource}", false);
264
+ b.bp("/workspaces/{workspaceId}/sync-jobs/{syncSource}");
265
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
266
+ b.p("syncSource", () => input.syncSource, "{syncSource}", false);
341
267
  let body;
342
268
  let { hostname: resolvedHostname } = await context.endpoint();
343
269
  if (context.disableHostPrefix !== true) {
@@ -346,21 +272,15 @@ export const se_DeleteSyncJobCommand = async (input, context) => {
346
272
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
347
273
  }
348
274
  }
349
- return new __HttpRequest({
350
- protocol,
351
- hostname: resolvedHostname,
352
- port,
353
- method: "DELETE",
354
- headers,
355
- path: resolvedPath,
356
- body,
357
- });
275
+ b.hn(resolvedHostname);
276
+ b.m("DELETE").h(headers).b(body);
277
+ return b.build();
358
278
  };
359
279
  export const se_DeleteWorkspaceCommand = async (input, context) => {
360
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
280
+ const b = rb(input, context);
361
281
  const headers = {};
362
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces/{workspaceId}";
363
- resolvedPath = __resolvedPath(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
282
+ b.bp("/workspaces/{workspaceId}");
283
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
364
284
  let body;
365
285
  let { hostname: resolvedHostname } = await context.endpoint();
366
286
  if (context.disableHostPrefix !== true) {
@@ -369,22 +289,16 @@ export const se_DeleteWorkspaceCommand = async (input, context) => {
369
289
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
370
290
  }
371
291
  }
372
- return new __HttpRequest({
373
- protocol,
374
- hostname: resolvedHostname,
375
- port,
376
- method: "DELETE",
377
- headers,
378
- path: resolvedPath,
379
- body,
380
- });
292
+ b.hn(resolvedHostname);
293
+ b.m("DELETE").h(headers).b(body);
294
+ return b.build();
381
295
  };
382
296
  export const se_ExecuteQueryCommand = async (input, context) => {
383
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
297
+ const b = rb(input, context);
384
298
  const headers = {
385
299
  "content-type": "application/json",
386
300
  };
387
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/queries/execution";
301
+ b.bp("/queries/execution");
388
302
  let body;
389
303
  body = JSON.stringify(take(input, {
390
304
  maxResults: [],
@@ -399,23 +313,16 @@ export const se_ExecuteQueryCommand = async (input, context) => {
399
313
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
400
314
  }
401
315
  }
402
- return new __HttpRequest({
403
- protocol,
404
- hostname: resolvedHostname,
405
- port,
406
- method: "POST",
407
- headers,
408
- path: resolvedPath,
409
- body,
410
- });
316
+ b.hn(resolvedHostname);
317
+ b.m("POST").h(headers).b(body);
318
+ return b.build();
411
319
  };
412
320
  export const se_GetComponentTypeCommand = async (input, context) => {
413
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
321
+ const b = rb(input, context);
414
322
  const headers = {};
415
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
416
- "/workspaces/{workspaceId}/component-types/{componentTypeId}";
417
- resolvedPath = __resolvedPath(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
418
- resolvedPath = __resolvedPath(resolvedPath, input, "componentTypeId", () => input.componentTypeId, "{componentTypeId}", false);
323
+ b.bp("/workspaces/{workspaceId}/component-types/{componentTypeId}");
324
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
325
+ b.p("componentTypeId", () => input.componentTypeId, "{componentTypeId}", false);
419
326
  let body;
420
327
  let { hostname: resolvedHostname } = await context.endpoint();
421
328
  if (context.disableHostPrefix !== true) {
@@ -424,23 +331,16 @@ export const se_GetComponentTypeCommand = async (input, context) => {
424
331
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
425
332
  }
426
333
  }
427
- return new __HttpRequest({
428
- protocol,
429
- hostname: resolvedHostname,
430
- port,
431
- method: "GET",
432
- headers,
433
- path: resolvedPath,
434
- body,
435
- });
334
+ b.hn(resolvedHostname);
335
+ b.m("GET").h(headers).b(body);
336
+ return b.build();
436
337
  };
437
338
  export const se_GetEntityCommand = async (input, context) => {
438
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
339
+ const b = rb(input, context);
439
340
  const headers = {};
440
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
441
- "/workspaces/{workspaceId}/entities/{entityId}";
442
- resolvedPath = __resolvedPath(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
443
- resolvedPath = __resolvedPath(resolvedPath, input, "entityId", () => input.entityId, "{entityId}", false);
341
+ b.bp("/workspaces/{workspaceId}/entities/{entityId}");
342
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
343
+ b.p("entityId", () => input.entityId, "{entityId}", false);
444
344
  let body;
445
345
  let { hostname: resolvedHostname } = await context.endpoint();
446
346
  if (context.disableHostPrefix !== true) {
@@ -449,22 +349,15 @@ export const se_GetEntityCommand = async (input, context) => {
449
349
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
450
350
  }
451
351
  }
452
- return new __HttpRequest({
453
- protocol,
454
- hostname: resolvedHostname,
455
- port,
456
- method: "GET",
457
- headers,
458
- path: resolvedPath,
459
- body,
460
- });
352
+ b.hn(resolvedHostname);
353
+ b.m("GET").h(headers).b(body);
354
+ return b.build();
461
355
  };
462
356
  export const se_GetMetadataTransferJobCommand = async (input, context) => {
463
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
357
+ const b = rb(input, context);
464
358
  const headers = {};
465
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
466
- "/metadata-transfer-jobs/{metadataTransferJobId}";
467
- resolvedPath = __resolvedPath(resolvedPath, input, "metadataTransferJobId", () => input.metadataTransferJobId, "{metadataTransferJobId}", false);
359
+ b.bp("/metadata-transfer-jobs/{metadataTransferJobId}");
360
+ b.p("metadataTransferJobId", () => input.metadataTransferJobId, "{metadataTransferJobId}", false);
468
361
  let body;
469
362
  let { hostname: resolvedHostname } = await context.endpoint();
470
363
  if (context.disableHostPrefix !== true) {
@@ -473,22 +366,16 @@ export const se_GetMetadataTransferJobCommand = async (input, context) => {
473
366
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
474
367
  }
475
368
  }
476
- return new __HttpRequest({
477
- protocol,
478
- hostname: resolvedHostname,
479
- port,
480
- method: "GET",
481
- headers,
482
- path: resolvedPath,
483
- body,
484
- });
369
+ b.hn(resolvedHostname);
370
+ b.m("GET").h(headers).b(body);
371
+ return b.build();
485
372
  };
486
373
  export const se_GetPricingPlanCommand = async (input, context) => {
487
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
374
+ const b = rb(input, context);
488
375
  const headers = {
489
376
  "content-type": "application/json",
490
377
  };
491
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/pricingplan";
378
+ b.bp("/pricingplan");
492
379
  let body;
493
380
  body = "";
494
381
  let { hostname: resolvedHostname } = await context.endpoint();
@@ -498,24 +385,17 @@ export const se_GetPricingPlanCommand = async (input, context) => {
498
385
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
499
386
  }
500
387
  }
501
- return new __HttpRequest({
502
- protocol,
503
- hostname: resolvedHostname,
504
- port,
505
- method: "GET",
506
- headers,
507
- path: resolvedPath,
508
- body,
509
- });
388
+ b.hn(resolvedHostname);
389
+ b.m("GET").h(headers).b(body);
390
+ return b.build();
510
391
  };
511
392
  export const se_GetPropertyValueCommand = async (input, context) => {
512
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
393
+ const b = rb(input, context);
513
394
  const headers = {
514
395
  "content-type": "application/json",
515
396
  };
516
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
517
- "/workspaces/{workspaceId}/entity-properties/value";
518
- resolvedPath = __resolvedPath(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
397
+ b.bp("/workspaces/{workspaceId}/entity-properties/value");
398
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
519
399
  let body;
520
400
  body = JSON.stringify(take(input, {
521
401
  componentName: [],
@@ -535,24 +415,17 @@ export const se_GetPropertyValueCommand = async (input, context) => {
535
415
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
536
416
  }
537
417
  }
538
- return new __HttpRequest({
539
- protocol,
540
- hostname: resolvedHostname,
541
- port,
542
- method: "POST",
543
- headers,
544
- path: resolvedPath,
545
- body,
546
- });
418
+ b.hn(resolvedHostname);
419
+ b.m("POST").h(headers).b(body);
420
+ return b.build();
547
421
  };
548
422
  export const se_GetPropertyValueHistoryCommand = async (input, context) => {
549
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
423
+ const b = rb(input, context);
550
424
  const headers = {
551
425
  "content-type": "application/json",
552
426
  };
553
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
554
- "/workspaces/{workspaceId}/entity-properties/history";
555
- resolvedPath = __resolvedPath(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
427
+ b.bp("/workspaces/{workspaceId}/entity-properties/history");
428
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
556
429
  let body;
557
430
  body = JSON.stringify(take(input, {
558
431
  componentName: [],
@@ -577,23 +450,16 @@ export const se_GetPropertyValueHistoryCommand = async (input, context) => {
577
450
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
578
451
  }
579
452
  }
580
- return new __HttpRequest({
581
- protocol,
582
- hostname: resolvedHostname,
583
- port,
584
- method: "POST",
585
- headers,
586
- path: resolvedPath,
587
- body,
588
- });
453
+ b.hn(resolvedHostname);
454
+ b.m("POST").h(headers).b(body);
455
+ return b.build();
589
456
  };
590
457
  export const se_GetSceneCommand = async (input, context) => {
591
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
458
+ const b = rb(input, context);
592
459
  const headers = {};
593
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
594
- "/workspaces/{workspaceId}/scenes/{sceneId}";
595
- resolvedPath = __resolvedPath(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
596
- resolvedPath = __resolvedPath(resolvedPath, input, "sceneId", () => input.sceneId, "{sceneId}", false);
460
+ b.bp("/workspaces/{workspaceId}/scenes/{sceneId}");
461
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
462
+ b.p("sceneId", () => input.sceneId, "{sceneId}", false);
597
463
  let body;
598
464
  let { hostname: resolvedHostname } = await context.endpoint();
599
465
  if (context.disableHostPrefix !== true) {
@@ -602,23 +468,17 @@ export const se_GetSceneCommand = async (input, context) => {
602
468
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
603
469
  }
604
470
  }
605
- return new __HttpRequest({
606
- protocol,
607
- hostname: resolvedHostname,
608
- port,
609
- method: "GET",
610
- headers,
611
- path: resolvedPath,
612
- body,
613
- });
471
+ b.hn(resolvedHostname);
472
+ b.m("GET").h(headers).b(body);
473
+ return b.build();
614
474
  };
615
475
  export const se_GetSyncJobCommand = async (input, context) => {
616
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
476
+ const b = rb(input, context);
617
477
  const headers = {};
618
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sync-jobs/{syncSource}";
619
- resolvedPath = __resolvedPath(resolvedPath, input, "syncSource", () => input.syncSource, "{syncSource}", false);
478
+ b.bp("/sync-jobs/{syncSource}");
479
+ b.p("syncSource", () => input.syncSource, "{syncSource}", false);
620
480
  const query = map({
621
- workspace: [, input.workspaceId],
481
+ [_w]: [, input[_wI]],
622
482
  });
623
483
  let body;
624
484
  let { hostname: resolvedHostname } = await context.endpoint();
@@ -628,22 +488,15 @@ export const se_GetSyncJobCommand = async (input, context) => {
628
488
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
629
489
  }
630
490
  }
631
- return new __HttpRequest({
632
- protocol,
633
- hostname: resolvedHostname,
634
- port,
635
- method: "GET",
636
- headers,
637
- path: resolvedPath,
638
- query,
639
- body,
640
- });
491
+ b.hn(resolvedHostname);
492
+ b.m("GET").h(headers).q(query).b(body);
493
+ return b.build();
641
494
  };
642
495
  export const se_GetWorkspaceCommand = async (input, context) => {
643
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
496
+ const b = rb(input, context);
644
497
  const headers = {};
645
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces/{workspaceId}";
646
- resolvedPath = __resolvedPath(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
498
+ b.bp("/workspaces/{workspaceId}");
499
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
647
500
  let body;
648
501
  let { hostname: resolvedHostname } = await context.endpoint();
649
502
  if (context.disableHostPrefix !== true) {
@@ -652,25 +505,18 @@ export const se_GetWorkspaceCommand = async (input, context) => {
652
505
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
653
506
  }
654
507
  }
655
- return new __HttpRequest({
656
- protocol,
657
- hostname: resolvedHostname,
658
- port,
659
- method: "GET",
660
- headers,
661
- path: resolvedPath,
662
- body,
663
- });
508
+ b.hn(resolvedHostname);
509
+ b.m("GET").h(headers).b(body);
510
+ return b.build();
664
511
  };
665
512
  export const se_ListComponentsCommand = async (input, context) => {
666
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
513
+ const b = rb(input, context);
667
514
  const headers = {
668
515
  "content-type": "application/json",
669
516
  };
670
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
671
- "/workspaces/{workspaceId}/entities/{entityId}/components-list";
672
- resolvedPath = __resolvedPath(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
673
- resolvedPath = __resolvedPath(resolvedPath, input, "entityId", () => input.entityId, "{entityId}", false);
517
+ b.bp("/workspaces/{workspaceId}/entities/{entityId}/components-list");
518
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
519
+ b.p("entityId", () => input.entityId, "{entityId}", false);
674
520
  let body;
675
521
  body = JSON.stringify(take(input, {
676
522
  componentPath: [],
@@ -684,24 +530,17 @@ export const se_ListComponentsCommand = async (input, context) => {
684
530
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
685
531
  }
686
532
  }
687
- return new __HttpRequest({
688
- protocol,
689
- hostname: resolvedHostname,
690
- port,
691
- method: "POST",
692
- headers,
693
- path: resolvedPath,
694
- body,
695
- });
533
+ b.hn(resolvedHostname);
534
+ b.m("POST").h(headers).b(body);
535
+ return b.build();
696
536
  };
697
537
  export const se_ListComponentTypesCommand = async (input, context) => {
698
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
538
+ const b = rb(input, context);
699
539
  const headers = {
700
540
  "content-type": "application/json",
701
541
  };
702
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
703
- "/workspaces/{workspaceId}/component-types-list";
704
- resolvedPath = __resolvedPath(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
542
+ b.bp("/workspaces/{workspaceId}/component-types-list");
543
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
705
544
  let body;
706
545
  body = JSON.stringify(take(input, {
707
546
  filters: (_) => _json(_),
@@ -715,23 +554,17 @@ export const se_ListComponentTypesCommand = async (input, context) => {
715
554
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
716
555
  }
717
556
  }
718
- return new __HttpRequest({
719
- protocol,
720
- hostname: resolvedHostname,
721
- port,
722
- method: "POST",
723
- headers,
724
- path: resolvedPath,
725
- body,
726
- });
557
+ b.hn(resolvedHostname);
558
+ b.m("POST").h(headers).b(body);
559
+ return b.build();
727
560
  };
728
561
  export const se_ListEntitiesCommand = async (input, context) => {
729
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
562
+ const b = rb(input, context);
730
563
  const headers = {
731
564
  "content-type": "application/json",
732
565
  };
733
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces/{workspaceId}/entities-list";
734
- resolvedPath = __resolvedPath(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
566
+ b.bp("/workspaces/{workspaceId}/entities-list");
567
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
735
568
  let body;
736
569
  body = JSON.stringify(take(input, {
737
570
  filters: (_) => _json(_),
@@ -745,22 +578,16 @@ export const se_ListEntitiesCommand = async (input, context) => {
745
578
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
746
579
  }
747
580
  }
748
- return new __HttpRequest({
749
- protocol,
750
- hostname: resolvedHostname,
751
- port,
752
- method: "POST",
753
- headers,
754
- path: resolvedPath,
755
- body,
756
- });
581
+ b.hn(resolvedHostname);
582
+ b.m("POST").h(headers).b(body);
583
+ return b.build();
757
584
  };
758
585
  export const se_ListMetadataTransferJobsCommand = async (input, context) => {
759
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
586
+ const b = rb(input, context);
760
587
  const headers = {
761
588
  "content-type": "application/json",
762
589
  };
763
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/metadata-transfer-jobs-list";
590
+ b.bp("/metadata-transfer-jobs-list");
764
591
  let body;
765
592
  body = JSON.stringify(take(input, {
766
593
  destinationType: [],
@@ -776,23 +603,17 @@ export const se_ListMetadataTransferJobsCommand = async (input, context) => {
776
603
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
777
604
  }
778
605
  }
779
- return new __HttpRequest({
780
- protocol,
781
- hostname: resolvedHostname,
782
- port,
783
- method: "POST",
784
- headers,
785
- path: resolvedPath,
786
- body,
787
- });
606
+ b.hn(resolvedHostname);
607
+ b.m("POST").h(headers).b(body);
608
+ return b.build();
788
609
  };
789
610
  export const se_ListPropertiesCommand = async (input, context) => {
790
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
611
+ const b = rb(input, context);
791
612
  const headers = {
792
613
  "content-type": "application/json",
793
614
  };
794
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces/{workspaceId}/properties-list";
795
- resolvedPath = __resolvedPath(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
615
+ b.bp("/workspaces/{workspaceId}/properties-list");
616
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
796
617
  let body;
797
618
  body = JSON.stringify(take(input, {
798
619
  componentName: [],
@@ -808,23 +629,17 @@ export const se_ListPropertiesCommand = async (input, context) => {
808
629
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
809
630
  }
810
631
  }
811
- return new __HttpRequest({
812
- protocol,
813
- hostname: resolvedHostname,
814
- port,
815
- method: "POST",
816
- headers,
817
- path: resolvedPath,
818
- body,
819
- });
632
+ b.hn(resolvedHostname);
633
+ b.m("POST").h(headers).b(body);
634
+ return b.build();
820
635
  };
821
636
  export const se_ListScenesCommand = async (input, context) => {
822
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
637
+ const b = rb(input, context);
823
638
  const headers = {
824
639
  "content-type": "application/json",
825
640
  };
826
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces/{workspaceId}/scenes-list";
827
- resolvedPath = __resolvedPath(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
641
+ b.bp("/workspaces/{workspaceId}/scenes-list");
642
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
828
643
  let body;
829
644
  body = JSON.stringify(take(input, {
830
645
  maxResults: [],
@@ -837,23 +652,17 @@ export const se_ListScenesCommand = async (input, context) => {
837
652
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
838
653
  }
839
654
  }
840
- return new __HttpRequest({
841
- protocol,
842
- hostname: resolvedHostname,
843
- port,
844
- method: "POST",
845
- headers,
846
- path: resolvedPath,
847
- body,
848
- });
655
+ b.hn(resolvedHostname);
656
+ b.m("POST").h(headers).b(body);
657
+ return b.build();
849
658
  };
850
659
  export const se_ListSyncJobsCommand = async (input, context) => {
851
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
660
+ const b = rb(input, context);
852
661
  const headers = {
853
662
  "content-type": "application/json",
854
663
  };
855
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces/{workspaceId}/sync-jobs-list";
856
- resolvedPath = __resolvedPath(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
664
+ b.bp("/workspaces/{workspaceId}/sync-jobs-list");
665
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
857
666
  let body;
858
667
  body = JSON.stringify(take(input, {
859
668
  maxResults: [],
@@ -866,25 +675,18 @@ export const se_ListSyncJobsCommand = async (input, context) => {
866
675
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
867
676
  }
868
677
  }
869
- return new __HttpRequest({
870
- protocol,
871
- hostname: resolvedHostname,
872
- port,
873
- method: "POST",
874
- headers,
875
- path: resolvedPath,
876
- body,
877
- });
678
+ b.hn(resolvedHostname);
679
+ b.m("POST").h(headers).b(body);
680
+ return b.build();
878
681
  };
879
682
  export const se_ListSyncResourcesCommand = async (input, context) => {
880
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
683
+ const b = rb(input, context);
881
684
  const headers = {
882
685
  "content-type": "application/json",
883
686
  };
884
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
885
- "/workspaces/{workspaceId}/sync-jobs/{syncSource}/resources-list";
886
- resolvedPath = __resolvedPath(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
887
- resolvedPath = __resolvedPath(resolvedPath, input, "syncSource", () => input.syncSource, "{syncSource}", false);
687
+ b.bp("/workspaces/{workspaceId}/sync-jobs/{syncSource}/resources-list");
688
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
689
+ b.p("syncSource", () => input.syncSource, "{syncSource}", false);
888
690
  let body;
889
691
  body = JSON.stringify(take(input, {
890
692
  filters: (_) => _json(_),
@@ -898,22 +700,16 @@ export const se_ListSyncResourcesCommand = async (input, context) => {
898
700
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
899
701
  }
900
702
  }
901
- return new __HttpRequest({
902
- protocol,
903
- hostname: resolvedHostname,
904
- port,
905
- method: "POST",
906
- headers,
907
- path: resolvedPath,
908
- body,
909
- });
703
+ b.hn(resolvedHostname);
704
+ b.m("POST").h(headers).b(body);
705
+ return b.build();
910
706
  };
911
707
  export const se_ListTagsForResourceCommand = async (input, context) => {
912
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
708
+ const b = rb(input, context);
913
709
  const headers = {
914
710
  "content-type": "application/json",
915
711
  };
916
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags-list";
712
+ b.bp("/tags-list");
917
713
  let body;
918
714
  body = JSON.stringify(take(input, {
919
715
  maxResults: [],
@@ -927,22 +723,16 @@ export const se_ListTagsForResourceCommand = async (input, context) => {
927
723
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
928
724
  }
929
725
  }
930
- return new __HttpRequest({
931
- protocol,
932
- hostname: resolvedHostname,
933
- port,
934
- method: "POST",
935
- headers,
936
- path: resolvedPath,
937
- body,
938
- });
726
+ b.hn(resolvedHostname);
727
+ b.m("POST").h(headers).b(body);
728
+ return b.build();
939
729
  };
940
730
  export const se_ListWorkspacesCommand = async (input, context) => {
941
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
731
+ const b = rb(input, context);
942
732
  const headers = {
943
733
  "content-type": "application/json",
944
734
  };
945
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces-list";
735
+ b.bp("/workspaces-list");
946
736
  let body;
947
737
  body = JSON.stringify(take(input, {
948
738
  maxResults: [],
@@ -955,22 +745,16 @@ export const se_ListWorkspacesCommand = async (input, context) => {
955
745
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
956
746
  }
957
747
  }
958
- return new __HttpRequest({
959
- protocol,
960
- hostname: resolvedHostname,
961
- port,
962
- method: "POST",
963
- headers,
964
- path: resolvedPath,
965
- body,
966
- });
748
+ b.hn(resolvedHostname);
749
+ b.m("POST").h(headers).b(body);
750
+ return b.build();
967
751
  };
968
752
  export const se_TagResourceCommand = async (input, context) => {
969
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
753
+ const b = rb(input, context);
970
754
  const headers = {
971
755
  "content-type": "application/json",
972
756
  };
973
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags";
757
+ b.bp("/tags");
974
758
  let body;
975
759
  body = JSON.stringify(take(input, {
976
760
  resourceARN: [],
@@ -983,25 +767,19 @@ export const se_TagResourceCommand = async (input, context) => {
983
767
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
984
768
  }
985
769
  }
986
- return new __HttpRequest({
987
- protocol,
988
- hostname: resolvedHostname,
989
- port,
990
- method: "POST",
991
- headers,
992
- path: resolvedPath,
993
- body,
994
- });
770
+ b.hn(resolvedHostname);
771
+ b.m("POST").h(headers).b(body);
772
+ return b.build();
995
773
  };
996
774
  export const se_UntagResourceCommand = async (input, context) => {
997
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
775
+ const b = rb(input, context);
998
776
  const headers = {};
999
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags";
777
+ b.bp("/tags");
1000
778
  const query = map({
1001
- resourceARN: [, __expectNonNull(input.resourceARN, `resourceARN`)],
1002
- tagKeys: [
779
+ [_rARN]: [, __expectNonNull(input[_rARN], `resourceARN`)],
780
+ [_tK]: [
1003
781
  __expectNonNull(input.tagKeys, `tagKeys`) != null,
1004
- () => (input.tagKeys || []).map((_entry) => _entry),
782
+ () => (input[_tK] || []).map((_entry) => _entry),
1005
783
  ],
1006
784
  });
1007
785
  let body;
@@ -1012,26 +790,18 @@ export const se_UntagResourceCommand = async (input, context) => {
1012
790
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1013
791
  }
1014
792
  }
1015
- return new __HttpRequest({
1016
- protocol,
1017
- hostname: resolvedHostname,
1018
- port,
1019
- method: "DELETE",
1020
- headers,
1021
- path: resolvedPath,
1022
- query,
1023
- body,
1024
- });
793
+ b.hn(resolvedHostname);
794
+ b.m("DELETE").h(headers).q(query).b(body);
795
+ return b.build();
1025
796
  };
1026
797
  export const se_UpdateComponentTypeCommand = async (input, context) => {
1027
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
798
+ const b = rb(input, context);
1028
799
  const headers = {
1029
800
  "content-type": "application/json",
1030
801
  };
1031
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1032
- "/workspaces/{workspaceId}/component-types/{componentTypeId}";
1033
- resolvedPath = __resolvedPath(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
1034
- resolvedPath = __resolvedPath(resolvedPath, input, "componentTypeId", () => input.componentTypeId, "{componentTypeId}", false);
802
+ b.bp("/workspaces/{workspaceId}/component-types/{componentTypeId}");
803
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
804
+ b.p("componentTypeId", () => input.componentTypeId, "{componentTypeId}", false);
1035
805
  let body;
1036
806
  body = JSON.stringify(take(input, {
1037
807
  componentTypeName: [],
@@ -1050,25 +820,18 @@ export const se_UpdateComponentTypeCommand = async (input, context) => {
1050
820
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1051
821
  }
1052
822
  }
1053
- return new __HttpRequest({
1054
- protocol,
1055
- hostname: resolvedHostname,
1056
- port,
1057
- method: "PUT",
1058
- headers,
1059
- path: resolvedPath,
1060
- body,
1061
- });
823
+ b.hn(resolvedHostname);
824
+ b.m("PUT").h(headers).b(body);
825
+ return b.build();
1062
826
  };
1063
827
  export const se_UpdateEntityCommand = async (input, context) => {
1064
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
828
+ const b = rb(input, context);
1065
829
  const headers = {
1066
830
  "content-type": "application/json",
1067
831
  };
1068
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1069
- "/workspaces/{workspaceId}/entities/{entityId}";
1070
- resolvedPath = __resolvedPath(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
1071
- resolvedPath = __resolvedPath(resolvedPath, input, "entityId", () => input.entityId, "{entityId}", false);
832
+ b.bp("/workspaces/{workspaceId}/entities/{entityId}");
833
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
834
+ b.p("entityId", () => input.entityId, "{entityId}", false);
1072
835
  let body;
1073
836
  body = JSON.stringify(take(input, {
1074
837
  componentUpdates: (_) => se_ComponentUpdatesMapRequest(_, context),
@@ -1084,22 +847,16 @@ export const se_UpdateEntityCommand = async (input, context) => {
1084
847
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1085
848
  }
1086
849
  }
1087
- return new __HttpRequest({
1088
- protocol,
1089
- hostname: resolvedHostname,
1090
- port,
1091
- method: "PUT",
1092
- headers,
1093
- path: resolvedPath,
1094
- body,
1095
- });
850
+ b.hn(resolvedHostname);
851
+ b.m("PUT").h(headers).b(body);
852
+ return b.build();
1096
853
  };
1097
854
  export const se_UpdatePricingPlanCommand = async (input, context) => {
1098
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
855
+ const b = rb(input, context);
1099
856
  const headers = {
1100
857
  "content-type": "application/json",
1101
858
  };
1102
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/pricingplan";
859
+ b.bp("/pricingplan");
1103
860
  let body;
1104
861
  body = JSON.stringify(take(input, {
1105
862
  bundleNames: (_) => _json(_),
@@ -1112,25 +869,18 @@ export const se_UpdatePricingPlanCommand = async (input, context) => {
1112
869
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1113
870
  }
1114
871
  }
1115
- return new __HttpRequest({
1116
- protocol,
1117
- hostname: resolvedHostname,
1118
- port,
1119
- method: "POST",
1120
- headers,
1121
- path: resolvedPath,
1122
- body,
1123
- });
872
+ b.hn(resolvedHostname);
873
+ b.m("POST").h(headers).b(body);
874
+ return b.build();
1124
875
  };
1125
876
  export const se_UpdateSceneCommand = async (input, context) => {
1126
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
877
+ const b = rb(input, context);
1127
878
  const headers = {
1128
879
  "content-type": "application/json",
1129
880
  };
1130
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1131
- "/workspaces/{workspaceId}/scenes/{sceneId}";
1132
- resolvedPath = __resolvedPath(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
1133
- resolvedPath = __resolvedPath(resolvedPath, input, "sceneId", () => input.sceneId, "{sceneId}", false);
881
+ b.bp("/workspaces/{workspaceId}/scenes/{sceneId}");
882
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
883
+ b.p("sceneId", () => input.sceneId, "{sceneId}", false);
1134
884
  let body;
1135
885
  body = JSON.stringify(take(input, {
1136
886
  capabilities: (_) => _json(_),
@@ -1145,23 +895,17 @@ export const se_UpdateSceneCommand = async (input, context) => {
1145
895
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1146
896
  }
1147
897
  }
1148
- return new __HttpRequest({
1149
- protocol,
1150
- hostname: resolvedHostname,
1151
- port,
1152
- method: "PUT",
1153
- headers,
1154
- path: resolvedPath,
1155
- body,
1156
- });
898
+ b.hn(resolvedHostname);
899
+ b.m("PUT").h(headers).b(body);
900
+ return b.build();
1157
901
  };
1158
902
  export const se_UpdateWorkspaceCommand = async (input, context) => {
1159
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
903
+ const b = rb(input, context);
1160
904
  const headers = {
1161
905
  "content-type": "application/json",
1162
906
  };
1163
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces/{workspaceId}";
1164
- resolvedPath = __resolvedPath(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
907
+ b.bp("/workspaces/{workspaceId}");
908
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
1165
909
  let body;
1166
910
  body = JSON.stringify(take(input, {
1167
911
  description: [],
@@ -1175,15 +919,9 @@ export const se_UpdateWorkspaceCommand = async (input, context) => {
1175
919
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1176
920
  }
1177
921
  }
1178
- return new __HttpRequest({
1179
- protocol,
1180
- hostname: resolvedHostname,
1181
- port,
1182
- method: "PUT",
1183
- headers,
1184
- path: resolvedPath,
1185
- body,
1186
- });
922
+ b.hn(resolvedHostname);
923
+ b.m("PUT").h(headers).b(body);
924
+ return b.build();
1187
925
  };
1188
926
  export const de_BatchPutPropertyValuesCommand = async (output, context) => {
1189
927
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -3821,6 +3559,11 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
3821
3559
  value !== "" &&
3822
3560
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
3823
3561
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
3562
+ const _iR = "isRecursive";
3563
+ const _rARN = "resourceARN";
3564
+ const _tK = "tagKeys";
3565
+ const _w = "workspace";
3566
+ const _wI = "workspaceId";
3824
3567
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
3825
3568
  if (encoded.length) {
3826
3569
  return JSON.parse(encoded);