@aws-sdk/client-iottwinmaker 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 +256 -513
  2. package/dist-es/protocols/Aws_restJson1.js +258 -515
  3. package/package.json +5 -4
package/dist-cjs/protocols/Aws_restJson1.js CHANGED
@@ -2,18 +2,18 @@
2
2
  Object.defineProperty(exports, "__esModule", { value: true });
3
3
  exports.de_DeleteEntityCommand = exports.de_DeleteComponentTypeCommand = exports.de_CreateWorkspaceCommand = exports.de_CreateSyncJobCommand = exports.de_CreateSceneCommand = exports.de_CreateMetadataTransferJobCommand = exports.de_CreateEntityCommand = exports.de_CreateComponentTypeCommand = exports.de_CancelMetadataTransferJobCommand = exports.de_BatchPutPropertyValuesCommand = exports.se_UpdateWorkspaceCommand = exports.se_UpdateSceneCommand = exports.se_UpdatePricingPlanCommand = exports.se_UpdateEntityCommand = exports.se_UpdateComponentTypeCommand = exports.se_UntagResourceCommand = exports.se_TagResourceCommand = exports.se_ListWorkspacesCommand = exports.se_ListTagsForResourceCommand = exports.se_ListSyncResourcesCommand = exports.se_ListSyncJobsCommand = exports.se_ListScenesCommand = exports.se_ListPropertiesCommand = exports.se_ListMetadataTransferJobsCommand = exports.se_ListEntitiesCommand = exports.se_ListComponentTypesCommand = exports.se_ListComponentsCommand = exports.se_GetWorkspaceCommand = exports.se_GetSyncJobCommand = exports.se_GetSceneCommand = exports.se_GetPropertyValueHistoryCommand = exports.se_GetPropertyValueCommand = exports.se_GetPricingPlanCommand = exports.se_GetMetadataTransferJobCommand = exports.se_GetEntityCommand = exports.se_GetComponentTypeCommand = exports.se_ExecuteQueryCommand = exports.se_DeleteWorkspaceCommand = exports.se_DeleteSyncJobCommand = exports.se_DeleteSceneCommand = exports.se_DeleteEntityCommand = exports.se_DeleteComponentTypeCommand = exports.se_CreateWorkspaceCommand = exports.se_CreateSyncJobCommand = exports.se_CreateSceneCommand = exports.se_CreateMetadataTransferJobCommand = exports.se_CreateEntityCommand = exports.se_CreateComponentTypeCommand = exports.se_CancelMetadataTransferJobCommand = exports.se_BatchPutPropertyValuesCommand = void 0;
4
4
  exports.de_UpdateWorkspaceCommand = exports.de_UpdateSceneCommand = exports.de_UpdatePricingPlanCommand = exports.de_UpdateEntityCommand = exports.de_UpdateComponentTypeCommand = exports.de_UntagResourceCommand = exports.de_TagResourceCommand = exports.de_ListWorkspacesCommand = exports.de_ListTagsForResourceCommand = exports.de_ListSyncResourcesCommand = exports.de_ListSyncJobsCommand = exports.de_ListScenesCommand = exports.de_ListPropertiesCommand = exports.de_ListMetadataTransferJobsCommand = exports.de_ListEntitiesCommand = exports.de_ListComponentTypesCommand = exports.de_ListComponentsCommand = exports.de_GetWorkspaceCommand = exports.de_GetSyncJobCommand = exports.de_GetSceneCommand = exports.de_GetPropertyValueHistoryCommand = exports.de_GetPropertyValueCommand = exports.de_GetPricingPlanCommand = exports.de_GetMetadataTransferJobCommand = exports.de_GetEntityCommand = exports.de_GetComponentTypeCommand = exports.de_ExecuteQueryCommand = exports.de_DeleteWorkspaceCommand = exports.de_DeleteSyncJobCommand = exports.de_DeleteSceneCommand = void 0;
5
+ const core_1 = require("@smithy/core");
5
6
  const protocol_http_1 = require("@smithy/protocol-http");
6
7
  const smithy_client_1 = require("@smithy/smithy-client");
7
8
  const IoTTwinMakerServiceException_1 = require("../models/IoTTwinMakerServiceException");
8
9
  const models_0_1 = require("../models/models_0");
9
10
  const se_BatchPutPropertyValuesCommand = async (input, context) => {
10
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
11
+ const b = (0, core_1.requestBuilder)(input, context);
11
12
  const headers = {
12
13
  "content-type": "application/json",
13
14
  };
14
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
15
- "/workspaces/{workspaceId}/entity-properties";
16
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
15
+ b.bp("/workspaces/{workspaceId}/entity-properties");
16
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
17
17
  let body;
18
18
  body = JSON.stringify((0, smithy_client_1.take)(input, {
19
19
  entries: (_) => se_Entries(_, context),
@@ -25,23 +25,16 @@ const se_BatchPutPropertyValuesCommand = async (input, context) => {
25
25
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
26
26
  }
27
27
  }
28
- return new protocol_http_1.HttpRequest({
29
- protocol,
30
- hostname: resolvedHostname,
31
- port,
32
- method: "POST",
33
- headers,
34
- path: resolvedPath,
35
- body,
36
- });
28
+ b.hn(resolvedHostname);
29
+ b.m("POST").h(headers).b(body);
30
+ return b.build();
37
31
  };
38
32
  exports.se_BatchPutPropertyValuesCommand = se_BatchPutPropertyValuesCommand;
39
33
  const se_CancelMetadataTransferJobCommand = async (input, context) => {
40
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
34
+ const b = (0, core_1.requestBuilder)(input, context);
41
35
  const headers = {};
42
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
43
- "/metadata-transfer-jobs/{metadataTransferJobId}/cancel";
44
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "metadataTransferJobId", () => input.metadataTransferJobId, "{metadataTransferJobId}", false);
36
+ b.bp("/metadata-transfer-jobs/{metadataTransferJobId}/cancel");
37
+ b.p("metadataTransferJobId", () => input.metadataTransferJobId, "{metadataTransferJobId}", false);
45
38
  let body;
46
39
  let { hostname: resolvedHostname } = await context.endpoint();
47
40
  if (context.disableHostPrefix !== true) {
@@ -50,26 +43,19 @@ const se_CancelMetadataTransferJobCommand = async (input, context) => {
50
43
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
51
44
  }
52
45
  }
53
- return new protocol_http_1.HttpRequest({
54
- protocol,
55
- hostname: resolvedHostname,
56
- port,
57
- method: "PUT",
58
- headers,
59
- path: resolvedPath,
60
- body,
61
- });
46
+ b.hn(resolvedHostname);
47
+ b.m("PUT").h(headers).b(body);
48
+ return b.build();
62
49
  };
63
50
  exports.se_CancelMetadataTransferJobCommand = se_CancelMetadataTransferJobCommand;
64
51
  const se_CreateComponentTypeCommand = async (input, context) => {
65
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
52
+ const b = (0, core_1.requestBuilder)(input, context);
66
53
  const headers = {
67
54
  "content-type": "application/json",
68
55
  };
69
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
70
- "/workspaces/{workspaceId}/component-types/{componentTypeId}";
71
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
72
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "componentTypeId", () => input.componentTypeId, "{componentTypeId}", false);
56
+ b.bp("/workspaces/{workspaceId}/component-types/{componentTypeId}");
57
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
58
+ b.p("componentTypeId", () => input.componentTypeId, "{componentTypeId}", false);
73
59
  let body;
74
60
  body = JSON.stringify((0, smithy_client_1.take)(input, {
75
61
  componentTypeName: [],
@@ -89,24 +75,18 @@ const se_CreateComponentTypeCommand = async (input, context) => {
89
75
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
90
76
  }
91
77
  }
92
- return new protocol_http_1.HttpRequest({
93
- protocol,
94
- hostname: resolvedHostname,
95
- port,
96
- method: "POST",
97
- headers,
98
- path: resolvedPath,
99
- body,
100
- });
78
+ b.hn(resolvedHostname);
79
+ b.m("POST").h(headers).b(body);
80
+ return b.build();
101
81
  };
102
82
  exports.se_CreateComponentTypeCommand = se_CreateComponentTypeCommand;
103
83
  const se_CreateEntityCommand = async (input, context) => {
104
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
84
+ const b = (0, core_1.requestBuilder)(input, context);
105
85
  const headers = {
106
86
  "content-type": "application/json",
107
87
  };
108
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces/{workspaceId}/entities";
109
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
88
+ b.bp("/workspaces/{workspaceId}/entities");
89
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
110
90
  let body;
111
91
  body = JSON.stringify((0, smithy_client_1.take)(input, {
112
92
  components: (_) => se_ComponentsMapRequest(_, context),
@@ -124,23 +104,17 @@ const se_CreateEntityCommand = async (input, context) => {
124
104
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
125
105
  }
126
106
  }
127
- return new protocol_http_1.HttpRequest({
128
- protocol,
129
- hostname: resolvedHostname,
130
- port,
131
- method: "POST",
132
- headers,
133
- path: resolvedPath,
134
- body,
135
- });
107
+ b.hn(resolvedHostname);
108
+ b.m("POST").h(headers).b(body);
109
+ return b.build();
136
110
  };
137
111
  exports.se_CreateEntityCommand = se_CreateEntityCommand;
138
112
  const se_CreateMetadataTransferJobCommand = async (input, context) => {
139
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
113
+ const b = (0, core_1.requestBuilder)(input, context);
140
114
  const headers = {
141
115
  "content-type": "application/json",
142
116
  };
143
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/metadata-transfer-jobs";
117
+ b.bp("/metadata-transfer-jobs");
144
118
  let body;
145
119
  body = JSON.stringify((0, smithy_client_1.take)(input, {
146
120
  description: [],
@@ -155,24 +129,18 @@ const se_CreateMetadataTransferJobCommand = async (input, context) => {
155
129
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
156
130
  }
157
131
  }
158
- return new protocol_http_1.HttpRequest({
159
- protocol,
160
- hostname: resolvedHostname,
161
- port,
162
- method: "POST",
163
- headers,
164
- path: resolvedPath,
165
- body,
166
- });
132
+ b.hn(resolvedHostname);
133
+ b.m("POST").h(headers).b(body);
134
+ return b.build();
167
135
  };
168
136
  exports.se_CreateMetadataTransferJobCommand = se_CreateMetadataTransferJobCommand;
169
137
  const se_CreateSceneCommand = async (input, context) => {
170
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
138
+ const b = (0, core_1.requestBuilder)(input, context);
171
139
  const headers = {
172
140
  "content-type": "application/json",
173
141
  };
174
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces/{workspaceId}/scenes";
175
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
142
+ b.bp("/workspaces/{workspaceId}/scenes");
143
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
176
144
  let body;
177
145
  body = JSON.stringify((0, smithy_client_1.take)(input, {
178
146
  capabilities: (_) => (0, smithy_client_1._json)(_),
@@ -189,26 +157,19 @@ const se_CreateSceneCommand = async (input, context) => {
189
157
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
190
158
  }
191
159
  }
192
- return new protocol_http_1.HttpRequest({
193
- protocol,
194
- hostname: resolvedHostname,
195
- port,
196
- method: "POST",
197
- headers,
198
- path: resolvedPath,
199
- body,
200
- });
160
+ b.hn(resolvedHostname);
161
+ b.m("POST").h(headers).b(body);
162
+ return b.build();
201
163
  };
202
164
  exports.se_CreateSceneCommand = se_CreateSceneCommand;
203
165
  const se_CreateSyncJobCommand = async (input, context) => {
204
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
166
+ const b = (0, core_1.requestBuilder)(input, context);
205
167
  const headers = {
206
168
  "content-type": "application/json",
207
169
  };
208
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
209
- "/workspaces/{workspaceId}/sync-jobs/{syncSource}";
210
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
211
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "syncSource", () => input.syncSource, "{syncSource}", false);
170
+ b.bp("/workspaces/{workspaceId}/sync-jobs/{syncSource}");
171
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
172
+ b.p("syncSource", () => input.syncSource, "{syncSource}", false);
212
173
  let body;
213
174
  body = JSON.stringify((0, smithy_client_1.take)(input, {
214
175
  syncRole: [],
@@ -221,24 +182,18 @@ const se_CreateSyncJobCommand = async (input, context) => {
221
182
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
222
183
  }
223
184
  }
224
- return new protocol_http_1.HttpRequest({
225
- protocol,
226
- hostname: resolvedHostname,
227
- port,
228
- method: "POST",
229
- headers,
230
- path: resolvedPath,
231
- body,
232
- });
185
+ b.hn(resolvedHostname);
186
+ b.m("POST").h(headers).b(body);
187
+ return b.build();
233
188
  };
234
189
  exports.se_CreateSyncJobCommand = se_CreateSyncJobCommand;
235
190
  const se_CreateWorkspaceCommand = async (input, context) => {
236
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
191
+ const b = (0, core_1.requestBuilder)(input, context);
237
192
  const headers = {
238
193
  "content-type": "application/json",
239
194
  };
240
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces/{workspaceId}";
241
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
195
+ b.bp("/workspaces/{workspaceId}");
196
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
242
197
  let body;
243
198
  body = JSON.stringify((0, smithy_client_1.take)(input, {
244
199
  description: [],
@@ -253,24 +208,17 @@ const se_CreateWorkspaceCommand = async (input, context) => {
253
208
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
254
209
  }
255
210
  }
256
- return new protocol_http_1.HttpRequest({
257
- protocol,
258
- hostname: resolvedHostname,
259
- port,
260
- method: "POST",
261
- headers,
262
- path: resolvedPath,
263
- body,
264
- });
211
+ b.hn(resolvedHostname);
212
+ b.m("POST").h(headers).b(body);
213
+ return b.build();
265
214
  };
266
215
  exports.se_CreateWorkspaceCommand = se_CreateWorkspaceCommand;
267
216
  const se_DeleteComponentTypeCommand = async (input, context) => {
268
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
217
+ const b = (0, core_1.requestBuilder)(input, context);
269
218
  const headers = {};
270
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
271
- "/workspaces/{workspaceId}/component-types/{componentTypeId}";
272
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
273
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "componentTypeId", () => input.componentTypeId, "{componentTypeId}", false);
219
+ b.bp("/workspaces/{workspaceId}/component-types/{componentTypeId}");
220
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
221
+ b.p("componentTypeId", () => input.componentTypeId, "{componentTypeId}", false);
274
222
  let body;
275
223
  let { hostname: resolvedHostname } = await context.endpoint();
276
224
  if (context.disableHostPrefix !== true) {
@@ -279,26 +227,19 @@ const se_DeleteComponentTypeCommand = async (input, context) => {
279
227
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
280
228
  }
281
229
  }
282
- return new protocol_http_1.HttpRequest({
283
- protocol,
284
- hostname: resolvedHostname,
285
- port,
286
- method: "DELETE",
287
- headers,
288
- path: resolvedPath,
289
- body,
290
- });
230
+ b.hn(resolvedHostname);
231
+ b.m("DELETE").h(headers).b(body);
232
+ return b.build();
291
233
  };
292
234
  exports.se_DeleteComponentTypeCommand = se_DeleteComponentTypeCommand;
293
235
  const se_DeleteEntityCommand = async (input, context) => {
294
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
236
+ const b = (0, core_1.requestBuilder)(input, context);
295
237
  const headers = {};
296
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
297
- "/workspaces/{workspaceId}/entities/{entityId}";
298
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
299
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "entityId", () => input.entityId, "{entityId}", false);
238
+ b.bp("/workspaces/{workspaceId}/entities/{entityId}");
239
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
240
+ b.p("entityId", () => input.entityId, "{entityId}", false);
300
241
  const query = (0, smithy_client_1.map)({
301
- isRecursive: [() => input.isRecursive !== void 0, () => input.isRecursive.toString()],
242
+ [_iR]: [() => input.isRecursive !== void 0, () => input[_iR].toString()],
302
243
  });
303
244
  let body;
304
245
  let { hostname: resolvedHostname } = await context.endpoint();
@@ -308,25 +249,17 @@ const se_DeleteEntityCommand = async (input, context) => {
308
249
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
309
250
  }
310
251
  }
311
- return new protocol_http_1.HttpRequest({
312
- protocol,
313
- hostname: resolvedHostname,
314
- port,
315
- method: "DELETE",
316
- headers,
317
- path: resolvedPath,
318
- query,
319
- body,
320
- });
252
+ b.hn(resolvedHostname);
253
+ b.m("DELETE").h(headers).q(query).b(body);
254
+ return b.build();
321
255
  };
322
256
  exports.se_DeleteEntityCommand = se_DeleteEntityCommand;
323
257
  const se_DeleteSceneCommand = async (input, context) => {
324
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
258
+ const b = (0, core_1.requestBuilder)(input, context);
325
259
  const headers = {};
326
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
327
- "/workspaces/{workspaceId}/scenes/{sceneId}";
328
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
329
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "sceneId", () => input.sceneId, "{sceneId}", false);
260
+ b.bp("/workspaces/{workspaceId}/scenes/{sceneId}");
261
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
262
+ b.p("sceneId", () => input.sceneId, "{sceneId}", false);
330
263
  let body;
331
264
  let { hostname: resolvedHostname } = await context.endpoint();
332
265
  if (context.disableHostPrefix !== true) {
@@ -335,24 +268,17 @@ const se_DeleteSceneCommand = async (input, context) => {
335
268
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
336
269
  }
337
270
  }
338
- return new protocol_http_1.HttpRequest({
339
- protocol,
340
- hostname: resolvedHostname,
341
- port,
342
- method: "DELETE",
343
- headers,
344
- path: resolvedPath,
345
- body,
346
- });
271
+ b.hn(resolvedHostname);
272
+ b.m("DELETE").h(headers).b(body);
273
+ return b.build();
347
274
  };
348
275
  exports.se_DeleteSceneCommand = se_DeleteSceneCommand;
349
276
  const se_DeleteSyncJobCommand = async (input, context) => {
350
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
277
+ const b = (0, core_1.requestBuilder)(input, context);
351
278
  const headers = {};
352
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
353
- "/workspaces/{workspaceId}/sync-jobs/{syncSource}";
354
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
355
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "syncSource", () => input.syncSource, "{syncSource}", false);
279
+ b.bp("/workspaces/{workspaceId}/sync-jobs/{syncSource}");
280
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
281
+ b.p("syncSource", () => input.syncSource, "{syncSource}", false);
356
282
  let body;
357
283
  let { hostname: resolvedHostname } = await context.endpoint();
358
284
  if (context.disableHostPrefix !== true) {
@@ -361,22 +287,16 @@ const se_DeleteSyncJobCommand = async (input, context) => {
361
287
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
362
288
  }
363
289
  }
364
- return new protocol_http_1.HttpRequest({
365
- protocol,
366
- hostname: resolvedHostname,
367
- port,
368
- method: "DELETE",
369
- headers,
370
- path: resolvedPath,
371
- body,
372
- });
290
+ b.hn(resolvedHostname);
291
+ b.m("DELETE").h(headers).b(body);
292
+ return b.build();
373
293
  };
374
294
  exports.se_DeleteSyncJobCommand = se_DeleteSyncJobCommand;
375
295
  const se_DeleteWorkspaceCommand = async (input, context) => {
376
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
296
+ const b = (0, core_1.requestBuilder)(input, context);
377
297
  const headers = {};
378
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces/{workspaceId}";
379
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
298
+ b.bp("/workspaces/{workspaceId}");
299
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
380
300
  let body;
381
301
  let { hostname: resolvedHostname } = await context.endpoint();
382
302
  if (context.disableHostPrefix !== true) {
@@ -385,23 +305,17 @@ const se_DeleteWorkspaceCommand = async (input, context) => {
385
305
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
386
306
  }
387
307
  }
388
- return new protocol_http_1.HttpRequest({
389
- protocol,
390
- hostname: resolvedHostname,
391
- port,
392
- method: "DELETE",
393
- headers,
394
- path: resolvedPath,
395
- body,
396
- });
308
+ b.hn(resolvedHostname);
309
+ b.m("DELETE").h(headers).b(body);
310
+ return b.build();
397
311
  };
398
312
  exports.se_DeleteWorkspaceCommand = se_DeleteWorkspaceCommand;
399
313
  const se_ExecuteQueryCommand = async (input, context) => {
400
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
314
+ const b = (0, core_1.requestBuilder)(input, context);
401
315
  const headers = {
402
316
  "content-type": "application/json",
403
317
  };
404
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/queries/execution";
318
+ b.bp("/queries/execution");
405
319
  let body;
406
320
  body = JSON.stringify((0, smithy_client_1.take)(input, {
407
321
  maxResults: [],
@@ -416,24 +330,17 @@ const se_ExecuteQueryCommand = async (input, context) => {
416
330
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
417
331
  }
418
332
  }
419
- return new protocol_http_1.HttpRequest({
420
- protocol,
421
- hostname: resolvedHostname,
422
- port,
423
- method: "POST",
424
- headers,
425
- path: resolvedPath,
426
- body,
427
- });
333
+ b.hn(resolvedHostname);
334
+ b.m("POST").h(headers).b(body);
335
+ return b.build();
428
336
  };
429
337
  exports.se_ExecuteQueryCommand = se_ExecuteQueryCommand;
430
338
  const se_GetComponentTypeCommand = async (input, context) => {
431
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
339
+ const b = (0, core_1.requestBuilder)(input, context);
432
340
  const headers = {};
433
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
434
- "/workspaces/{workspaceId}/component-types/{componentTypeId}";
435
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
436
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "componentTypeId", () => input.componentTypeId, "{componentTypeId}", false);
341
+ b.bp("/workspaces/{workspaceId}/component-types/{componentTypeId}");
342
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
343
+ b.p("componentTypeId", () => input.componentTypeId, "{componentTypeId}", false);
437
344
  let body;
438
345
  let { hostname: resolvedHostname } = await context.endpoint();
439
346
  if (context.disableHostPrefix !== true) {
@@ -442,24 +349,17 @@ const se_GetComponentTypeCommand = async (input, context) => {
442
349
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
443
350
  }
444
351
  }
445
- return new protocol_http_1.HttpRequest({
446
- protocol,
447
- hostname: resolvedHostname,
448
- port,
449
- method: "GET",
450
- headers,
451
- path: resolvedPath,
452
- body,
453
- });
352
+ b.hn(resolvedHostname);
353
+ b.m("GET").h(headers).b(body);
354
+ return b.build();
454
355
  };
455
356
  exports.se_GetComponentTypeCommand = se_GetComponentTypeCommand;
456
357
  const se_GetEntityCommand = async (input, context) => {
457
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
358
+ const b = (0, core_1.requestBuilder)(input, context);
458
359
  const headers = {};
459
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
460
- "/workspaces/{workspaceId}/entities/{entityId}";
461
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
462
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "entityId", () => input.entityId, "{entityId}", false);
360
+ b.bp("/workspaces/{workspaceId}/entities/{entityId}");
361
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
362
+ b.p("entityId", () => input.entityId, "{entityId}", false);
463
363
  let body;
464
364
  let { hostname: resolvedHostname } = await context.endpoint();
465
365
  if (context.disableHostPrefix !== true) {
@@ -468,23 +368,16 @@ const se_GetEntityCommand = async (input, context) => {
468
368
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
469
369
  }
470
370
  }
471
- return new protocol_http_1.HttpRequest({
472
- protocol,
473
- hostname: resolvedHostname,
474
- port,
475
- method: "GET",
476
- headers,
477
- path: resolvedPath,
478
- body,
479
- });
371
+ b.hn(resolvedHostname);
372
+ b.m("GET").h(headers).b(body);
373
+ return b.build();
480
374
  };
481
375
  exports.se_GetEntityCommand = se_GetEntityCommand;
482
376
  const se_GetMetadataTransferJobCommand = async (input, context) => {
483
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
377
+ const b = (0, core_1.requestBuilder)(input, context);
484
378
  const headers = {};
485
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
486
- "/metadata-transfer-jobs/{metadataTransferJobId}";
487
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "metadataTransferJobId", () => input.metadataTransferJobId, "{metadataTransferJobId}", false);
379
+ b.bp("/metadata-transfer-jobs/{metadataTransferJobId}");
380
+ b.p("metadataTransferJobId", () => input.metadataTransferJobId, "{metadataTransferJobId}", false);
488
381
  let body;
489
382
  let { hostname: resolvedHostname } = await context.endpoint();
490
383
  if (context.disableHostPrefix !== true) {
@@ -493,23 +386,17 @@ const se_GetMetadataTransferJobCommand = async (input, context) => {
493
386
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
494
387
  }
495
388
  }
496
- return new protocol_http_1.HttpRequest({
497
- protocol,
498
- hostname: resolvedHostname,
499
- port,
500
- method: "GET",
501
- headers,
502
- path: resolvedPath,
503
- body,
504
- });
389
+ b.hn(resolvedHostname);
390
+ b.m("GET").h(headers).b(body);
391
+ return b.build();
505
392
  };
506
393
  exports.se_GetMetadataTransferJobCommand = se_GetMetadataTransferJobCommand;
507
394
  const se_GetPricingPlanCommand = async (input, context) => {
508
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
395
+ const b = (0, core_1.requestBuilder)(input, context);
509
396
  const headers = {
510
397
  "content-type": "application/json",
511
398
  };
512
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/pricingplan";
399
+ b.bp("/pricingplan");
513
400
  let body;
514
401
  body = "";
515
402
  let { hostname: resolvedHostname } = await context.endpoint();
@@ -519,25 +406,18 @@ const se_GetPricingPlanCommand = async (input, context) => {
519
406
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
520
407
  }
521
408
  }
522
- return new protocol_http_1.HttpRequest({
523
- protocol,
524
- hostname: resolvedHostname,
525
- port,
526
- method: "GET",
527
- headers,
528
- path: resolvedPath,
529
- body,
530
- });
409
+ b.hn(resolvedHostname);
410
+ b.m("GET").h(headers).b(body);
411
+ return b.build();
531
412
  };
532
413
  exports.se_GetPricingPlanCommand = se_GetPricingPlanCommand;
533
414
  const se_GetPropertyValueCommand = async (input, context) => {
534
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
415
+ const b = (0, core_1.requestBuilder)(input, context);
535
416
  const headers = {
536
417
  "content-type": "application/json",
537
418
  };
538
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
539
- "/workspaces/{workspaceId}/entity-properties/value";
540
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
419
+ b.bp("/workspaces/{workspaceId}/entity-properties/value");
420
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
541
421
  let body;
542
422
  body = JSON.stringify((0, smithy_client_1.take)(input, {
543
423
  componentName: [],
@@ -557,25 +437,18 @@ const se_GetPropertyValueCommand = async (input, context) => {
557
437
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
558
438
  }
559
439
  }
560
- return new protocol_http_1.HttpRequest({
561
- protocol,
562
- hostname: resolvedHostname,
563
- port,
564
- method: "POST",
565
- headers,
566
- path: resolvedPath,
567
- body,
568
- });
440
+ b.hn(resolvedHostname);
441
+ b.m("POST").h(headers).b(body);
442
+ return b.build();
569
443
  };
570
444
  exports.se_GetPropertyValueCommand = se_GetPropertyValueCommand;
571
445
  const se_GetPropertyValueHistoryCommand = async (input, context) => {
572
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
446
+ const b = (0, core_1.requestBuilder)(input, context);
573
447
  const headers = {
574
448
  "content-type": "application/json",
575
449
  };
576
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
577
- "/workspaces/{workspaceId}/entity-properties/history";
578
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
450
+ b.bp("/workspaces/{workspaceId}/entity-properties/history");
451
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
579
452
  let body;
580
453
  body = JSON.stringify((0, smithy_client_1.take)(input, {
581
454
  componentName: [],
@@ -600,24 +473,17 @@ const se_GetPropertyValueHistoryCommand = async (input, context) => {
600
473
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
601
474
  }
602
475
  }
603
- return new protocol_http_1.HttpRequest({
604
- protocol,
605
- hostname: resolvedHostname,
606
- port,
607
- method: "POST",
608
- headers,
609
- path: resolvedPath,
610
- body,
611
- });
476
+ b.hn(resolvedHostname);
477
+ b.m("POST").h(headers).b(body);
478
+ return b.build();
612
479
  };
613
480
  exports.se_GetPropertyValueHistoryCommand = se_GetPropertyValueHistoryCommand;
614
481
  const se_GetSceneCommand = async (input, context) => {
615
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
482
+ const b = (0, core_1.requestBuilder)(input, context);
616
483
  const headers = {};
617
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
618
- "/workspaces/{workspaceId}/scenes/{sceneId}";
619
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
620
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "sceneId", () => input.sceneId, "{sceneId}", false);
484
+ b.bp("/workspaces/{workspaceId}/scenes/{sceneId}");
485
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
486
+ b.p("sceneId", () => input.sceneId, "{sceneId}", false);
621
487
  let body;
622
488
  let { hostname: resolvedHostname } = await context.endpoint();
623
489
  if (context.disableHostPrefix !== true) {
@@ -626,24 +492,18 @@ const se_GetSceneCommand = async (input, context) => {
626
492
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
627
493
  }
628
494
  }
629
- return new protocol_http_1.HttpRequest({
630
- protocol,
631
- hostname: resolvedHostname,
632
- port,
633
- method: "GET",
634
- headers,
635
- path: resolvedPath,
636
- body,
637
- });
495
+ b.hn(resolvedHostname);
496
+ b.m("GET").h(headers).b(body);
497
+ return b.build();
638
498
  };
639
499
  exports.se_GetSceneCommand = se_GetSceneCommand;
640
500
  const se_GetSyncJobCommand = async (input, context) => {
641
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
501
+ const b = (0, core_1.requestBuilder)(input, context);
642
502
  const headers = {};
643
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sync-jobs/{syncSource}";
644
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "syncSource", () => input.syncSource, "{syncSource}", false);
503
+ b.bp("/sync-jobs/{syncSource}");
504
+ b.p("syncSource", () => input.syncSource, "{syncSource}", false);
645
505
  const query = (0, smithy_client_1.map)({
646
- workspace: [, input.workspaceId],
506
+ [_w]: [, input[_wI]],
647
507
  });
648
508
  let body;
649
509
  let { hostname: resolvedHostname } = await context.endpoint();
@@ -653,23 +513,16 @@ const se_GetSyncJobCommand = async (input, context) => {
653
513
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
654
514
  }
655
515
  }
656
- return new protocol_http_1.HttpRequest({
657
- protocol,
658
- hostname: resolvedHostname,
659
- port,
660
- method: "GET",
661
- headers,
662
- path: resolvedPath,
663
- query,
664
- body,
665
- });
516
+ b.hn(resolvedHostname);
517
+ b.m("GET").h(headers).q(query).b(body);
518
+ return b.build();
666
519
  };
667
520
  exports.se_GetSyncJobCommand = se_GetSyncJobCommand;
668
521
  const se_GetWorkspaceCommand = async (input, context) => {
669
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
522
+ const b = (0, core_1.requestBuilder)(input, context);
670
523
  const headers = {};
671
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces/{workspaceId}";
672
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
524
+ b.bp("/workspaces/{workspaceId}");
525
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
673
526
  let body;
674
527
  let { hostname: resolvedHostname } = await context.endpoint();
675
528
  if (context.disableHostPrefix !== true) {
@@ -678,26 +531,19 @@ const se_GetWorkspaceCommand = async (input, context) => {
678
531
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
679
532
  }
680
533
  }
681
- return new protocol_http_1.HttpRequest({
682
- protocol,
683
- hostname: resolvedHostname,
684
- port,
685
- method: "GET",
686
- headers,
687
- path: resolvedPath,
688
- body,
689
- });
534
+ b.hn(resolvedHostname);
535
+ b.m("GET").h(headers).b(body);
536
+ return b.build();
690
537
  };
691
538
  exports.se_GetWorkspaceCommand = se_GetWorkspaceCommand;
692
539
  const se_ListComponentsCommand = async (input, context) => {
693
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
540
+ const b = (0, core_1.requestBuilder)(input, context);
694
541
  const headers = {
695
542
  "content-type": "application/json",
696
543
  };
697
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
698
- "/workspaces/{workspaceId}/entities/{entityId}/components-list";
699
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
700
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "entityId", () => input.entityId, "{entityId}", false);
544
+ b.bp("/workspaces/{workspaceId}/entities/{entityId}/components-list");
545
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
546
+ b.p("entityId", () => input.entityId, "{entityId}", false);
701
547
  let body;
702
548
  body = JSON.stringify((0, smithy_client_1.take)(input, {
703
549
  componentPath: [],
@@ -711,25 +557,18 @@ const se_ListComponentsCommand = async (input, context) => {
711
557
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
712
558
  }
713
559
  }
714
- return new protocol_http_1.HttpRequest({
715
- protocol,
716
- hostname: resolvedHostname,
717
- port,
718
- method: "POST",
719
- headers,
720
- path: resolvedPath,
721
- body,
722
- });
560
+ b.hn(resolvedHostname);
561
+ b.m("POST").h(headers).b(body);
562
+ return b.build();
723
563
  };
724
564
  exports.se_ListComponentsCommand = se_ListComponentsCommand;
725
565
  const se_ListComponentTypesCommand = async (input, context) => {
726
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
566
+ const b = (0, core_1.requestBuilder)(input, context);
727
567
  const headers = {
728
568
  "content-type": "application/json",
729
569
  };
730
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
731
- "/workspaces/{workspaceId}/component-types-list";
732
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
570
+ b.bp("/workspaces/{workspaceId}/component-types-list");
571
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
733
572
  let body;
734
573
  body = JSON.stringify((0, smithy_client_1.take)(input, {
735
574
  filters: (_) => (0, smithy_client_1._json)(_),
@@ -743,24 +582,18 @@ const se_ListComponentTypesCommand = async (input, context) => {
743
582
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
744
583
  }
745
584
  }
746
- return new protocol_http_1.HttpRequest({
747
- protocol,
748
- hostname: resolvedHostname,
749
- port,
750
- method: "POST",
751
- headers,
752
- path: resolvedPath,
753
- body,
754
- });
585
+ b.hn(resolvedHostname);
586
+ b.m("POST").h(headers).b(body);
587
+ return b.build();
755
588
  };
756
589
  exports.se_ListComponentTypesCommand = se_ListComponentTypesCommand;
757
590
  const se_ListEntitiesCommand = async (input, context) => {
758
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
591
+ const b = (0, core_1.requestBuilder)(input, context);
759
592
  const headers = {
760
593
  "content-type": "application/json",
761
594
  };
762
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces/{workspaceId}/entities-list";
763
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
595
+ b.bp("/workspaces/{workspaceId}/entities-list");
596
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
764
597
  let body;
765
598
  body = JSON.stringify((0, smithy_client_1.take)(input, {
766
599
  filters: (_) => (0, smithy_client_1._json)(_),
@@ -774,23 +607,17 @@ const se_ListEntitiesCommand = async (input, context) => {
774
607
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
775
608
  }
776
609
  }
777
- return new protocol_http_1.HttpRequest({
778
- protocol,
779
- hostname: resolvedHostname,
780
- port,
781
- method: "POST",
782
- headers,
783
- path: resolvedPath,
784
- body,
785
- });
610
+ b.hn(resolvedHostname);
611
+ b.m("POST").h(headers).b(body);
612
+ return b.build();
786
613
  };
787
614
  exports.se_ListEntitiesCommand = se_ListEntitiesCommand;
788
615
  const se_ListMetadataTransferJobsCommand = async (input, context) => {
789
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
616
+ const b = (0, core_1.requestBuilder)(input, context);
790
617
  const headers = {
791
618
  "content-type": "application/json",
792
619
  };
793
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/metadata-transfer-jobs-list";
620
+ b.bp("/metadata-transfer-jobs-list");
794
621
  let body;
795
622
  body = JSON.stringify((0, smithy_client_1.take)(input, {
796
623
  destinationType: [],
@@ -806,24 +633,18 @@ const se_ListMetadataTransferJobsCommand = async (input, context) => {
806
633
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
807
634
  }
808
635
  }
809
- return new protocol_http_1.HttpRequest({
810
- protocol,
811
- hostname: resolvedHostname,
812
- port,
813
- method: "POST",
814
- headers,
815
- path: resolvedPath,
816
- body,
817
- });
636
+ b.hn(resolvedHostname);
637
+ b.m("POST").h(headers).b(body);
638
+ return b.build();
818
639
  };
819
640
  exports.se_ListMetadataTransferJobsCommand = se_ListMetadataTransferJobsCommand;
820
641
  const se_ListPropertiesCommand = async (input, context) => {
821
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
642
+ const b = (0, core_1.requestBuilder)(input, context);
822
643
  const headers = {
823
644
  "content-type": "application/json",
824
645
  };
825
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces/{workspaceId}/properties-list";
826
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
646
+ b.bp("/workspaces/{workspaceId}/properties-list");
647
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
827
648
  let body;
828
649
  body = JSON.stringify((0, smithy_client_1.take)(input, {
829
650
  componentName: [],
@@ -839,24 +660,18 @@ const se_ListPropertiesCommand = async (input, context) => {
839
660
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
840
661
  }
841
662
  }
842
- return new protocol_http_1.HttpRequest({
843
- protocol,
844
- hostname: resolvedHostname,
845
- port,
846
- method: "POST",
847
- headers,
848
- path: resolvedPath,
849
- body,
850
- });
663
+ b.hn(resolvedHostname);
664
+ b.m("POST").h(headers).b(body);
665
+ return b.build();
851
666
  };
852
667
  exports.se_ListPropertiesCommand = se_ListPropertiesCommand;
853
668
  const se_ListScenesCommand = async (input, context) => {
854
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
669
+ const b = (0, core_1.requestBuilder)(input, context);
855
670
  const headers = {
856
671
  "content-type": "application/json",
857
672
  };
858
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces/{workspaceId}/scenes-list";
859
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
673
+ b.bp("/workspaces/{workspaceId}/scenes-list");
674
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
860
675
  let body;
861
676
  body = JSON.stringify((0, smithy_client_1.take)(input, {
862
677
  maxResults: [],
@@ -869,24 +684,18 @@ const se_ListScenesCommand = async (input, context) => {
869
684
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
870
685
  }
871
686
  }
872
- return new protocol_http_1.HttpRequest({
873
- protocol,
874
- hostname: resolvedHostname,
875
- port,
876
- method: "POST",
877
- headers,
878
- path: resolvedPath,
879
- body,
880
- });
687
+ b.hn(resolvedHostname);
688
+ b.m("POST").h(headers).b(body);
689
+ return b.build();
881
690
  };
882
691
  exports.se_ListScenesCommand = se_ListScenesCommand;
883
692
  const se_ListSyncJobsCommand = async (input, context) => {
884
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
693
+ const b = (0, core_1.requestBuilder)(input, context);
885
694
  const headers = {
886
695
  "content-type": "application/json",
887
696
  };
888
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces/{workspaceId}/sync-jobs-list";
889
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
697
+ b.bp("/workspaces/{workspaceId}/sync-jobs-list");
698
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
890
699
  let body;
891
700
  body = JSON.stringify((0, smithy_client_1.take)(input, {
892
701
  maxResults: [],
@@ -899,26 +708,19 @@ const se_ListSyncJobsCommand = async (input, context) => {
899
708
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
900
709
  }
901
710
  }
902
- return new protocol_http_1.HttpRequest({
903
- protocol,
904
- hostname: resolvedHostname,
905
- port,
906
- method: "POST",
907
- headers,
908
- path: resolvedPath,
909
- body,
910
- });
711
+ b.hn(resolvedHostname);
712
+ b.m("POST").h(headers).b(body);
713
+ return b.build();
911
714
  };
912
715
  exports.se_ListSyncJobsCommand = se_ListSyncJobsCommand;
913
716
  const se_ListSyncResourcesCommand = async (input, context) => {
914
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
717
+ const b = (0, core_1.requestBuilder)(input, context);
915
718
  const headers = {
916
719
  "content-type": "application/json",
917
720
  };
918
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
919
- "/workspaces/{workspaceId}/sync-jobs/{syncSource}/resources-list";
920
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
921
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "syncSource", () => input.syncSource, "{syncSource}", false);
721
+ b.bp("/workspaces/{workspaceId}/sync-jobs/{syncSource}/resources-list");
722
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
723
+ b.p("syncSource", () => input.syncSource, "{syncSource}", false);
922
724
  let body;
923
725
  body = JSON.stringify((0, smithy_client_1.take)(input, {
924
726
  filters: (_) => (0, smithy_client_1._json)(_),
@@ -932,23 +734,17 @@ const se_ListSyncResourcesCommand = async (input, context) => {
932
734
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
933
735
  }
934
736
  }
935
- return new protocol_http_1.HttpRequest({
936
- protocol,
937
- hostname: resolvedHostname,
938
- port,
939
- method: "POST",
940
- headers,
941
- path: resolvedPath,
942
- body,
943
- });
737
+ b.hn(resolvedHostname);
738
+ b.m("POST").h(headers).b(body);
739
+ return b.build();
944
740
  };
945
741
  exports.se_ListSyncResourcesCommand = se_ListSyncResourcesCommand;
946
742
  const se_ListTagsForResourceCommand = async (input, context) => {
947
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
743
+ const b = (0, core_1.requestBuilder)(input, context);
948
744
  const headers = {
949
745
  "content-type": "application/json",
950
746
  };
951
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags-list";
747
+ b.bp("/tags-list");
952
748
  let body;
953
749
  body = JSON.stringify((0, smithy_client_1.take)(input, {
954
750
  maxResults: [],
@@ -962,23 +758,17 @@ const se_ListTagsForResourceCommand = async (input, context) => {
962
758
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
963
759
  }
964
760
  }
965
- return new protocol_http_1.HttpRequest({
966
- protocol,
967
- hostname: resolvedHostname,
968
- port,
969
- method: "POST",
970
- headers,
971
- path: resolvedPath,
972
- body,
973
- });
761
+ b.hn(resolvedHostname);
762
+ b.m("POST").h(headers).b(body);
763
+ return b.build();
974
764
  };
975
765
  exports.se_ListTagsForResourceCommand = se_ListTagsForResourceCommand;
976
766
  const se_ListWorkspacesCommand = async (input, context) => {
977
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
767
+ const b = (0, core_1.requestBuilder)(input, context);
978
768
  const headers = {
979
769
  "content-type": "application/json",
980
770
  };
981
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces-list";
771
+ b.bp("/workspaces-list");
982
772
  let body;
983
773
  body = JSON.stringify((0, smithy_client_1.take)(input, {
984
774
  maxResults: [],
@@ -991,23 +781,17 @@ const se_ListWorkspacesCommand = async (input, context) => {
991
781
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
992
782
  }
993
783
  }
994
- return new protocol_http_1.HttpRequest({
995
- protocol,
996
- hostname: resolvedHostname,
997
- port,
998
- method: "POST",
999
- headers,
1000
- path: resolvedPath,
1001
- body,
1002
- });
784
+ b.hn(resolvedHostname);
785
+ b.m("POST").h(headers).b(body);
786
+ return b.build();
1003
787
  };
1004
788
  exports.se_ListWorkspacesCommand = se_ListWorkspacesCommand;
1005
789
  const se_TagResourceCommand = async (input, context) => {
1006
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
790
+ const b = (0, core_1.requestBuilder)(input, context);
1007
791
  const headers = {
1008
792
  "content-type": "application/json",
1009
793
  };
1010
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags";
794
+ b.bp("/tags");
1011
795
  let body;
1012
796
  body = JSON.stringify((0, smithy_client_1.take)(input, {
1013
797
  resourceARN: [],
@@ -1020,26 +804,20 @@ const se_TagResourceCommand = async (input, context) => {
1020
804
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1021
805
  }
1022
806
  }
1023
- return new protocol_http_1.HttpRequest({
1024
- protocol,
1025
- hostname: resolvedHostname,
1026
- port,
1027
- method: "POST",
1028
- headers,
1029
- path: resolvedPath,
1030
- body,
1031
- });
807
+ b.hn(resolvedHostname);
808
+ b.m("POST").h(headers).b(body);
809
+ return b.build();
1032
810
  };
1033
811
  exports.se_TagResourceCommand = se_TagResourceCommand;
1034
812
  const se_UntagResourceCommand = async (input, context) => {
1035
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
813
+ const b = (0, core_1.requestBuilder)(input, context);
1036
814
  const headers = {};
1037
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags";
815
+ b.bp("/tags");
1038
816
  const query = (0, smithy_client_1.map)({
1039
- resourceARN: [, (0, smithy_client_1.expectNonNull)(input.resourceARN, `resourceARN`)],
1040
- tagKeys: [
817
+ [_rARN]: [, (0, smithy_client_1.expectNonNull)(input[_rARN], `resourceARN`)],
818
+ [_tK]: [
1041
819
  (0, smithy_client_1.expectNonNull)(input.tagKeys, `tagKeys`) != null,
1042
- () => (input.tagKeys || []).map((_entry) => _entry),
820
+ () => (input[_tK] || []).map((_entry) => _entry),
1043
821
  ],
1044
822
  });
1045
823
  let body;
@@ -1050,27 +828,19 @@ const se_UntagResourceCommand = async (input, context) => {
1050
828
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1051
829
  }
1052
830
  }
1053
- return new protocol_http_1.HttpRequest({
1054
- protocol,
1055
- hostname: resolvedHostname,
1056
- port,
1057
- method: "DELETE",
1058
- headers,
1059
- path: resolvedPath,
1060
- query,
1061
- body,
1062
- });
831
+ b.hn(resolvedHostname);
832
+ b.m("DELETE").h(headers).q(query).b(body);
833
+ return b.build();
1063
834
  };
1064
835
  exports.se_UntagResourceCommand = se_UntagResourceCommand;
1065
836
  const se_UpdateComponentTypeCommand = async (input, context) => {
1066
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
837
+ const b = (0, core_1.requestBuilder)(input, context);
1067
838
  const headers = {
1068
839
  "content-type": "application/json",
1069
840
  };
1070
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1071
- "/workspaces/{workspaceId}/component-types/{componentTypeId}";
1072
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
1073
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "componentTypeId", () => input.componentTypeId, "{componentTypeId}", false);
841
+ b.bp("/workspaces/{workspaceId}/component-types/{componentTypeId}");
842
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
843
+ b.p("componentTypeId", () => input.componentTypeId, "{componentTypeId}", false);
1074
844
  let body;
1075
845
  body = JSON.stringify((0, smithy_client_1.take)(input, {
1076
846
  componentTypeName: [],
@@ -1089,26 +859,19 @@ const se_UpdateComponentTypeCommand = async (input, context) => {
1089
859
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1090
860
  }
1091
861
  }
1092
- return new protocol_http_1.HttpRequest({
1093
- protocol,
1094
- hostname: resolvedHostname,
1095
- port,
1096
- method: "PUT",
1097
- headers,
1098
- path: resolvedPath,
1099
- body,
1100
- });
862
+ b.hn(resolvedHostname);
863
+ b.m("PUT").h(headers).b(body);
864
+ return b.build();
1101
865
  };
1102
866
  exports.se_UpdateComponentTypeCommand = se_UpdateComponentTypeCommand;
1103
867
  const se_UpdateEntityCommand = async (input, context) => {
1104
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
868
+ const b = (0, core_1.requestBuilder)(input, context);
1105
869
  const headers = {
1106
870
  "content-type": "application/json",
1107
871
  };
1108
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1109
- "/workspaces/{workspaceId}/entities/{entityId}";
1110
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
1111
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "entityId", () => input.entityId, "{entityId}", false);
872
+ b.bp("/workspaces/{workspaceId}/entities/{entityId}");
873
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
874
+ b.p("entityId", () => input.entityId, "{entityId}", false);
1112
875
  let body;
1113
876
  body = JSON.stringify((0, smithy_client_1.take)(input, {
1114
877
  componentUpdates: (_) => se_ComponentUpdatesMapRequest(_, context),
@@ -1124,23 +887,17 @@ const se_UpdateEntityCommand = async (input, context) => {
1124
887
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1125
888
  }
1126
889
  }
1127
- return new protocol_http_1.HttpRequest({
1128
- protocol,
1129
- hostname: resolvedHostname,
1130
- port,
1131
- method: "PUT",
1132
- headers,
1133
- path: resolvedPath,
1134
- body,
1135
- });
890
+ b.hn(resolvedHostname);
891
+ b.m("PUT").h(headers).b(body);
892
+ return b.build();
1136
893
  };
1137
894
  exports.se_UpdateEntityCommand = se_UpdateEntityCommand;
1138
895
  const se_UpdatePricingPlanCommand = async (input, context) => {
1139
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
896
+ const b = (0, core_1.requestBuilder)(input, context);
1140
897
  const headers = {
1141
898
  "content-type": "application/json",
1142
899
  };
1143
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/pricingplan";
900
+ b.bp("/pricingplan");
1144
901
  let body;
1145
902
  body = JSON.stringify((0, smithy_client_1.take)(input, {
1146
903
  bundleNames: (_) => (0, smithy_client_1._json)(_),
@@ -1153,26 +910,19 @@ const se_UpdatePricingPlanCommand = async (input, context) => {
1153
910
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1154
911
  }
1155
912
  }
1156
- return new protocol_http_1.HttpRequest({
1157
- protocol,
1158
- hostname: resolvedHostname,
1159
- port,
1160
- method: "POST",
1161
- headers,
1162
- path: resolvedPath,
1163
- body,
1164
- });
913
+ b.hn(resolvedHostname);
914
+ b.m("POST").h(headers).b(body);
915
+ return b.build();
1165
916
  };
1166
917
  exports.se_UpdatePricingPlanCommand = se_UpdatePricingPlanCommand;
1167
918
  const se_UpdateSceneCommand = async (input, context) => {
1168
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
919
+ const b = (0, core_1.requestBuilder)(input, context);
1169
920
  const headers = {
1170
921
  "content-type": "application/json",
1171
922
  };
1172
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1173
- "/workspaces/{workspaceId}/scenes/{sceneId}";
1174
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
1175
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "sceneId", () => input.sceneId, "{sceneId}", false);
923
+ b.bp("/workspaces/{workspaceId}/scenes/{sceneId}");
924
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
925
+ b.p("sceneId", () => input.sceneId, "{sceneId}", false);
1176
926
  let body;
1177
927
  body = JSON.stringify((0, smithy_client_1.take)(input, {
1178
928
  capabilities: (_) => (0, smithy_client_1._json)(_),
@@ -1187,24 +937,18 @@ const se_UpdateSceneCommand = async (input, context) => {
1187
937
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1188
938
  }
1189
939
  }
1190
- return new protocol_http_1.HttpRequest({
1191
- protocol,
1192
- hostname: resolvedHostname,
1193
- port,
1194
- method: "PUT",
1195
- headers,
1196
- path: resolvedPath,
1197
- body,
1198
- });
940
+ b.hn(resolvedHostname);
941
+ b.m("PUT").h(headers).b(body);
942
+ return b.build();
1199
943
  };
1200
944
  exports.se_UpdateSceneCommand = se_UpdateSceneCommand;
1201
945
  const se_UpdateWorkspaceCommand = async (input, context) => {
1202
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
946
+ const b = (0, core_1.requestBuilder)(input, context);
1203
947
  const headers = {
1204
948
  "content-type": "application/json",
1205
949
  };
1206
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces/{workspaceId}";
1207
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "workspaceId", () => input.workspaceId, "{workspaceId}", false);
950
+ b.bp("/workspaces/{workspaceId}");
951
+ b.p("workspaceId", () => input.workspaceId, "{workspaceId}", false);
1208
952
  let body;
1209
953
  body = JSON.stringify((0, smithy_client_1.take)(input, {
1210
954
  description: [],
@@ -1218,15 +962,9 @@ const se_UpdateWorkspaceCommand = async (input, context) => {
1218
962
  throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1219
963
  }
1220
964
  }
1221
- return new protocol_http_1.HttpRequest({
1222
- protocol,
1223
- hostname: resolvedHostname,
1224
- port,
1225
- method: "PUT",
1226
- headers,
1227
- path: resolvedPath,
1228
- body,
1229
- });
965
+ b.hn(resolvedHostname);
966
+ b.m("PUT").h(headers).b(body);
967
+ return b.build();
1230
968
  };
1231
969
  exports.se_UpdateWorkspaceCommand = se_UpdateWorkspaceCommand;
1232
970
  const de_BatchPutPropertyValuesCommand = async (output, context) => {
@@ -3905,6 +3643,11 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
3905
3643
  value !== "" &&
3906
3644
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
3907
3645
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
3646
+ const _iR = "isRecursive";
3647
+ const _rARN = "resourceARN";
3648
+ const _tK = "tagKeys";
3649
+ const _w = "workspace";
3650
+ const _wI = "workspaceId";
3908
3651
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
3909
3652
  if (encoded.length) {
3910
3653
  return JSON.parse(encoded);