@aws-sdk/client-workspaces-web 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 +317 -743
  2. package/dist-es/protocols/Aws_restJson1.js +318 -744
  3. package/package.json +5 -4
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,138 +1,86 @@
1
- import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
2
- import { _json, collectBody, decorateServiceException as __decorateServiceException, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, strictParseInt32 as __strictParseInt32, take, withBaseException, } from "@smithy/smithy-client";
1
+ import { requestBuilder as rb } from "@smithy/core";
2
+ import { _json, collectBody, decorateServiceException as __decorateServiceException, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, map, parseEpochTimestamp as __parseEpochTimestamp, strictParseInt32 as __strictParseInt32, take, withBaseException, } from "@smithy/smithy-client";
3
3
  import { v4 as generateIdempotencyToken } from "uuid";
4
4
  import { AccessDeniedException, ConflictException, InternalServerException, ResourceNotFoundException, ServiceQuotaExceededException, ThrottlingException, TooManyTagsException, ValidationException, } from "../models/models_0";
5
5
  import { WorkSpacesWebServiceException as __BaseException } from "../models/WorkSpacesWebServiceException";
6
6
  export const se_AssociateBrowserSettingsCommand = async (input, context) => {
7
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
7
+ const b = rb(input, context);
8
8
  const headers = {};
9
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/portals/{portalArn+}/browserSettings";
10
- resolvedPath = __resolvedPath(resolvedPath, input, "portalArn", () => input.portalArn, "{portalArn+}", true);
9
+ b.bp("/portals/{portalArn+}/browserSettings");
10
+ b.p("portalArn", () => input.portalArn, "{portalArn+}", true);
11
11
  const query = map({
12
- browserSettingsArn: [, __expectNonNull(input.browserSettingsArn, `browserSettingsArn`)],
12
+ [_bSA]: [, __expectNonNull(input[_bSA], `browserSettingsArn`)],
13
13
  });
14
14
  let body;
15
- return new __HttpRequest({
16
- protocol,
17
- hostname,
18
- port,
19
- method: "PUT",
20
- headers,
21
- path: resolvedPath,
22
- query,
23
- body,
24
- });
15
+ b.m("PUT").h(headers).q(query).b(body);
16
+ return b.build();
25
17
  };
26
18
  export const se_AssociateIpAccessSettingsCommand = async (input, context) => {
27
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
19
+ const b = rb(input, context);
28
20
  const headers = {};
29
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/portals/{portalArn+}/ipAccessSettings";
30
- resolvedPath = __resolvedPath(resolvedPath, input, "portalArn", () => input.portalArn, "{portalArn+}", true);
21
+ b.bp("/portals/{portalArn+}/ipAccessSettings");
22
+ b.p("portalArn", () => input.portalArn, "{portalArn+}", true);
31
23
  const query = map({
32
- ipAccessSettingsArn: [, __expectNonNull(input.ipAccessSettingsArn, `ipAccessSettingsArn`)],
24
+ [_iASA]: [, __expectNonNull(input[_iASA], `ipAccessSettingsArn`)],
33
25
  });
34
26
  let body;
35
- return new __HttpRequest({
36
- protocol,
37
- hostname,
38
- port,
39
- method: "PUT",
40
- headers,
41
- path: resolvedPath,
42
- query,
43
- body,
44
- });
27
+ b.m("PUT").h(headers).q(query).b(body);
28
+ return b.build();
45
29
  };
46
30
  export const se_AssociateNetworkSettingsCommand = async (input, context) => {
47
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
31
+ const b = rb(input, context);
48
32
  const headers = {};
49
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/portals/{portalArn+}/networkSettings";
50
- resolvedPath = __resolvedPath(resolvedPath, input, "portalArn", () => input.portalArn, "{portalArn+}", true);
33
+ b.bp("/portals/{portalArn+}/networkSettings");
34
+ b.p("portalArn", () => input.portalArn, "{portalArn+}", true);
51
35
  const query = map({
52
- networkSettingsArn: [, __expectNonNull(input.networkSettingsArn, `networkSettingsArn`)],
36
+ [_nSA]: [, __expectNonNull(input[_nSA], `networkSettingsArn`)],
53
37
  });
54
38
  let body;
55
- return new __HttpRequest({
56
- protocol,
57
- hostname,
58
- port,
59
- method: "PUT",
60
- headers,
61
- path: resolvedPath,
62
- query,
63
- body,
64
- });
39
+ b.m("PUT").h(headers).q(query).b(body);
40
+ return b.build();
65
41
  };
66
42
  export const se_AssociateTrustStoreCommand = async (input, context) => {
67
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
43
+ const b = rb(input, context);
68
44
  const headers = {};
69
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/portals/{portalArn+}/trustStores";
70
- resolvedPath = __resolvedPath(resolvedPath, input, "portalArn", () => input.portalArn, "{portalArn+}", true);
45
+ b.bp("/portals/{portalArn+}/trustStores");
46
+ b.p("portalArn", () => input.portalArn, "{portalArn+}", true);
71
47
  const query = map({
72
- trustStoreArn: [, __expectNonNull(input.trustStoreArn, `trustStoreArn`)],
48
+ [_tSA]: [, __expectNonNull(input[_tSA], `trustStoreArn`)],
73
49
  });
74
50
  let body;
75
- return new __HttpRequest({
76
- protocol,
77
- hostname,
78
- port,
79
- method: "PUT",
80
- headers,
81
- path: resolvedPath,
82
- query,
83
- body,
84
- });
51
+ b.m("PUT").h(headers).q(query).b(body);
52
+ return b.build();
85
53
  };
86
54
  export const se_AssociateUserAccessLoggingSettingsCommand = async (input, context) => {
87
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
55
+ const b = rb(input, context);
88
56
  const headers = {};
89
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
90
- "/portals/{portalArn+}/userAccessLoggingSettings";
91
- resolvedPath = __resolvedPath(resolvedPath, input, "portalArn", () => input.portalArn, "{portalArn+}", true);
57
+ b.bp("/portals/{portalArn+}/userAccessLoggingSettings");
58
+ b.p("portalArn", () => input.portalArn, "{portalArn+}", true);
92
59
  const query = map({
93
- userAccessLoggingSettingsArn: [
94
- ,
95
- __expectNonNull(input.userAccessLoggingSettingsArn, `userAccessLoggingSettingsArn`),
96
- ],
60
+ [_uALSA]: [, __expectNonNull(input[_uALSA], `userAccessLoggingSettingsArn`)],
97
61
  });
98
62
  let body;
99
- return new __HttpRequest({
100
- protocol,
101
- hostname,
102
- port,
103
- method: "PUT",
104
- headers,
105
- path: resolvedPath,
106
- query,
107
- body,
108
- });
63
+ b.m("PUT").h(headers).q(query).b(body);
64
+ return b.build();
109
65
  };
110
66
  export const se_AssociateUserSettingsCommand = async (input, context) => {
111
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
67
+ const b = rb(input, context);
112
68
  const headers = {};
113
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/portals/{portalArn+}/userSettings";
114
- resolvedPath = __resolvedPath(resolvedPath, input, "portalArn", () => input.portalArn, "{portalArn+}", true);
69
+ b.bp("/portals/{portalArn+}/userSettings");
70
+ b.p("portalArn", () => input.portalArn, "{portalArn+}", true);
115
71
  const query = map({
116
- userSettingsArn: [, __expectNonNull(input.userSettingsArn, `userSettingsArn`)],
72
+ [_uSA]: [, __expectNonNull(input[_uSA], `userSettingsArn`)],
117
73
  });
118
74
  let body;
119
- return new __HttpRequest({
120
- protocol,
121
- hostname,
122
- port,
123
- method: "PUT",
124
- headers,
125
- path: resolvedPath,
126
- query,
127
- body,
128
- });
75
+ b.m("PUT").h(headers).q(query).b(body);
76
+ return b.build();
129
77
  };
130
78
  export const se_CreateBrowserSettingsCommand = async (input, context) => {
131
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
79
+ const b = rb(input, context);
132
80
  const headers = {
133
81
  "content-type": "application/json",
134
82
  };
135
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/browserSettings";
83
+ b.bp("/browserSettings");
136
84
  let body;
137
85
  body = JSON.stringify(take(input, {
138
86
  additionalEncryptionContext: (_) => _json(_),
@@ -141,22 +89,15 @@ export const se_CreateBrowserSettingsCommand = async (input, context) => {
141
89
  customerManagedKey: [],
142
90
  tags: (_) => _json(_),
143
91
  }));
144
- return new __HttpRequest({
145
- protocol,
146
- hostname,
147
- port,
148
- method: "POST",
149
- headers,
150
- path: resolvedPath,
151
- body,
152
- });
92
+ b.m("POST").h(headers).b(body);
93
+ return b.build();
153
94
  };
154
95
  export const se_CreateIdentityProviderCommand = async (input, context) => {
155
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
96
+ const b = rb(input, context);
156
97
  const headers = {
157
98
  "content-type": "application/json",
158
99
  };
159
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/identityProviders";
100
+ b.bp("/identityProviders");
160
101
  let body;
161
102
  body = JSON.stringify(take(input, {
162
103
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -165,22 +106,15 @@ export const se_CreateIdentityProviderCommand = async (input, context) => {
165
106
  identityProviderType: [],
166
107
  portalArn: [],
167
108
  }));
168
- return new __HttpRequest({
169
- protocol,
170
- hostname,
171
- port,
172
- method: "POST",
173
- headers,
174
- path: resolvedPath,
175
- body,
176
- });
109
+ b.m("POST").h(headers).b(body);
110
+ return b.build();
177
111
  };
178
112
  export const se_CreateIpAccessSettingsCommand = async (input, context) => {
179
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
113
+ const b = rb(input, context);
180
114
  const headers = {
181
115
  "content-type": "application/json",
182
116
  };
183
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ipAccessSettings";
117
+ b.bp("/ipAccessSettings");
184
118
  let body;
185
119
  body = JSON.stringify(take(input, {
186
120
  additionalEncryptionContext: (_) => _json(_),
@@ -191,22 +125,15 @@ export const se_CreateIpAccessSettingsCommand = async (input, context) => {
191
125
  ipRules: (_) => _json(_),
192
126
  tags: (_) => _json(_),
193
127
  }));
194
- return new __HttpRequest({
195
- protocol,
196
- hostname,
197
- port,
198
- method: "POST",
199
- headers,
200
- path: resolvedPath,
201
- body,
202
- });
128
+ b.m("POST").h(headers).b(body);
129
+ return b.build();
203
130
  };
204
131
  export const se_CreateNetworkSettingsCommand = async (input, context) => {
205
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
132
+ const b = rb(input, context);
206
133
  const headers = {
207
134
  "content-type": "application/json",
208
135
  };
209
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/networkSettings";
136
+ b.bp("/networkSettings");
210
137
  let body;
211
138
  body = JSON.stringify(take(input, {
212
139
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -215,22 +142,15 @@ export const se_CreateNetworkSettingsCommand = async (input, context) => {
215
142
  tags: (_) => _json(_),
216
143
  vpcId: [],
217
144
  }));
218
- return new __HttpRequest({
219
- protocol,
220
- hostname,
221
- port,
222
- method: "POST",
223
- headers,
224
- path: resolvedPath,
225
- body,
226
- });
145
+ b.m("POST").h(headers).b(body);
146
+ return b.build();
227
147
  };
228
148
  export const se_CreatePortalCommand = async (input, context) => {
229
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
149
+ const b = rb(input, context);
230
150
  const headers = {
231
151
  "content-type": "application/json",
232
152
  };
233
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/portals";
153
+ b.bp("/portals");
234
154
  let body;
235
155
  body = JSON.stringify(take(input, {
236
156
  additionalEncryptionContext: (_) => _json(_),
@@ -240,66 +160,45 @@ export const se_CreatePortalCommand = async (input, context) => {
240
160
  displayName: [],
241
161
  tags: (_) => _json(_),
242
162
  }));
243
- return new __HttpRequest({
244
- protocol,
245
- hostname,
246
- port,
247
- method: "POST",
248
- headers,
249
- path: resolvedPath,
250
- body,
251
- });
163
+ b.m("POST").h(headers).b(body);
164
+ return b.build();
252
165
  };
253
166
  export const se_CreateTrustStoreCommand = async (input, context) => {
254
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
167
+ const b = rb(input, context);
255
168
  const headers = {
256
169
  "content-type": "application/json",
257
170
  };
258
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/trustStores";
171
+ b.bp("/trustStores");
259
172
  let body;
260
173
  body = JSON.stringify(take(input, {
261
174
  certificateList: (_) => se_CertificateList(_, context),
262
175
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
263
176
  tags: (_) => _json(_),
264
177
  }));
265
- return new __HttpRequest({
266
- protocol,
267
- hostname,
268
- port,
269
- method: "POST",
270
- headers,
271
- path: resolvedPath,
272
- body,
273
- });
178
+ b.m("POST").h(headers).b(body);
179
+ return b.build();
274
180
  };
275
181
  export const se_CreateUserAccessLoggingSettingsCommand = async (input, context) => {
276
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
182
+ const b = rb(input, context);
277
183
  const headers = {
278
184
  "content-type": "application/json",
279
185
  };
280
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/userAccessLoggingSettings";
186
+ b.bp("/userAccessLoggingSettings");
281
187
  let body;
282
188
  body = JSON.stringify(take(input, {
283
189
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
284
190
  kinesisStreamArn: [],
285
191
  tags: (_) => _json(_),
286
192
  }));
287
- return new __HttpRequest({
288
- protocol,
289
- hostname,
290
- port,
291
- method: "POST",
292
- headers,
293
- path: resolvedPath,
294
- body,
295
- });
193
+ b.m("POST").h(headers).b(body);
194
+ return b.build();
296
195
  };
297
196
  export const se_CreateUserSettingsCommand = async (input, context) => {
298
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
197
+ const b = rb(input, context);
299
198
  const headers = {
300
199
  "content-type": "application/json",
301
200
  };
302
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/userSettings";
201
+ b.bp("/userSettings");
303
202
  let body;
304
203
  body = JSON.stringify(take(input, {
305
204
  additionalEncryptionContext: (_) => _json(_),
@@ -315,680 +214,399 @@ export const se_CreateUserSettingsCommand = async (input, context) => {
315
214
  tags: (_) => _json(_),
316
215
  uploadAllowed: [],
317
216
  }));
318
- return new __HttpRequest({
319
- protocol,
320
- hostname,
321
- port,
322
- method: "POST",
323
- headers,
324
- path: resolvedPath,
325
- body,
326
- });
217
+ b.m("POST").h(headers).b(body);
218
+ return b.build();
327
219
  };
328
220
  export const se_DeleteBrowserSettingsCommand = async (input, context) => {
329
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
221
+ const b = rb(input, context);
330
222
  const headers = {};
331
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/browserSettings/{browserSettingsArn+}";
332
- resolvedPath = __resolvedPath(resolvedPath, input, "browserSettingsArn", () => input.browserSettingsArn, "{browserSettingsArn+}", true);
223
+ b.bp("/browserSettings/{browserSettingsArn+}");
224
+ b.p("browserSettingsArn", () => input.browserSettingsArn, "{browserSettingsArn+}", true);
333
225
  let body;
334
- return new __HttpRequest({
335
- protocol,
336
- hostname,
337
- port,
338
- method: "DELETE",
339
- headers,
340
- path: resolvedPath,
341
- body,
342
- });
226
+ b.m("DELETE").h(headers).b(body);
227
+ return b.build();
343
228
  };
344
229
  export const se_DeleteIdentityProviderCommand = async (input, context) => {
345
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
230
+ const b = rb(input, context);
346
231
  const headers = {};
347
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/identityProviders/{identityProviderArn+}";
348
- resolvedPath = __resolvedPath(resolvedPath, input, "identityProviderArn", () => input.identityProviderArn, "{identityProviderArn+}", true);
232
+ b.bp("/identityProviders/{identityProviderArn+}");
233
+ b.p("identityProviderArn", () => input.identityProviderArn, "{identityProviderArn+}", true);
349
234
  let body;
350
- return new __HttpRequest({
351
- protocol,
352
- hostname,
353
- port,
354
- method: "DELETE",
355
- headers,
356
- path: resolvedPath,
357
- body,
358
- });
235
+ b.m("DELETE").h(headers).b(body);
236
+ return b.build();
359
237
  };
360
238
  export const se_DeleteIpAccessSettingsCommand = async (input, context) => {
361
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
239
+ const b = rb(input, context);
362
240
  const headers = {};
363
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ipAccessSettings/{ipAccessSettingsArn+}";
364
- resolvedPath = __resolvedPath(resolvedPath, input, "ipAccessSettingsArn", () => input.ipAccessSettingsArn, "{ipAccessSettingsArn+}", true);
241
+ b.bp("/ipAccessSettings/{ipAccessSettingsArn+}");
242
+ b.p("ipAccessSettingsArn", () => input.ipAccessSettingsArn, "{ipAccessSettingsArn+}", true);
365
243
  let body;
366
- return new __HttpRequest({
367
- protocol,
368
- hostname,
369
- port,
370
- method: "DELETE",
371
- headers,
372
- path: resolvedPath,
373
- body,
374
- });
244
+ b.m("DELETE").h(headers).b(body);
245
+ return b.build();
375
246
  };
376
247
  export const se_DeleteNetworkSettingsCommand = async (input, context) => {
377
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
248
+ const b = rb(input, context);
378
249
  const headers = {};
379
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/networkSettings/{networkSettingsArn+}";
380
- resolvedPath = __resolvedPath(resolvedPath, input, "networkSettingsArn", () => input.networkSettingsArn, "{networkSettingsArn+}", true);
250
+ b.bp("/networkSettings/{networkSettingsArn+}");
251
+ b.p("networkSettingsArn", () => input.networkSettingsArn, "{networkSettingsArn+}", true);
381
252
  let body;
382
- return new __HttpRequest({
383
- protocol,
384
- hostname,
385
- port,
386
- method: "DELETE",
387
- headers,
388
- path: resolvedPath,
389
- body,
390
- });
253
+ b.m("DELETE").h(headers).b(body);
254
+ return b.build();
391
255
  };
392
256
  export const se_DeletePortalCommand = async (input, context) => {
393
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
257
+ const b = rb(input, context);
394
258
  const headers = {};
395
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/portals/{portalArn+}";
396
- resolvedPath = __resolvedPath(resolvedPath, input, "portalArn", () => input.portalArn, "{portalArn+}", true);
259
+ b.bp("/portals/{portalArn+}");
260
+ b.p("portalArn", () => input.portalArn, "{portalArn+}", true);
397
261
  let body;
398
- return new __HttpRequest({
399
- protocol,
400
- hostname,
401
- port,
402
- method: "DELETE",
403
- headers,
404
- path: resolvedPath,
405
- body,
406
- });
262
+ b.m("DELETE").h(headers).b(body);
263
+ return b.build();
407
264
  };
408
265
  export const se_DeleteTrustStoreCommand = async (input, context) => {
409
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
266
+ const b = rb(input, context);
410
267
  const headers = {};
411
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/trustStores/{trustStoreArn+}";
412
- resolvedPath = __resolvedPath(resolvedPath, input, "trustStoreArn", () => input.trustStoreArn, "{trustStoreArn+}", true);
268
+ b.bp("/trustStores/{trustStoreArn+}");
269
+ b.p("trustStoreArn", () => input.trustStoreArn, "{trustStoreArn+}", true);
413
270
  let body;
414
- return new __HttpRequest({
415
- protocol,
416
- hostname,
417
- port,
418
- method: "DELETE",
419
- headers,
420
- path: resolvedPath,
421
- body,
422
- });
271
+ b.m("DELETE").h(headers).b(body);
272
+ return b.build();
423
273
  };
424
274
  export const se_DeleteUserAccessLoggingSettingsCommand = async (input, context) => {
425
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
275
+ const b = rb(input, context);
426
276
  const headers = {};
427
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
428
- "/userAccessLoggingSettings/{userAccessLoggingSettingsArn+}";
429
- resolvedPath = __resolvedPath(resolvedPath, input, "userAccessLoggingSettingsArn", () => input.userAccessLoggingSettingsArn, "{userAccessLoggingSettingsArn+}", true);
277
+ b.bp("/userAccessLoggingSettings/{userAccessLoggingSettingsArn+}");
278
+ b.p("userAccessLoggingSettingsArn", () => input.userAccessLoggingSettingsArn, "{userAccessLoggingSettingsArn+}", true);
430
279
  let body;
431
- return new __HttpRequest({
432
- protocol,
433
- hostname,
434
- port,
435
- method: "DELETE",
436
- headers,
437
- path: resolvedPath,
438
- body,
439
- });
280
+ b.m("DELETE").h(headers).b(body);
281
+ return b.build();
440
282
  };
441
283
  export const se_DeleteUserSettingsCommand = async (input, context) => {
442
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
284
+ const b = rb(input, context);
443
285
  const headers = {};
444
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/userSettings/{userSettingsArn+}";
445
- resolvedPath = __resolvedPath(resolvedPath, input, "userSettingsArn", () => input.userSettingsArn, "{userSettingsArn+}", true);
286
+ b.bp("/userSettings/{userSettingsArn+}");
287
+ b.p("userSettingsArn", () => input.userSettingsArn, "{userSettingsArn+}", true);
446
288
  let body;
447
- return new __HttpRequest({
448
- protocol,
449
- hostname,
450
- port,
451
- method: "DELETE",
452
- headers,
453
- path: resolvedPath,
454
- body,
455
- });
289
+ b.m("DELETE").h(headers).b(body);
290
+ return b.build();
456
291
  };
457
292
  export const se_DisassociateBrowserSettingsCommand = async (input, context) => {
458
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
293
+ const b = rb(input, context);
459
294
  const headers = {};
460
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/portals/{portalArn+}/browserSettings";
461
- resolvedPath = __resolvedPath(resolvedPath, input, "portalArn", () => input.portalArn, "{portalArn+}", true);
295
+ b.bp("/portals/{portalArn+}/browserSettings");
296
+ b.p("portalArn", () => input.portalArn, "{portalArn+}", true);
462
297
  let body;
463
- return new __HttpRequest({
464
- protocol,
465
- hostname,
466
- port,
467
- method: "DELETE",
468
- headers,
469
- path: resolvedPath,
470
- body,
471
- });
298
+ b.m("DELETE").h(headers).b(body);
299
+ return b.build();
472
300
  };
473
301
  export const se_DisassociateIpAccessSettingsCommand = async (input, context) => {
474
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
302
+ const b = rb(input, context);
475
303
  const headers = {};
476
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/portals/{portalArn+}/ipAccessSettings";
477
- resolvedPath = __resolvedPath(resolvedPath, input, "portalArn", () => input.portalArn, "{portalArn+}", true);
304
+ b.bp("/portals/{portalArn+}/ipAccessSettings");
305
+ b.p("portalArn", () => input.portalArn, "{portalArn+}", true);
478
306
  let body;
479
- return new __HttpRequest({
480
- protocol,
481
- hostname,
482
- port,
483
- method: "DELETE",
484
- headers,
485
- path: resolvedPath,
486
- body,
487
- });
307
+ b.m("DELETE").h(headers).b(body);
308
+ return b.build();
488
309
  };
489
310
  export const se_DisassociateNetworkSettingsCommand = async (input, context) => {
490
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
311
+ const b = rb(input, context);
491
312
  const headers = {};
492
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/portals/{portalArn+}/networkSettings";
493
- resolvedPath = __resolvedPath(resolvedPath, input, "portalArn", () => input.portalArn, "{portalArn+}", true);
313
+ b.bp("/portals/{portalArn+}/networkSettings");
314
+ b.p("portalArn", () => input.portalArn, "{portalArn+}", true);
494
315
  let body;
495
- return new __HttpRequest({
496
- protocol,
497
- hostname,
498
- port,
499
- method: "DELETE",
500
- headers,
501
- path: resolvedPath,
502
- body,
503
- });
316
+ b.m("DELETE").h(headers).b(body);
317
+ return b.build();
504
318
  };
505
319
  export const se_DisassociateTrustStoreCommand = async (input, context) => {
506
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
320
+ const b = rb(input, context);
507
321
  const headers = {};
508
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/portals/{portalArn+}/trustStores";
509
- resolvedPath = __resolvedPath(resolvedPath, input, "portalArn", () => input.portalArn, "{portalArn+}", true);
322
+ b.bp("/portals/{portalArn+}/trustStores");
323
+ b.p("portalArn", () => input.portalArn, "{portalArn+}", true);
510
324
  let body;
511
- return new __HttpRequest({
512
- protocol,
513
- hostname,
514
- port,
515
- method: "DELETE",
516
- headers,
517
- path: resolvedPath,
518
- body,
519
- });
325
+ b.m("DELETE").h(headers).b(body);
326
+ return b.build();
520
327
  };
521
328
  export const se_DisassociateUserAccessLoggingSettingsCommand = async (input, context) => {
522
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
329
+ const b = rb(input, context);
523
330
  const headers = {};
524
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
525
- "/portals/{portalArn+}/userAccessLoggingSettings";
526
- resolvedPath = __resolvedPath(resolvedPath, input, "portalArn", () => input.portalArn, "{portalArn+}", true);
331
+ b.bp("/portals/{portalArn+}/userAccessLoggingSettings");
332
+ b.p("portalArn", () => input.portalArn, "{portalArn+}", true);
527
333
  let body;
528
- return new __HttpRequest({
529
- protocol,
530
- hostname,
531
- port,
532
- method: "DELETE",
533
- headers,
534
- path: resolvedPath,
535
- body,
536
- });
334
+ b.m("DELETE").h(headers).b(body);
335
+ return b.build();
537
336
  };
538
337
  export const se_DisassociateUserSettingsCommand = async (input, context) => {
539
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
338
+ const b = rb(input, context);
540
339
  const headers = {};
541
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/portals/{portalArn+}/userSettings";
542
- resolvedPath = __resolvedPath(resolvedPath, input, "portalArn", () => input.portalArn, "{portalArn+}", true);
340
+ b.bp("/portals/{portalArn+}/userSettings");
341
+ b.p("portalArn", () => input.portalArn, "{portalArn+}", true);
543
342
  let body;
544
- return new __HttpRequest({
545
- protocol,
546
- hostname,
547
- port,
548
- method: "DELETE",
549
- headers,
550
- path: resolvedPath,
551
- body,
552
- });
343
+ b.m("DELETE").h(headers).b(body);
344
+ return b.build();
553
345
  };
554
346
  export const se_GetBrowserSettingsCommand = async (input, context) => {
555
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
347
+ const b = rb(input, context);
556
348
  const headers = {};
557
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/browserSettings/{browserSettingsArn+}";
558
- resolvedPath = __resolvedPath(resolvedPath, input, "browserSettingsArn", () => input.browserSettingsArn, "{browserSettingsArn+}", true);
349
+ b.bp("/browserSettings/{browserSettingsArn+}");
350
+ b.p("browserSettingsArn", () => input.browserSettingsArn, "{browserSettingsArn+}", true);
559
351
  let body;
560
- return new __HttpRequest({
561
- protocol,
562
- hostname,
563
- port,
564
- method: "GET",
565
- headers,
566
- path: resolvedPath,
567
- body,
568
- });
352
+ b.m("GET").h(headers).b(body);
353
+ return b.build();
569
354
  };
570
355
  export const se_GetIdentityProviderCommand = async (input, context) => {
571
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
356
+ const b = rb(input, context);
572
357
  const headers = {};
573
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/identityProviders/{identityProviderArn+}";
574
- resolvedPath = __resolvedPath(resolvedPath, input, "identityProviderArn", () => input.identityProviderArn, "{identityProviderArn+}", true);
358
+ b.bp("/identityProviders/{identityProviderArn+}");
359
+ b.p("identityProviderArn", () => input.identityProviderArn, "{identityProviderArn+}", true);
575
360
  let body;
576
- return new __HttpRequest({
577
- protocol,
578
- hostname,
579
- port,
580
- method: "GET",
581
- headers,
582
- path: resolvedPath,
583
- body,
584
- });
361
+ b.m("GET").h(headers).b(body);
362
+ return b.build();
585
363
  };
586
364
  export const se_GetIpAccessSettingsCommand = async (input, context) => {
587
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
365
+ const b = rb(input, context);
588
366
  const headers = {};
589
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ipAccessSettings/{ipAccessSettingsArn+}";
590
- resolvedPath = __resolvedPath(resolvedPath, input, "ipAccessSettingsArn", () => input.ipAccessSettingsArn, "{ipAccessSettingsArn+}", true);
367
+ b.bp("/ipAccessSettings/{ipAccessSettingsArn+}");
368
+ b.p("ipAccessSettingsArn", () => input.ipAccessSettingsArn, "{ipAccessSettingsArn+}", true);
591
369
  let body;
592
- return new __HttpRequest({
593
- protocol,
594
- hostname,
595
- port,
596
- method: "GET",
597
- headers,
598
- path: resolvedPath,
599
- body,
600
- });
370
+ b.m("GET").h(headers).b(body);
371
+ return b.build();
601
372
  };
602
373
  export const se_GetNetworkSettingsCommand = async (input, context) => {
603
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
374
+ const b = rb(input, context);
604
375
  const headers = {};
605
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/networkSettings/{networkSettingsArn+}";
606
- resolvedPath = __resolvedPath(resolvedPath, input, "networkSettingsArn", () => input.networkSettingsArn, "{networkSettingsArn+}", true);
376
+ b.bp("/networkSettings/{networkSettingsArn+}");
377
+ b.p("networkSettingsArn", () => input.networkSettingsArn, "{networkSettingsArn+}", true);
607
378
  let body;
608
- return new __HttpRequest({
609
- protocol,
610
- hostname,
611
- port,
612
- method: "GET",
613
- headers,
614
- path: resolvedPath,
615
- body,
616
- });
379
+ b.m("GET").h(headers).b(body);
380
+ return b.build();
617
381
  };
618
382
  export const se_GetPortalCommand = async (input, context) => {
619
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
383
+ const b = rb(input, context);
620
384
  const headers = {};
621
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/portals/{portalArn+}";
622
- resolvedPath = __resolvedPath(resolvedPath, input, "portalArn", () => input.portalArn, "{portalArn+}", true);
385
+ b.bp("/portals/{portalArn+}");
386
+ b.p("portalArn", () => input.portalArn, "{portalArn+}", true);
623
387
  let body;
624
- return new __HttpRequest({
625
- protocol,
626
- hostname,
627
- port,
628
- method: "GET",
629
- headers,
630
- path: resolvedPath,
631
- body,
632
- });
388
+ b.m("GET").h(headers).b(body);
389
+ return b.build();
633
390
  };
634
391
  export const se_GetPortalServiceProviderMetadataCommand = async (input, context) => {
635
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
392
+ const b = rb(input, context);
636
393
  const headers = {};
637
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/portalIdp/{portalArn+}";
638
- resolvedPath = __resolvedPath(resolvedPath, input, "portalArn", () => input.portalArn, "{portalArn+}", true);
394
+ b.bp("/portalIdp/{portalArn+}");
395
+ b.p("portalArn", () => input.portalArn, "{portalArn+}", true);
639
396
  let body;
640
- return new __HttpRequest({
641
- protocol,
642
- hostname,
643
- port,
644
- method: "GET",
645
- headers,
646
- path: resolvedPath,
647
- body,
648
- });
397
+ b.m("GET").h(headers).b(body);
398
+ return b.build();
649
399
  };
650
400
  export const se_GetTrustStoreCommand = async (input, context) => {
651
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
401
+ const b = rb(input, context);
652
402
  const headers = {};
653
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/trustStores/{trustStoreArn+}";
654
- resolvedPath = __resolvedPath(resolvedPath, input, "trustStoreArn", () => input.trustStoreArn, "{trustStoreArn+}", true);
403
+ b.bp("/trustStores/{trustStoreArn+}");
404
+ b.p("trustStoreArn", () => input.trustStoreArn, "{trustStoreArn+}", true);
655
405
  let body;
656
- return new __HttpRequest({
657
- protocol,
658
- hostname,
659
- port,
660
- method: "GET",
661
- headers,
662
- path: resolvedPath,
663
- body,
664
- });
406
+ b.m("GET").h(headers).b(body);
407
+ return b.build();
665
408
  };
666
409
  export const se_GetTrustStoreCertificateCommand = async (input, context) => {
667
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
410
+ const b = rb(input, context);
668
411
  const headers = {};
669
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/trustStores/{trustStoreArn+}/certificate";
670
- resolvedPath = __resolvedPath(resolvedPath, input, "trustStoreArn", () => input.trustStoreArn, "{trustStoreArn+}", true);
412
+ b.bp("/trustStores/{trustStoreArn+}/certificate");
413
+ b.p("trustStoreArn", () => input.trustStoreArn, "{trustStoreArn+}", true);
671
414
  const query = map({
672
- thumbprint: [, __expectNonNull(input.thumbprint, `thumbprint`)],
415
+ [_t]: [, __expectNonNull(input[_t], `thumbprint`)],
673
416
  });
674
417
  let body;
675
- return new __HttpRequest({
676
- protocol,
677
- hostname,
678
- port,
679
- method: "GET",
680
- headers,
681
- path: resolvedPath,
682
- query,
683
- body,
684
- });
418
+ b.m("GET").h(headers).q(query).b(body);
419
+ return b.build();
685
420
  };
686
421
  export const se_GetUserAccessLoggingSettingsCommand = async (input, context) => {
687
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
422
+ const b = rb(input, context);
688
423
  const headers = {};
689
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
690
- "/userAccessLoggingSettings/{userAccessLoggingSettingsArn+}";
691
- resolvedPath = __resolvedPath(resolvedPath, input, "userAccessLoggingSettingsArn", () => input.userAccessLoggingSettingsArn, "{userAccessLoggingSettingsArn+}", true);
424
+ b.bp("/userAccessLoggingSettings/{userAccessLoggingSettingsArn+}");
425
+ b.p("userAccessLoggingSettingsArn", () => input.userAccessLoggingSettingsArn, "{userAccessLoggingSettingsArn+}", true);
692
426
  let body;
693
- return new __HttpRequest({
694
- protocol,
695
- hostname,
696
- port,
697
- method: "GET",
698
- headers,
699
- path: resolvedPath,
700
- body,
701
- });
427
+ b.m("GET").h(headers).b(body);
428
+ return b.build();
702
429
  };
703
430
  export const se_GetUserSettingsCommand = async (input, context) => {
704
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
431
+ const b = rb(input, context);
705
432
  const headers = {};
706
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/userSettings/{userSettingsArn+}";
707
- resolvedPath = __resolvedPath(resolvedPath, input, "userSettingsArn", () => input.userSettingsArn, "{userSettingsArn+}", true);
433
+ b.bp("/userSettings/{userSettingsArn+}");
434
+ b.p("userSettingsArn", () => input.userSettingsArn, "{userSettingsArn+}", true);
708
435
  let body;
709
- return new __HttpRequest({
710
- protocol,
711
- hostname,
712
- port,
713
- method: "GET",
714
- headers,
715
- path: resolvedPath,
716
- body,
717
- });
436
+ b.m("GET").h(headers).b(body);
437
+ return b.build();
718
438
  };
719
439
  export const se_ListBrowserSettingsCommand = async (input, context) => {
720
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
440
+ const b = rb(input, context);
721
441
  const headers = {};
722
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/browserSettings";
442
+ b.bp("/browserSettings");
723
443
  const query = map({
724
- nextToken: [, input.nextToken],
725
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
444
+ [_nT]: [, input[_nT]],
445
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
726
446
  });
727
447
  let body;
728
- return new __HttpRequest({
729
- protocol,
730
- hostname,
731
- port,
732
- method: "GET",
733
- headers,
734
- path: resolvedPath,
735
- query,
736
- body,
737
- });
448
+ b.m("GET").h(headers).q(query).b(body);
449
+ return b.build();
738
450
  };
739
451
  export const se_ListIdentityProvidersCommand = async (input, context) => {
740
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
452
+ const b = rb(input, context);
741
453
  const headers = {};
742
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/portals/{portalArn+}/identityProviders";
743
- resolvedPath = __resolvedPath(resolvedPath, input, "portalArn", () => input.portalArn, "{portalArn+}", true);
454
+ b.bp("/portals/{portalArn+}/identityProviders");
455
+ b.p("portalArn", () => input.portalArn, "{portalArn+}", true);
744
456
  const query = map({
745
- nextToken: [, input.nextToken],
746
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
457
+ [_nT]: [, input[_nT]],
458
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
747
459
  });
748
460
  let body;
749
- return new __HttpRequest({
750
- protocol,
751
- hostname,
752
- port,
753
- method: "GET",
754
- headers,
755
- path: resolvedPath,
756
- query,
757
- body,
758
- });
461
+ b.m("GET").h(headers).q(query).b(body);
462
+ return b.build();
759
463
  };
760
464
  export const se_ListIpAccessSettingsCommand = async (input, context) => {
761
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
465
+ const b = rb(input, context);
762
466
  const headers = {};
763
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ipAccessSettings";
467
+ b.bp("/ipAccessSettings");
764
468
  const query = map({
765
- nextToken: [, input.nextToken],
766
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
469
+ [_nT]: [, input[_nT]],
470
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
767
471
  });
768
472
  let body;
769
- return new __HttpRequest({
770
- protocol,
771
- hostname,
772
- port,
773
- method: "GET",
774
- headers,
775
- path: resolvedPath,
776
- query,
777
- body,
778
- });
473
+ b.m("GET").h(headers).q(query).b(body);
474
+ return b.build();
779
475
  };
780
476
  export const se_ListNetworkSettingsCommand = async (input, context) => {
781
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
477
+ const b = rb(input, context);
782
478
  const headers = {};
783
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/networkSettings";
479
+ b.bp("/networkSettings");
784
480
  const query = map({
785
- nextToken: [, input.nextToken],
786
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
481
+ [_nT]: [, input[_nT]],
482
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
787
483
  });
788
484
  let body;
789
- return new __HttpRequest({
790
- protocol,
791
- hostname,
792
- port,
793
- method: "GET",
794
- headers,
795
- path: resolvedPath,
796
- query,
797
- body,
798
- });
485
+ b.m("GET").h(headers).q(query).b(body);
486
+ return b.build();
799
487
  };
800
488
  export const se_ListPortalsCommand = async (input, context) => {
801
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
489
+ const b = rb(input, context);
802
490
  const headers = {};
803
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/portals";
491
+ b.bp("/portals");
804
492
  const query = map({
805
- nextToken: [, input.nextToken],
806
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
493
+ [_nT]: [, input[_nT]],
494
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
807
495
  });
808
496
  let body;
809
- return new __HttpRequest({
810
- protocol,
811
- hostname,
812
- port,
813
- method: "GET",
814
- headers,
815
- path: resolvedPath,
816
- query,
817
- body,
818
- });
497
+ b.m("GET").h(headers).q(query).b(body);
498
+ return b.build();
819
499
  };
820
500
  export const se_ListTagsForResourceCommand = async (input, context) => {
821
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
501
+ const b = rb(input, context);
822
502
  const headers = {};
823
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn+}";
824
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn+}", true);
503
+ b.bp("/tags/{resourceArn+}");
504
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn+}", true);
825
505
  let body;
826
- return new __HttpRequest({
827
- protocol,
828
- hostname,
829
- port,
830
- method: "GET",
831
- headers,
832
- path: resolvedPath,
833
- body,
834
- });
506
+ b.m("GET").h(headers).b(body);
507
+ return b.build();
835
508
  };
836
509
  export const se_ListTrustStoreCertificatesCommand = async (input, context) => {
837
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
510
+ const b = rb(input, context);
838
511
  const headers = {};
839
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
840
- "/trustStores/{trustStoreArn+}/certificates";
841
- resolvedPath = __resolvedPath(resolvedPath, input, "trustStoreArn", () => input.trustStoreArn, "{trustStoreArn+}", true);
512
+ b.bp("/trustStores/{trustStoreArn+}/certificates");
513
+ b.p("trustStoreArn", () => input.trustStoreArn, "{trustStoreArn+}", true);
842
514
  const query = map({
843
- nextToken: [, input.nextToken],
844
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
515
+ [_nT]: [, input[_nT]],
516
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
845
517
  });
846
518
  let body;
847
- return new __HttpRequest({
848
- protocol,
849
- hostname,
850
- port,
851
- method: "GET",
852
- headers,
853
- path: resolvedPath,
854
- query,
855
- body,
856
- });
519
+ b.m("GET").h(headers).q(query).b(body);
520
+ return b.build();
857
521
  };
858
522
  export const se_ListTrustStoresCommand = async (input, context) => {
859
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
523
+ const b = rb(input, context);
860
524
  const headers = {};
861
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/trustStores";
525
+ b.bp("/trustStores");
862
526
  const query = map({
863
- nextToken: [, input.nextToken],
864
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
527
+ [_nT]: [, input[_nT]],
528
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
865
529
  });
866
530
  let body;
867
- return new __HttpRequest({
868
- protocol,
869
- hostname,
870
- port,
871
- method: "GET",
872
- headers,
873
- path: resolvedPath,
874
- query,
875
- body,
876
- });
531
+ b.m("GET").h(headers).q(query).b(body);
532
+ return b.build();
877
533
  };
878
534
  export const se_ListUserAccessLoggingSettingsCommand = async (input, context) => {
879
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
535
+ const b = rb(input, context);
880
536
  const headers = {};
881
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/userAccessLoggingSettings";
537
+ b.bp("/userAccessLoggingSettings");
882
538
  const query = map({
883
- nextToken: [, input.nextToken],
884
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
539
+ [_nT]: [, input[_nT]],
540
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
885
541
  });
886
542
  let body;
887
- return new __HttpRequest({
888
- protocol,
889
- hostname,
890
- port,
891
- method: "GET",
892
- headers,
893
- path: resolvedPath,
894
- query,
895
- body,
896
- });
543
+ b.m("GET").h(headers).q(query).b(body);
544
+ return b.build();
897
545
  };
898
546
  export const se_ListUserSettingsCommand = async (input, context) => {
899
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
547
+ const b = rb(input, context);
900
548
  const headers = {};
901
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/userSettings";
549
+ b.bp("/userSettings");
902
550
  const query = map({
903
- nextToken: [, input.nextToken],
904
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
551
+ [_nT]: [, input[_nT]],
552
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
905
553
  });
906
554
  let body;
907
- return new __HttpRequest({
908
- protocol,
909
- hostname,
910
- port,
911
- method: "GET",
912
- headers,
913
- path: resolvedPath,
914
- query,
915
- body,
916
- });
555
+ b.m("GET").h(headers).q(query).b(body);
556
+ return b.build();
917
557
  };
918
558
  export const se_TagResourceCommand = async (input, context) => {
919
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
559
+ const b = rb(input, context);
920
560
  const headers = {
921
561
  "content-type": "application/json",
922
562
  };
923
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn+}";
924
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn+}", true);
563
+ b.bp("/tags/{resourceArn+}");
564
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn+}", true);
925
565
  let body;
926
566
  body = JSON.stringify(take(input, {
927
567
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
928
568
  tags: (_) => _json(_),
929
569
  }));
930
- return new __HttpRequest({
931
- protocol,
932
- hostname,
933
- port,
934
- method: "POST",
935
- headers,
936
- path: resolvedPath,
937
- body,
938
- });
570
+ b.m("POST").h(headers).b(body);
571
+ return b.build();
939
572
  };
940
573
  export const se_UntagResourceCommand = async (input, context) => {
941
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
574
+ const b = rb(input, context);
942
575
  const headers = {};
943
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn+}";
944
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn+}", true);
576
+ b.bp("/tags/{resourceArn+}");
577
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn+}", true);
945
578
  const query = map({
946
- tagKeys: [
579
+ [_tK]: [
947
580
  __expectNonNull(input.tagKeys, `tagKeys`) != null,
948
- () => (input.tagKeys || []).map((_entry) => _entry),
581
+ () => (input[_tK] || []).map((_entry) => _entry),
949
582
  ],
950
583
  });
951
584
  let body;
952
- return new __HttpRequest({
953
- protocol,
954
- hostname,
955
- port,
956
- method: "DELETE",
957
- headers,
958
- path: resolvedPath,
959
- query,
960
- body,
961
- });
585
+ b.m("DELETE").h(headers).q(query).b(body);
586
+ return b.build();
962
587
  };
963
588
  export const se_UpdateBrowserSettingsCommand = async (input, context) => {
964
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
589
+ const b = rb(input, context);
965
590
  const headers = {
966
591
  "content-type": "application/json",
967
592
  };
968
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/browserSettings/{browserSettingsArn+}";
969
- resolvedPath = __resolvedPath(resolvedPath, input, "browserSettingsArn", () => input.browserSettingsArn, "{browserSettingsArn+}", true);
593
+ b.bp("/browserSettings/{browserSettingsArn+}");
594
+ b.p("browserSettingsArn", () => input.browserSettingsArn, "{browserSettingsArn+}", true);
970
595
  let body;
971
596
  body = JSON.stringify(take(input, {
972
597
  browserPolicy: [],
973
598
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
974
599
  }));
975
- return new __HttpRequest({
976
- protocol,
977
- hostname,
978
- port,
979
- method: "PATCH",
980
- headers,
981
- path: resolvedPath,
982
- body,
983
- });
600
+ b.m("PATCH").h(headers).b(body);
601
+ return b.build();
984
602
  };
985
603
  export const se_UpdateIdentityProviderCommand = async (input, context) => {
986
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
604
+ const b = rb(input, context);
987
605
  const headers = {
988
606
  "content-type": "application/json",
989
607
  };
990
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/identityProviders/{identityProviderArn+}";
991
- resolvedPath = __resolvedPath(resolvedPath, input, "identityProviderArn", () => input.identityProviderArn, "{identityProviderArn+}", true);
608
+ b.bp("/identityProviders/{identityProviderArn+}");
609
+ b.p("identityProviderArn", () => input.identityProviderArn, "{identityProviderArn+}", true);
992
610
  let body;
993
611
  body = JSON.stringify(take(input, {
994
612
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -996,23 +614,16 @@ export const se_UpdateIdentityProviderCommand = async (input, context) => {
996
614
  identityProviderName: [],
997
615
  identityProviderType: [],
998
616
  }));
999
- return new __HttpRequest({
1000
- protocol,
1001
- hostname,
1002
- port,
1003
- method: "PATCH",
1004
- headers,
1005
- path: resolvedPath,
1006
- body,
1007
- });
617
+ b.m("PATCH").h(headers).b(body);
618
+ return b.build();
1008
619
  };
1009
620
  export const se_UpdateIpAccessSettingsCommand = async (input, context) => {
1010
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
621
+ const b = rb(input, context);
1011
622
  const headers = {
1012
623
  "content-type": "application/json",
1013
624
  };
1014
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ipAccessSettings/{ipAccessSettingsArn+}";
1015
- resolvedPath = __resolvedPath(resolvedPath, input, "ipAccessSettingsArn", () => input.ipAccessSettingsArn, "{ipAccessSettingsArn+}", true);
625
+ b.bp("/ipAccessSettings/{ipAccessSettingsArn+}");
626
+ b.p("ipAccessSettingsArn", () => input.ipAccessSettingsArn, "{ipAccessSettingsArn+}", true);
1016
627
  let body;
1017
628
  body = JSON.stringify(take(input, {
1018
629
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -1020,23 +631,16 @@ export const se_UpdateIpAccessSettingsCommand = async (input, context) => {
1020
631
  displayName: [],
1021
632
  ipRules: (_) => _json(_),
1022
633
  }));
1023
- return new __HttpRequest({
1024
- protocol,
1025
- hostname,
1026
- port,
1027
- method: "PATCH",
1028
- headers,
1029
- path: resolvedPath,
1030
- body,
1031
- });
634
+ b.m("PATCH").h(headers).b(body);
635
+ return b.build();
1032
636
  };
1033
637
  export const se_UpdateNetworkSettingsCommand = async (input, context) => {
1034
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
638
+ const b = rb(input, context);
1035
639
  const headers = {
1036
640
  "content-type": "application/json",
1037
641
  };
1038
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/networkSettings/{networkSettingsArn+}";
1039
- resolvedPath = __resolvedPath(resolvedPath, input, "networkSettingsArn", () => input.networkSettingsArn, "{networkSettingsArn+}", true);
642
+ b.bp("/networkSettings/{networkSettingsArn+}");
643
+ b.p("networkSettingsArn", () => input.networkSettingsArn, "{networkSettingsArn+}", true);
1040
644
  let body;
1041
645
  body = JSON.stringify(take(input, {
1042
646
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -1044,91 +648,62 @@ export const se_UpdateNetworkSettingsCommand = async (input, context) => {
1044
648
  subnetIds: (_) => _json(_),
1045
649
  vpcId: [],
1046
650
  }));
1047
- return new __HttpRequest({
1048
- protocol,
1049
- hostname,
1050
- port,
1051
- method: "PATCH",
1052
- headers,
1053
- path: resolvedPath,
1054
- body,
1055
- });
651
+ b.m("PATCH").h(headers).b(body);
652
+ return b.build();
1056
653
  };
1057
654
  export const se_UpdatePortalCommand = async (input, context) => {
1058
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
655
+ const b = rb(input, context);
1059
656
  const headers = {
1060
657
  "content-type": "application/json",
1061
658
  };
1062
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/portals/{portalArn+}";
1063
- resolvedPath = __resolvedPath(resolvedPath, input, "portalArn", () => input.portalArn, "{portalArn+}", true);
659
+ b.bp("/portals/{portalArn+}");
660
+ b.p("portalArn", () => input.portalArn, "{portalArn+}", true);
1064
661
  let body;
1065
662
  body = JSON.stringify(take(input, {
1066
663
  authenticationType: [],
1067
664
  displayName: [],
1068
665
  }));
1069
- return new __HttpRequest({
1070
- protocol,
1071
- hostname,
1072
- port,
1073
- method: "PUT",
1074
- headers,
1075
- path: resolvedPath,
1076
- body,
1077
- });
666
+ b.m("PUT").h(headers).b(body);
667
+ return b.build();
1078
668
  };
1079
669
  export const se_UpdateTrustStoreCommand = async (input, context) => {
1080
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
670
+ const b = rb(input, context);
1081
671
  const headers = {
1082
672
  "content-type": "application/json",
1083
673
  };
1084
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/trustStores/{trustStoreArn+}";
1085
- resolvedPath = __resolvedPath(resolvedPath, input, "trustStoreArn", () => input.trustStoreArn, "{trustStoreArn+}", true);
674
+ b.bp("/trustStores/{trustStoreArn+}");
675
+ b.p("trustStoreArn", () => input.trustStoreArn, "{trustStoreArn+}", true);
1086
676
  let body;
1087
677
  body = JSON.stringify(take(input, {
1088
678
  certificatesToAdd: (_) => se_CertificateList(_, context),
1089
679
  certificatesToDelete: (_) => _json(_),
1090
680
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
1091
681
  }));
1092
- return new __HttpRequest({
1093
- protocol,
1094
- hostname,
1095
- port,
1096
- method: "PATCH",
1097
- headers,
1098
- path: resolvedPath,
1099
- body,
1100
- });
682
+ b.m("PATCH").h(headers).b(body);
683
+ return b.build();
1101
684
  };
1102
685
  export const se_UpdateUserAccessLoggingSettingsCommand = async (input, context) => {
1103
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
686
+ const b = rb(input, context);
1104
687
  const headers = {
1105
688
  "content-type": "application/json",
1106
689
  };
1107
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1108
- "/userAccessLoggingSettings/{userAccessLoggingSettingsArn+}";
1109
- resolvedPath = __resolvedPath(resolvedPath, input, "userAccessLoggingSettingsArn", () => input.userAccessLoggingSettingsArn, "{userAccessLoggingSettingsArn+}", true);
690
+ b.bp("/userAccessLoggingSettings/{userAccessLoggingSettingsArn+}");
691
+ b.p("userAccessLoggingSettingsArn", () => input.userAccessLoggingSettingsArn, "{userAccessLoggingSettingsArn+}", true);
1110
692
  let body;
1111
693
  body = JSON.stringify(take(input, {
1112
694
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
1113
695
  kinesisStreamArn: [],
1114
696
  }));
1115
- return new __HttpRequest({
1116
- protocol,
1117
- hostname,
1118
- port,
1119
- method: "PATCH",
1120
- headers,
1121
- path: resolvedPath,
1122
- body,
1123
- });
697
+ b.m("PATCH").h(headers).b(body);
698
+ return b.build();
1124
699
  };
1125
700
  export const se_UpdateUserSettingsCommand = async (input, context) => {
1126
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
701
+ const b = rb(input, context);
1127
702
  const headers = {
1128
703
  "content-type": "application/json",
1129
704
  };
1130
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/userSettings/{userSettingsArn+}";
1131
- resolvedPath = __resolvedPath(resolvedPath, input, "userSettingsArn", () => input.userSettingsArn, "{userSettingsArn+}", true);
705
+ b.bp("/userSettings/{userSettingsArn+}");
706
+ b.p("userSettingsArn", () => input.userSettingsArn, "{userSettingsArn+}", true);
1132
707
  let body;
1133
708
  body = JSON.stringify(take(input, {
1134
709
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -1141,15 +716,8 @@ export const se_UpdateUserSettingsCommand = async (input, context) => {
1141
716
  printAllowed: [],
1142
717
  uploadAllowed: [],
1143
718
  }));
1144
- return new __HttpRequest({
1145
- protocol,
1146
- hostname,
1147
- port,
1148
- method: "PATCH",
1149
- headers,
1150
- path: resolvedPath,
1151
- body,
1152
- });
719
+ b.m("PATCH").h(headers).b(body);
720
+ return b.build();
1153
721
  };
1154
722
  export const de_AssociateBrowserSettingsCommand = async (output, context) => {
1155
723
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -3780,10 +3348,7 @@ const de_ConflictExceptionRes = async (parsedOutput, context) => {
3780
3348
  };
3781
3349
  const de_InternalServerExceptionRes = async (parsedOutput, context) => {
3782
3350
  const contents = map({
3783
- retryAfterSeconds: [
3784
- () => void 0 !== parsedOutput.headers["retry-after"],
3785
- () => __strictParseInt32(parsedOutput.headers["retry-after"]),
3786
- ],
3351
+ [_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => __strictParseInt32(parsedOutput.headers[_ra])],
3787
3352
  });
3788
3353
  const data = parsedOutput.body;
3789
3354
  const doc = take(data, {
@@ -3830,10 +3395,7 @@ const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
3830
3395
  };
3831
3396
  const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
3832
3397
  const contents = map({
3833
- retryAfterSeconds: [
3834
- () => void 0 !== parsedOutput.headers["retry-after"],
3835
- () => __strictParseInt32(parsedOutput.headers["retry-after"]),
3836
- ],
3398
+ [_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => __strictParseInt32(parsedOutput.headers[_ra])],
3837
3399
  });
3838
3400
  const data = parsedOutput.body;
3839
3401
  const doc = take(data, {
@@ -3994,6 +3556,18 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
3994
3556
  value !== "" &&
3995
3557
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
3996
3558
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
3559
+ const _bSA = "browserSettingsArn";
3560
+ const _iASA = "ipAccessSettingsArn";
3561
+ const _mR = "maxResults";
3562
+ const _nSA = "networkSettingsArn";
3563
+ const _nT = "nextToken";
3564
+ const _rAS = "retryAfterSeconds";
3565
+ const _ra = "retry-after";
3566
+ const _t = "thumbprint";
3567
+ const _tK = "tagKeys";
3568
+ const _tSA = "trustStoreArn";
3569
+ const _uALSA = "userAccessLoggingSettingsArn";
3570
+ const _uSA = "userSettingsArn";
3997
3571
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
3998
3572
  if (encoded.length) {
3999
3573
  return JSON.parse(encoded);