@aws-sdk/client-rolesanywhere 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 +141 -339
  2. package/dist-es/protocols/Aws_restJson1.js +142 -340
  3. package/package.json +5 -4
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,13 +1,13 @@
1
- import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
2
- import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, resolvedPath as __resolvedPath, take, withBaseException, } from "@smithy/smithy-client";
1
+ import { requestBuilder as rb } from "@smithy/core";
2
+ import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, take, withBaseException, } from "@smithy/smithy-client";
3
3
  import { AccessDeniedException, ResourceNotFoundException, TooManyTagsException, ValidationException, } from "../models/models_0";
4
4
  import { RolesAnywhereServiceException as __BaseException } from "../models/RolesAnywhereServiceException";
5
5
  export const se_CreateProfileCommand = async (input, context) => {
6
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
6
+ const b = rb(input, context);
7
7
  const headers = {
8
8
  "content-type": "application/json",
9
9
  };
10
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/profiles";
10
+ b.bp("/profiles");
11
11
  let body;
12
12
  body = JSON.stringify(take(input, {
13
13
  durationSeconds: [],
@@ -19,22 +19,15 @@ export const se_CreateProfileCommand = async (input, context) => {
19
19
  sessionPolicy: [],
20
20
  tags: (_) => _json(_),
21
21
  }));
22
- return new __HttpRequest({
23
- protocol,
24
- hostname,
25
- port,
26
- method: "POST",
27
- headers,
28
- path: resolvedPath,
29
- body,
30
- });
22
+ b.m("POST").h(headers).b(body);
23
+ return b.build();
31
24
  };
32
25
  export const se_CreateTrustAnchorCommand = async (input, context) => {
33
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
26
+ const b = rb(input, context);
34
27
  const headers = {
35
28
  "content-type": "application/json",
36
29
  };
37
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/trustanchors";
30
+ b.bp("/trustanchors");
38
31
  let body;
39
32
  body = JSON.stringify(take(input, {
40
33
  enabled: [],
@@ -43,230 +36,132 @@ export const se_CreateTrustAnchorCommand = async (input, context) => {
43
36
  source: (_) => _json(_),
44
37
  tags: (_) => _json(_),
45
38
  }));
46
- return new __HttpRequest({
47
- protocol,
48
- hostname,
49
- port,
50
- method: "POST",
51
- headers,
52
- path: resolvedPath,
53
- body,
54
- });
39
+ b.m("POST").h(headers).b(body);
40
+ return b.build();
55
41
  };
56
42
  export const se_DeleteCrlCommand = async (input, context) => {
57
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
43
+ const b = rb(input, context);
58
44
  const headers = {};
59
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/crl/{crlId}";
60
- resolvedPath = __resolvedPath(resolvedPath, input, "crlId", () => input.crlId, "{crlId}", false);
45
+ b.bp("/crl/{crlId}");
46
+ b.p("crlId", () => input.crlId, "{crlId}", false);
61
47
  let body;
62
- return new __HttpRequest({
63
- protocol,
64
- hostname,
65
- port,
66
- method: "DELETE",
67
- headers,
68
- path: resolvedPath,
69
- body,
70
- });
48
+ b.m("DELETE").h(headers).b(body);
49
+ return b.build();
71
50
  };
72
51
  export const se_DeleteProfileCommand = async (input, context) => {
73
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
52
+ const b = rb(input, context);
74
53
  const headers = {};
75
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/profile/{profileId}";
76
- resolvedPath = __resolvedPath(resolvedPath, input, "profileId", () => input.profileId, "{profileId}", false);
54
+ b.bp("/profile/{profileId}");
55
+ b.p("profileId", () => input.profileId, "{profileId}", false);
77
56
  let body;
78
- return new __HttpRequest({
79
- protocol,
80
- hostname,
81
- port,
82
- method: "DELETE",
83
- headers,
84
- path: resolvedPath,
85
- body,
86
- });
57
+ b.m("DELETE").h(headers).b(body);
58
+ return b.build();
87
59
  };
88
60
  export const se_DeleteTrustAnchorCommand = async (input, context) => {
89
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
61
+ const b = rb(input, context);
90
62
  const headers = {};
91
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/trustanchor/{trustAnchorId}";
92
- resolvedPath = __resolvedPath(resolvedPath, input, "trustAnchorId", () => input.trustAnchorId, "{trustAnchorId}", false);
63
+ b.bp("/trustanchor/{trustAnchorId}");
64
+ b.p("trustAnchorId", () => input.trustAnchorId, "{trustAnchorId}", false);
93
65
  let body;
94
- return new __HttpRequest({
95
- protocol,
96
- hostname,
97
- port,
98
- method: "DELETE",
99
- headers,
100
- path: resolvedPath,
101
- body,
102
- });
66
+ b.m("DELETE").h(headers).b(body);
67
+ return b.build();
103
68
  };
104
69
  export const se_DisableCrlCommand = async (input, context) => {
105
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
70
+ const b = rb(input, context);
106
71
  const headers = {};
107
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/crl/{crlId}/disable";
108
- resolvedPath = __resolvedPath(resolvedPath, input, "crlId", () => input.crlId, "{crlId}", false);
72
+ b.bp("/crl/{crlId}/disable");
73
+ b.p("crlId", () => input.crlId, "{crlId}", false);
109
74
  let body;
110
- return new __HttpRequest({
111
- protocol,
112
- hostname,
113
- port,
114
- method: "POST",
115
- headers,
116
- path: resolvedPath,
117
- body,
118
- });
75
+ b.m("POST").h(headers).b(body);
76
+ return b.build();
119
77
  };
120
78
  export const se_DisableProfileCommand = async (input, context) => {
121
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
79
+ const b = rb(input, context);
122
80
  const headers = {};
123
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/profile/{profileId}/disable";
124
- resolvedPath = __resolvedPath(resolvedPath, input, "profileId", () => input.profileId, "{profileId}", false);
81
+ b.bp("/profile/{profileId}/disable");
82
+ b.p("profileId", () => input.profileId, "{profileId}", false);
125
83
  let body;
126
- return new __HttpRequest({
127
- protocol,
128
- hostname,
129
- port,
130
- method: "POST",
131
- headers,
132
- path: resolvedPath,
133
- body,
134
- });
84
+ b.m("POST").h(headers).b(body);
85
+ return b.build();
135
86
  };
136
87
  export const se_DisableTrustAnchorCommand = async (input, context) => {
137
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
88
+ const b = rb(input, context);
138
89
  const headers = {};
139
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/trustanchor/{trustAnchorId}/disable";
140
- resolvedPath = __resolvedPath(resolvedPath, input, "trustAnchorId", () => input.trustAnchorId, "{trustAnchorId}", false);
90
+ b.bp("/trustanchor/{trustAnchorId}/disable");
91
+ b.p("trustAnchorId", () => input.trustAnchorId, "{trustAnchorId}", false);
141
92
  let body;
142
- return new __HttpRequest({
143
- protocol,
144
- hostname,
145
- port,
146
- method: "POST",
147
- headers,
148
- path: resolvedPath,
149
- body,
150
- });
93
+ b.m("POST").h(headers).b(body);
94
+ return b.build();
151
95
  };
152
96
  export const se_EnableCrlCommand = async (input, context) => {
153
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
97
+ const b = rb(input, context);
154
98
  const headers = {};
155
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/crl/{crlId}/enable";
156
- resolvedPath = __resolvedPath(resolvedPath, input, "crlId", () => input.crlId, "{crlId}", false);
99
+ b.bp("/crl/{crlId}/enable");
100
+ b.p("crlId", () => input.crlId, "{crlId}", false);
157
101
  let body;
158
- return new __HttpRequest({
159
- protocol,
160
- hostname,
161
- port,
162
- method: "POST",
163
- headers,
164
- path: resolvedPath,
165
- body,
166
- });
102
+ b.m("POST").h(headers).b(body);
103
+ return b.build();
167
104
  };
168
105
  export const se_EnableProfileCommand = async (input, context) => {
169
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
106
+ const b = rb(input, context);
170
107
  const headers = {};
171
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/profile/{profileId}/enable";
172
- resolvedPath = __resolvedPath(resolvedPath, input, "profileId", () => input.profileId, "{profileId}", false);
108
+ b.bp("/profile/{profileId}/enable");
109
+ b.p("profileId", () => input.profileId, "{profileId}", false);
173
110
  let body;
174
- return new __HttpRequest({
175
- protocol,
176
- hostname,
177
- port,
178
- method: "POST",
179
- headers,
180
- path: resolvedPath,
181
- body,
182
- });
111
+ b.m("POST").h(headers).b(body);
112
+ return b.build();
183
113
  };
184
114
  export const se_EnableTrustAnchorCommand = async (input, context) => {
185
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
115
+ const b = rb(input, context);
186
116
  const headers = {};
187
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/trustanchor/{trustAnchorId}/enable";
188
- resolvedPath = __resolvedPath(resolvedPath, input, "trustAnchorId", () => input.trustAnchorId, "{trustAnchorId}", false);
117
+ b.bp("/trustanchor/{trustAnchorId}/enable");
118
+ b.p("trustAnchorId", () => input.trustAnchorId, "{trustAnchorId}", false);
189
119
  let body;
190
- return new __HttpRequest({
191
- protocol,
192
- hostname,
193
- port,
194
- method: "POST",
195
- headers,
196
- path: resolvedPath,
197
- body,
198
- });
120
+ b.m("POST").h(headers).b(body);
121
+ return b.build();
199
122
  };
200
123
  export const se_GetCrlCommand = async (input, context) => {
201
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
124
+ const b = rb(input, context);
202
125
  const headers = {};
203
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/crl/{crlId}";
204
- resolvedPath = __resolvedPath(resolvedPath, input, "crlId", () => input.crlId, "{crlId}", false);
126
+ b.bp("/crl/{crlId}");
127
+ b.p("crlId", () => input.crlId, "{crlId}", false);
205
128
  let body;
206
- return new __HttpRequest({
207
- protocol,
208
- hostname,
209
- port,
210
- method: "GET",
211
- headers,
212
- path: resolvedPath,
213
- body,
214
- });
129
+ b.m("GET").h(headers).b(body);
130
+ return b.build();
215
131
  };
216
132
  export const se_GetProfileCommand = async (input, context) => {
217
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
133
+ const b = rb(input, context);
218
134
  const headers = {};
219
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/profile/{profileId}";
220
- resolvedPath = __resolvedPath(resolvedPath, input, "profileId", () => input.profileId, "{profileId}", false);
135
+ b.bp("/profile/{profileId}");
136
+ b.p("profileId", () => input.profileId, "{profileId}", false);
221
137
  let body;
222
- return new __HttpRequest({
223
- protocol,
224
- hostname,
225
- port,
226
- method: "GET",
227
- headers,
228
- path: resolvedPath,
229
- body,
230
- });
138
+ b.m("GET").h(headers).b(body);
139
+ return b.build();
231
140
  };
232
141
  export const se_GetSubjectCommand = async (input, context) => {
233
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
142
+ const b = rb(input, context);
234
143
  const headers = {};
235
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/subject/{subjectId}";
236
- resolvedPath = __resolvedPath(resolvedPath, input, "subjectId", () => input.subjectId, "{subjectId}", false);
144
+ b.bp("/subject/{subjectId}");
145
+ b.p("subjectId", () => input.subjectId, "{subjectId}", false);
237
146
  let body;
238
- return new __HttpRequest({
239
- protocol,
240
- hostname,
241
- port,
242
- method: "GET",
243
- headers,
244
- path: resolvedPath,
245
- body,
246
- });
147
+ b.m("GET").h(headers).b(body);
148
+ return b.build();
247
149
  };
248
150
  export const se_GetTrustAnchorCommand = async (input, context) => {
249
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
151
+ const b = rb(input, context);
250
152
  const headers = {};
251
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/trustanchor/{trustAnchorId}";
252
- resolvedPath = __resolvedPath(resolvedPath, input, "trustAnchorId", () => input.trustAnchorId, "{trustAnchorId}", false);
153
+ b.bp("/trustanchor/{trustAnchorId}");
154
+ b.p("trustAnchorId", () => input.trustAnchorId, "{trustAnchorId}", false);
253
155
  let body;
254
- return new __HttpRequest({
255
- protocol,
256
- hostname,
257
- port,
258
- method: "GET",
259
- headers,
260
- path: resolvedPath,
261
- body,
262
- });
156
+ b.m("GET").h(headers).b(body);
157
+ return b.build();
263
158
  };
264
159
  export const se_ImportCrlCommand = async (input, context) => {
265
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
160
+ const b = rb(input, context);
266
161
  const headers = {
267
162
  "content-type": "application/json",
268
163
  };
269
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/crls";
164
+ b.bp("/crls");
270
165
  let body;
271
166
  body = JSON.stringify(take(input, {
272
167
  crlData: (_) => context.base64Encoder(_),
@@ -275,228 +170,146 @@ export const se_ImportCrlCommand = async (input, context) => {
275
170
  tags: (_) => _json(_),
276
171
  trustAnchorArn: [],
277
172
  }));
278
- return new __HttpRequest({
279
- protocol,
280
- hostname,
281
- port,
282
- method: "POST",
283
- headers,
284
- path: resolvedPath,
285
- body,
286
- });
173
+ b.m("POST").h(headers).b(body);
174
+ return b.build();
287
175
  };
288
176
  export const se_ListCrlsCommand = async (input, context) => {
289
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
177
+ const b = rb(input, context);
290
178
  const headers = {};
291
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/crls";
179
+ b.bp("/crls");
292
180
  const query = map({
293
- nextToken: [, input.nextToken],
294
- pageSize: [() => input.pageSize !== void 0, () => input.pageSize.toString()],
181
+ [_nT]: [, input[_nT]],
182
+ [_pS]: [() => input.pageSize !== void 0, () => input[_pS].toString()],
295
183
  });
296
184
  let body;
297
- return new __HttpRequest({
298
- protocol,
299
- hostname,
300
- port,
301
- method: "GET",
302
- headers,
303
- path: resolvedPath,
304
- query,
305
- body,
306
- });
185
+ b.m("GET").h(headers).q(query).b(body);
186
+ return b.build();
307
187
  };
308
188
  export const se_ListProfilesCommand = async (input, context) => {
309
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
189
+ const b = rb(input, context);
310
190
  const headers = {};
311
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/profiles";
191
+ b.bp("/profiles");
312
192
  const query = map({
313
- nextToken: [, input.nextToken],
314
- pageSize: [() => input.pageSize !== void 0, () => input.pageSize.toString()],
193
+ [_nT]: [, input[_nT]],
194
+ [_pS]: [() => input.pageSize !== void 0, () => input[_pS].toString()],
315
195
  });
316
196
  let body;
317
- return new __HttpRequest({
318
- protocol,
319
- hostname,
320
- port,
321
- method: "GET",
322
- headers,
323
- path: resolvedPath,
324
- query,
325
- body,
326
- });
197
+ b.m("GET").h(headers).q(query).b(body);
198
+ return b.build();
327
199
  };
328
200
  export const se_ListSubjectsCommand = async (input, context) => {
329
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
201
+ const b = rb(input, context);
330
202
  const headers = {};
331
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/subjects";
203
+ b.bp("/subjects");
332
204
  const query = map({
333
- nextToken: [, input.nextToken],
334
- pageSize: [() => input.pageSize !== void 0, () => input.pageSize.toString()],
205
+ [_nT]: [, input[_nT]],
206
+ [_pS]: [() => input.pageSize !== void 0, () => input[_pS].toString()],
335
207
  });
336
208
  let body;
337
- return new __HttpRequest({
338
- protocol,
339
- hostname,
340
- port,
341
- method: "GET",
342
- headers,
343
- path: resolvedPath,
344
- query,
345
- body,
346
- });
209
+ b.m("GET").h(headers).q(query).b(body);
210
+ return b.build();
347
211
  };
348
212
  export const se_ListTagsForResourceCommand = async (input, context) => {
349
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
213
+ const b = rb(input, context);
350
214
  const headers = {};
351
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListTagsForResource";
215
+ b.bp("/ListTagsForResource");
352
216
  const query = map({
353
- resourceArn: [, __expectNonNull(input.resourceArn, `resourceArn`)],
217
+ [_rA]: [, __expectNonNull(input[_rA], `resourceArn`)],
354
218
  });
355
219
  let body;
356
- return new __HttpRequest({
357
- protocol,
358
- hostname,
359
- port,
360
- method: "GET",
361
- headers,
362
- path: resolvedPath,
363
- query,
364
- body,
365
- });
220
+ b.m("GET").h(headers).q(query).b(body);
221
+ return b.build();
366
222
  };
367
223
  export const se_ListTrustAnchorsCommand = async (input, context) => {
368
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
224
+ const b = rb(input, context);
369
225
  const headers = {};
370
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/trustanchors";
226
+ b.bp("/trustanchors");
371
227
  const query = map({
372
- nextToken: [, input.nextToken],
373
- pageSize: [() => input.pageSize !== void 0, () => input.pageSize.toString()],
228
+ [_nT]: [, input[_nT]],
229
+ [_pS]: [() => input.pageSize !== void 0, () => input[_pS].toString()],
374
230
  });
375
231
  let body;
376
- return new __HttpRequest({
377
- protocol,
378
- hostname,
379
- port,
380
- method: "GET",
381
- headers,
382
- path: resolvedPath,
383
- query,
384
- body,
385
- });
232
+ b.m("GET").h(headers).q(query).b(body);
233
+ return b.build();
386
234
  };
387
235
  export const se_PutNotificationSettingsCommand = async (input, context) => {
388
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
236
+ const b = rb(input, context);
389
237
  const headers = {
390
238
  "content-type": "application/json",
391
239
  };
392
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/put-notifications-settings";
240
+ b.bp("/put-notifications-settings");
393
241
  let body;
394
242
  body = JSON.stringify(take(input, {
395
243
  notificationSettings: (_) => _json(_),
396
244
  trustAnchorId: [],
397
245
  }));
398
- return new __HttpRequest({
399
- protocol,
400
- hostname,
401
- port,
402
- method: "PATCH",
403
- headers,
404
- path: resolvedPath,
405
- body,
406
- });
246
+ b.m("PATCH").h(headers).b(body);
247
+ return b.build();
407
248
  };
408
249
  export const se_ResetNotificationSettingsCommand = async (input, context) => {
409
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
250
+ const b = rb(input, context);
410
251
  const headers = {
411
252
  "content-type": "application/json",
412
253
  };
413
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/reset-notifications-settings";
254
+ b.bp("/reset-notifications-settings");
414
255
  let body;
415
256
  body = JSON.stringify(take(input, {
416
257
  notificationSettingKeys: (_) => _json(_),
417
258
  trustAnchorId: [],
418
259
  }));
419
- return new __HttpRequest({
420
- protocol,
421
- hostname,
422
- port,
423
- method: "PATCH",
424
- headers,
425
- path: resolvedPath,
426
- body,
427
- });
260
+ b.m("PATCH").h(headers).b(body);
261
+ return b.build();
428
262
  };
429
263
  export const se_TagResourceCommand = async (input, context) => {
430
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
264
+ const b = rb(input, context);
431
265
  const headers = {
432
266
  "content-type": "application/json",
433
267
  };
434
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/TagResource";
268
+ b.bp("/TagResource");
435
269
  let body;
436
270
  body = JSON.stringify(take(input, {
437
271
  resourceArn: [],
438
272
  tags: (_) => _json(_),
439
273
  }));
440
- return new __HttpRequest({
441
- protocol,
442
- hostname,
443
- port,
444
- method: "POST",
445
- headers,
446
- path: resolvedPath,
447
- body,
448
- });
274
+ b.m("POST").h(headers).b(body);
275
+ return b.build();
449
276
  };
450
277
  export const se_UntagResourceCommand = async (input, context) => {
451
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
278
+ const b = rb(input, context);
452
279
  const headers = {
453
280
  "content-type": "application/json",
454
281
  };
455
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/UntagResource";
282
+ b.bp("/UntagResource");
456
283
  let body;
457
284
  body = JSON.stringify(take(input, {
458
285
  resourceArn: [],
459
286
  tagKeys: (_) => _json(_),
460
287
  }));
461
- return new __HttpRequest({
462
- protocol,
463
- hostname,
464
- port,
465
- method: "POST",
466
- headers,
467
- path: resolvedPath,
468
- body,
469
- });
288
+ b.m("POST").h(headers).b(body);
289
+ return b.build();
470
290
  };
471
291
  export const se_UpdateCrlCommand = async (input, context) => {
472
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
292
+ const b = rb(input, context);
473
293
  const headers = {
474
294
  "content-type": "application/json",
475
295
  };
476
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/crl/{crlId}";
477
- resolvedPath = __resolvedPath(resolvedPath, input, "crlId", () => input.crlId, "{crlId}", false);
296
+ b.bp("/crl/{crlId}");
297
+ b.p("crlId", () => input.crlId, "{crlId}", false);
478
298
  let body;
479
299
  body = JSON.stringify(take(input, {
480
300
  crlData: (_) => context.base64Encoder(_),
481
301
  name: [],
482
302
  }));
483
- return new __HttpRequest({
484
- protocol,
485
- hostname,
486
- port,
487
- method: "PATCH",
488
- headers,
489
- path: resolvedPath,
490
- body,
491
- });
303
+ b.m("PATCH").h(headers).b(body);
304
+ return b.build();
492
305
  };
493
306
  export const se_UpdateProfileCommand = async (input, context) => {
494
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
307
+ const b = rb(input, context);
495
308
  const headers = {
496
309
  "content-type": "application/json",
497
310
  };
498
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/profile/{profileId}";
499
- resolvedPath = __resolvedPath(resolvedPath, input, "profileId", () => input.profileId, "{profileId}", false);
311
+ b.bp("/profile/{profileId}");
312
+ b.p("profileId", () => input.profileId, "{profileId}", false);
500
313
  let body;
501
314
  body = JSON.stringify(take(input, {
502
315
  durationSeconds: [],
@@ -505,37 +318,23 @@ export const se_UpdateProfileCommand = async (input, context) => {
505
318
  roleArns: (_) => _json(_),
506
319
  sessionPolicy: [],
507
320
  }));
508
- return new __HttpRequest({
509
- protocol,
510
- hostname,
511
- port,
512
- method: "PATCH",
513
- headers,
514
- path: resolvedPath,
515
- body,
516
- });
321
+ b.m("PATCH").h(headers).b(body);
322
+ return b.build();
517
323
  };
518
324
  export const se_UpdateTrustAnchorCommand = async (input, context) => {
519
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
325
+ const b = rb(input, context);
520
326
  const headers = {
521
327
  "content-type": "application/json",
522
328
  };
523
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/trustanchor/{trustAnchorId}";
524
- resolvedPath = __resolvedPath(resolvedPath, input, "trustAnchorId", () => input.trustAnchorId, "{trustAnchorId}", false);
329
+ b.bp("/trustanchor/{trustAnchorId}");
330
+ b.p("trustAnchorId", () => input.trustAnchorId, "{trustAnchorId}", false);
525
331
  let body;
526
332
  body = JSON.stringify(take(input, {
527
333
  name: [],
528
334
  source: (_) => _json(_),
529
335
  }));
530
- return new __HttpRequest({
531
- protocol,
532
- hostname,
533
- port,
534
- method: "PATCH",
535
- headers,
536
- path: resolvedPath,
537
- body,
538
- });
336
+ b.m("PATCH").h(headers).b(body);
337
+ return b.build();
539
338
  };
540
339
  export const de_CreateProfileCommand = async (output, context) => {
541
340
  if (output.statusCode !== 201 && output.statusCode >= 300) {
@@ -1762,6 +1561,9 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
1762
1561
  value !== "" &&
1763
1562
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
1764
1563
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
1564
+ const _nT = "nextToken";
1565
+ const _pS = "pageSize";
1566
+ const _rA = "resourceArn";
1765
1567
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
1766
1568
  if (encoded.length) {
1767
1569
  return JSON.parse(encoded);