@aws-sdk/client-service-catalog-appregistry 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 +143 -324
  2. package/dist-es/protocols/Aws_restJson1.js +144 -325
  3. package/package.json +5 -4
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,56 +1,40 @@
1
- import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
2
- import { _json, collectBody, decorateServiceException as __decorateServiceException, 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, 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 { v4 as generateIdempotencyToken } from "uuid";
4
4
  import { ConflictException, InternalServerException, ResourceNotFoundException, ServiceQuotaExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
5
5
  import { ServiceCatalogAppRegistryServiceException as __BaseException } from "../models/ServiceCatalogAppRegistryServiceException";
6
6
  export const se_AssociateAttributeGroupCommand = 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 || ""}` +
10
- "/applications/{application}/attribute-groups/{attributeGroup}";
11
- resolvedPath = __resolvedPath(resolvedPath, input, "application", () => input.application, "{application}", false);
12
- resolvedPath = __resolvedPath(resolvedPath, input, "attributeGroup", () => input.attributeGroup, "{attributeGroup}", false);
9
+ b.bp("/applications/{application}/attribute-groups/{attributeGroup}");
10
+ b.p("application", () => input.application, "{application}", false);
11
+ b.p("attributeGroup", () => input.attributeGroup, "{attributeGroup}", false);
13
12
  let body;
14
- return new __HttpRequest({
15
- protocol,
16
- hostname,
17
- port,
18
- method: "PUT",
19
- headers,
20
- path: resolvedPath,
21
- body,
22
- });
13
+ b.m("PUT").h(headers).b(body);
14
+ return b.build();
23
15
  };
24
16
  export const se_AssociateResourceCommand = async (input, context) => {
25
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
17
+ const b = rb(input, context);
26
18
  const headers = {
27
19
  "content-type": "application/json",
28
20
  };
29
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
30
- "/applications/{application}/resources/{resourceType}/{resource}";
31
- resolvedPath = __resolvedPath(resolvedPath, input, "application", () => input.application, "{application}", false);
32
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceType", () => input.resourceType, "{resourceType}", false);
33
- resolvedPath = __resolvedPath(resolvedPath, input, "resource", () => input.resource, "{resource}", false);
21
+ b.bp("/applications/{application}/resources/{resourceType}/{resource}");
22
+ b.p("application", () => input.application, "{application}", false);
23
+ b.p("resourceType", () => input.resourceType, "{resourceType}", false);
24
+ b.p("resource", () => input.resource, "{resource}", false);
34
25
  let body;
35
26
  body = JSON.stringify(take(input, {
36
27
  options: (_) => _json(_),
37
28
  }));
38
- return new __HttpRequest({
39
- protocol,
40
- hostname,
41
- port,
42
- method: "PUT",
43
- headers,
44
- path: resolvedPath,
45
- body,
46
- });
29
+ b.m("PUT").h(headers).b(body);
30
+ return b.build();
47
31
  };
48
32
  export const se_CreateApplicationCommand = async (input, context) => {
49
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
33
+ const b = rb(input, context);
50
34
  const headers = {
51
35
  "content-type": "application/json",
52
36
  };
53
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/applications";
37
+ b.bp("/applications");
54
38
  let body;
55
39
  body = JSON.stringify(take(input, {
56
40
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -58,22 +42,15 @@ export const se_CreateApplicationCommand = async (input, context) => {
58
42
  name: [],
59
43
  tags: (_) => _json(_),
60
44
  }));
61
- return new __HttpRequest({
62
- protocol,
63
- hostname,
64
- port,
65
- method: "POST",
66
- headers,
67
- path: resolvedPath,
68
- body,
69
- });
45
+ b.m("POST").h(headers).b(body);
46
+ return b.build();
70
47
  };
71
48
  export const se_CreateAttributeGroupCommand = async (input, context) => {
72
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
49
+ const b = rb(input, context);
73
50
  const headers = {
74
51
  "content-type": "application/json",
75
52
  };
76
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/attribute-groups";
53
+ b.bp("/attribute-groups");
77
54
  let body;
78
55
  body = JSON.stringify(take(input, {
79
56
  attributes: [],
@@ -82,409 +59,247 @@ export const se_CreateAttributeGroupCommand = async (input, context) => {
82
59
  name: [],
83
60
  tags: (_) => _json(_),
84
61
  }));
85
- return new __HttpRequest({
86
- protocol,
87
- hostname,
88
- port,
89
- method: "POST",
90
- headers,
91
- path: resolvedPath,
92
- body,
93
- });
62
+ b.m("POST").h(headers).b(body);
63
+ return b.build();
94
64
  };
95
65
  export const se_DeleteApplicationCommand = async (input, context) => {
96
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
66
+ const b = rb(input, context);
97
67
  const headers = {};
98
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/applications/{application}";
99
- resolvedPath = __resolvedPath(resolvedPath, input, "application", () => input.application, "{application}", false);
68
+ b.bp("/applications/{application}");
69
+ b.p("application", () => input.application, "{application}", false);
100
70
  let body;
101
- return new __HttpRequest({
102
- protocol,
103
- hostname,
104
- port,
105
- method: "DELETE",
106
- headers,
107
- path: resolvedPath,
108
- body,
109
- });
71
+ b.m("DELETE").h(headers).b(body);
72
+ return b.build();
110
73
  };
111
74
  export const se_DeleteAttributeGroupCommand = async (input, context) => {
112
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
75
+ const b = rb(input, context);
113
76
  const headers = {};
114
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/attribute-groups/{attributeGroup}";
115
- resolvedPath = __resolvedPath(resolvedPath, input, "attributeGroup", () => input.attributeGroup, "{attributeGroup}", false);
77
+ b.bp("/attribute-groups/{attributeGroup}");
78
+ b.p("attributeGroup", () => input.attributeGroup, "{attributeGroup}", false);
116
79
  let body;
117
- return new __HttpRequest({
118
- protocol,
119
- hostname,
120
- port,
121
- method: "DELETE",
122
- headers,
123
- path: resolvedPath,
124
- body,
125
- });
80
+ b.m("DELETE").h(headers).b(body);
81
+ return b.build();
126
82
  };
127
83
  export const se_DisassociateAttributeGroupCommand = async (input, context) => {
128
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
84
+ const b = rb(input, context);
129
85
  const headers = {};
130
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
131
- "/applications/{application}/attribute-groups/{attributeGroup}";
132
- resolvedPath = __resolvedPath(resolvedPath, input, "application", () => input.application, "{application}", false);
133
- resolvedPath = __resolvedPath(resolvedPath, input, "attributeGroup", () => input.attributeGroup, "{attributeGroup}", false);
86
+ b.bp("/applications/{application}/attribute-groups/{attributeGroup}");
87
+ b.p("application", () => input.application, "{application}", false);
88
+ b.p("attributeGroup", () => input.attributeGroup, "{attributeGroup}", false);
134
89
  let body;
135
- return new __HttpRequest({
136
- protocol,
137
- hostname,
138
- port,
139
- method: "DELETE",
140
- headers,
141
- path: resolvedPath,
142
- body,
143
- });
90
+ b.m("DELETE").h(headers).b(body);
91
+ return b.build();
144
92
  };
145
93
  export const se_DisassociateResourceCommand = async (input, context) => {
146
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
94
+ const b = rb(input, context);
147
95
  const headers = {};
148
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
149
- "/applications/{application}/resources/{resourceType}/{resource}";
150
- resolvedPath = __resolvedPath(resolvedPath, input, "application", () => input.application, "{application}", false);
151
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceType", () => input.resourceType, "{resourceType}", false);
152
- resolvedPath = __resolvedPath(resolvedPath, input, "resource", () => input.resource, "{resource}", false);
96
+ b.bp("/applications/{application}/resources/{resourceType}/{resource}");
97
+ b.p("application", () => input.application, "{application}", false);
98
+ b.p("resourceType", () => input.resourceType, "{resourceType}", false);
99
+ b.p("resource", () => input.resource, "{resource}", false);
153
100
  let body;
154
- return new __HttpRequest({
155
- protocol,
156
- hostname,
157
- port,
158
- method: "DELETE",
159
- headers,
160
- path: resolvedPath,
161
- body,
162
- });
101
+ b.m("DELETE").h(headers).b(body);
102
+ return b.build();
163
103
  };
164
104
  export const se_GetApplicationCommand = async (input, context) => {
165
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
105
+ const b = rb(input, context);
166
106
  const headers = {};
167
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/applications/{application}";
168
- resolvedPath = __resolvedPath(resolvedPath, input, "application", () => input.application, "{application}", false);
107
+ b.bp("/applications/{application}");
108
+ b.p("application", () => input.application, "{application}", false);
169
109
  let body;
170
- return new __HttpRequest({
171
- protocol,
172
- hostname,
173
- port,
174
- method: "GET",
175
- headers,
176
- path: resolvedPath,
177
- body,
178
- });
110
+ b.m("GET").h(headers).b(body);
111
+ return b.build();
179
112
  };
180
113
  export const se_GetAssociatedResourceCommand = async (input, context) => {
181
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
114
+ const b = rb(input, context);
182
115
  const headers = {};
183
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
184
- "/applications/{application}/resources/{resourceType}/{resource}";
185
- resolvedPath = __resolvedPath(resolvedPath, input, "application", () => input.application, "{application}", false);
186
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceType", () => input.resourceType, "{resourceType}", false);
187
- resolvedPath = __resolvedPath(resolvedPath, input, "resource", () => input.resource, "{resource}", false);
116
+ b.bp("/applications/{application}/resources/{resourceType}/{resource}");
117
+ b.p("application", () => input.application, "{application}", false);
118
+ b.p("resourceType", () => input.resourceType, "{resourceType}", false);
119
+ b.p("resource", () => input.resource, "{resource}", false);
188
120
  const query = map({
189
- nextToken: [, input.nextToken],
190
- resourceTagStatus: [
191
- () => input.resourceTagStatus !== void 0,
192
- () => (input.resourceTagStatus || []).map((_entry) => _entry),
193
- ],
194
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
121
+ [_nT]: [, input[_nT]],
122
+ [_rTS]: [() => input.resourceTagStatus !== void 0, () => (input[_rTS] || []).map((_entry) => _entry)],
123
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
195
124
  });
196
125
  let body;
197
- return new __HttpRequest({
198
- protocol,
199
- hostname,
200
- port,
201
- method: "GET",
202
- headers,
203
- path: resolvedPath,
204
- query,
205
- body,
206
- });
126
+ b.m("GET").h(headers).q(query).b(body);
127
+ return b.build();
207
128
  };
208
129
  export const se_GetAttributeGroupCommand = async (input, context) => {
209
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
130
+ const b = rb(input, context);
210
131
  const headers = {};
211
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/attribute-groups/{attributeGroup}";
212
- resolvedPath = __resolvedPath(resolvedPath, input, "attributeGroup", () => input.attributeGroup, "{attributeGroup}", false);
132
+ b.bp("/attribute-groups/{attributeGroup}");
133
+ b.p("attributeGroup", () => input.attributeGroup, "{attributeGroup}", false);
213
134
  let body;
214
- return new __HttpRequest({
215
- protocol,
216
- hostname,
217
- port,
218
- method: "GET",
219
- headers,
220
- path: resolvedPath,
221
- body,
222
- });
135
+ b.m("GET").h(headers).b(body);
136
+ return b.build();
223
137
  };
224
138
  export const se_GetConfigurationCommand = async (input, context) => {
225
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
139
+ const b = rb(input, context);
226
140
  const headers = {
227
141
  "content-type": "application/json",
228
142
  };
229
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/configuration";
143
+ b.bp("/configuration");
230
144
  let body;
231
145
  body = "";
232
- return new __HttpRequest({
233
- protocol,
234
- hostname,
235
- port,
236
- method: "GET",
237
- headers,
238
- path: resolvedPath,
239
- body,
240
- });
146
+ b.m("GET").h(headers).b(body);
147
+ return b.build();
241
148
  };
242
149
  export const se_ListApplicationsCommand = async (input, context) => {
243
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
150
+ const b = rb(input, context);
244
151
  const headers = {};
245
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/applications";
152
+ b.bp("/applications");
246
153
  const query = map({
247
- nextToken: [, input.nextToken],
248
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
154
+ [_nT]: [, input[_nT]],
155
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
249
156
  });
250
157
  let body;
251
- return new __HttpRequest({
252
- protocol,
253
- hostname,
254
- port,
255
- method: "GET",
256
- headers,
257
- path: resolvedPath,
258
- query,
259
- body,
260
- });
158
+ b.m("GET").h(headers).q(query).b(body);
159
+ return b.build();
261
160
  };
262
161
  export const se_ListAssociatedAttributeGroupsCommand = async (input, context) => {
263
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
162
+ const b = rb(input, context);
264
163
  const headers = {};
265
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
266
- "/applications/{application}/attribute-groups";
267
- resolvedPath = __resolvedPath(resolvedPath, input, "application", () => input.application, "{application}", false);
164
+ b.bp("/applications/{application}/attribute-groups");
165
+ b.p("application", () => input.application, "{application}", false);
268
166
  const query = map({
269
- nextToken: [, input.nextToken],
270
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
167
+ [_nT]: [, input[_nT]],
168
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
271
169
  });
272
170
  let body;
273
- return new __HttpRequest({
274
- protocol,
275
- hostname,
276
- port,
277
- method: "GET",
278
- headers,
279
- path: resolvedPath,
280
- query,
281
- body,
282
- });
171
+ b.m("GET").h(headers).q(query).b(body);
172
+ return b.build();
283
173
  };
284
174
  export const se_ListAssociatedResourcesCommand = async (input, context) => {
285
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
175
+ const b = rb(input, context);
286
176
  const headers = {};
287
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/applications/{application}/resources";
288
- resolvedPath = __resolvedPath(resolvedPath, input, "application", () => input.application, "{application}", false);
177
+ b.bp("/applications/{application}/resources");
178
+ b.p("application", () => input.application, "{application}", false);
289
179
  const query = map({
290
- nextToken: [, input.nextToken],
291
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
180
+ [_nT]: [, input[_nT]],
181
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
292
182
  });
293
183
  let body;
294
- return new __HttpRequest({
295
- protocol,
296
- hostname,
297
- port,
298
- method: "GET",
299
- headers,
300
- path: resolvedPath,
301
- query,
302
- body,
303
- });
184
+ b.m("GET").h(headers).q(query).b(body);
185
+ return b.build();
304
186
  };
305
187
  export const se_ListAttributeGroupsCommand = async (input, context) => {
306
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
188
+ const b = rb(input, context);
307
189
  const headers = {};
308
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/attribute-groups";
190
+ b.bp("/attribute-groups");
309
191
  const query = map({
310
- nextToken: [, input.nextToken],
311
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
192
+ [_nT]: [, input[_nT]],
193
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
312
194
  });
313
195
  let body;
314
- return new __HttpRequest({
315
- protocol,
316
- hostname,
317
- port,
318
- method: "GET",
319
- headers,
320
- path: resolvedPath,
321
- query,
322
- body,
323
- });
196
+ b.m("GET").h(headers).q(query).b(body);
197
+ return b.build();
324
198
  };
325
199
  export const se_ListAttributeGroupsForApplicationCommand = async (input, context) => {
326
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
200
+ const b = rb(input, context);
327
201
  const headers = {};
328
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
329
- "/applications/{application}/attribute-group-details";
330
- resolvedPath = __resolvedPath(resolvedPath, input, "application", () => input.application, "{application}", false);
202
+ b.bp("/applications/{application}/attribute-group-details");
203
+ b.p("application", () => input.application, "{application}", false);
331
204
  const query = map({
332
- nextToken: [, input.nextToken],
333
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
205
+ [_nT]: [, input[_nT]],
206
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
334
207
  });
335
208
  let body;
336
- return new __HttpRequest({
337
- protocol,
338
- hostname,
339
- port,
340
- method: "GET",
341
- headers,
342
- path: resolvedPath,
343
- query,
344
- body,
345
- });
209
+ b.m("GET").h(headers).q(query).b(body);
210
+ return b.build();
346
211
  };
347
212
  export const se_ListTagsForResourceCommand = async (input, context) => {
348
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
213
+ const b = rb(input, context);
349
214
  const headers = {};
350
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
351
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
215
+ b.bp("/tags/{resourceArn}");
216
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
352
217
  let body;
353
- return new __HttpRequest({
354
- protocol,
355
- hostname,
356
- port,
357
- method: "GET",
358
- headers,
359
- path: resolvedPath,
360
- body,
361
- });
218
+ b.m("GET").h(headers).b(body);
219
+ return b.build();
362
220
  };
363
221
  export const se_PutConfigurationCommand = async (input, context) => {
364
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
222
+ const b = rb(input, context);
365
223
  const headers = {
366
224
  "content-type": "application/json",
367
225
  };
368
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/configuration";
226
+ b.bp("/configuration");
369
227
  let body;
370
228
  body = JSON.stringify(take(input, {
371
229
  configuration: (_) => _json(_),
372
230
  }));
373
- return new __HttpRequest({
374
- protocol,
375
- hostname,
376
- port,
377
- method: "PUT",
378
- headers,
379
- path: resolvedPath,
380
- body,
381
- });
231
+ b.m("PUT").h(headers).b(body);
232
+ return b.build();
382
233
  };
383
234
  export const se_SyncResourceCommand = async (input, context) => {
384
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
235
+ const b = rb(input, context);
385
236
  const headers = {};
386
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sync/{resourceType}/{resource}";
387
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceType", () => input.resourceType, "{resourceType}", false);
388
- resolvedPath = __resolvedPath(resolvedPath, input, "resource", () => input.resource, "{resource}", false);
237
+ b.bp("/sync/{resourceType}/{resource}");
238
+ b.p("resourceType", () => input.resourceType, "{resourceType}", false);
239
+ b.p("resource", () => input.resource, "{resource}", false);
389
240
  let body;
390
- return new __HttpRequest({
391
- protocol,
392
- hostname,
393
- port,
394
- method: "POST",
395
- headers,
396
- path: resolvedPath,
397
- body,
398
- });
241
+ b.m("POST").h(headers).b(body);
242
+ return b.build();
399
243
  };
400
244
  export const se_TagResourceCommand = async (input, context) => {
401
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
245
+ const b = rb(input, context);
402
246
  const headers = {
403
247
  "content-type": "application/json",
404
248
  };
405
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
406
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
249
+ b.bp("/tags/{resourceArn}");
250
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
407
251
  let body;
408
252
  body = JSON.stringify(take(input, {
409
253
  tags: (_) => _json(_),
410
254
  }));
411
- return new __HttpRequest({
412
- protocol,
413
- hostname,
414
- port,
415
- method: "POST",
416
- headers,
417
- path: resolvedPath,
418
- body,
419
- });
255
+ b.m("POST").h(headers).b(body);
256
+ return b.build();
420
257
  };
421
258
  export const se_UntagResourceCommand = async (input, context) => {
422
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
259
+ const b = rb(input, context);
423
260
  const headers = {};
424
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
425
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
261
+ b.bp("/tags/{resourceArn}");
262
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
426
263
  const query = map({
427
- tagKeys: [
264
+ [_tK]: [
428
265
  __expectNonNull(input.tagKeys, `tagKeys`) != null,
429
- () => (input.tagKeys || []).map((_entry) => _entry),
266
+ () => (input[_tK] || []).map((_entry) => _entry),
430
267
  ],
431
268
  });
432
269
  let body;
433
- return new __HttpRequest({
434
- protocol,
435
- hostname,
436
- port,
437
- method: "DELETE",
438
- headers,
439
- path: resolvedPath,
440
- query,
441
- body,
442
- });
270
+ b.m("DELETE").h(headers).q(query).b(body);
271
+ return b.build();
443
272
  };
444
273
  export const se_UpdateApplicationCommand = async (input, context) => {
445
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
274
+ const b = rb(input, context);
446
275
  const headers = {
447
276
  "content-type": "application/json",
448
277
  };
449
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/applications/{application}";
450
- resolvedPath = __resolvedPath(resolvedPath, input, "application", () => input.application, "{application}", false);
278
+ b.bp("/applications/{application}");
279
+ b.p("application", () => input.application, "{application}", false);
451
280
  let body;
452
281
  body = JSON.stringify(take(input, {
453
282
  description: [],
454
283
  name: [],
455
284
  }));
456
- return new __HttpRequest({
457
- protocol,
458
- hostname,
459
- port,
460
- method: "PATCH",
461
- headers,
462
- path: resolvedPath,
463
- body,
464
- });
285
+ b.m("PATCH").h(headers).b(body);
286
+ return b.build();
465
287
  };
466
288
  export const se_UpdateAttributeGroupCommand = async (input, context) => {
467
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
289
+ const b = rb(input, context);
468
290
  const headers = {
469
291
  "content-type": "application/json",
470
292
  };
471
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/attribute-groups/{attributeGroup}";
472
- resolvedPath = __resolvedPath(resolvedPath, input, "attributeGroup", () => input.attributeGroup, "{attributeGroup}", false);
293
+ b.bp("/attribute-groups/{attributeGroup}");
294
+ b.p("attributeGroup", () => input.attributeGroup, "{attributeGroup}", false);
473
295
  let body;
474
296
  body = JSON.stringify(take(input, {
475
297
  attributes: [],
476
298
  description: [],
477
299
  name: [],
478
300
  }));
479
- return new __HttpRequest({
480
- protocol,
481
- hostname,
482
- port,
483
- method: "PATCH",
484
- headers,
485
- path: resolvedPath,
486
- body,
487
- });
301
+ b.m("PATCH").h(headers).b(body);
302
+ return b.build();
488
303
  };
489
304
  export const de_AssociateAttributeGroupCommand = async (output, context) => {
490
305
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -1637,6 +1452,10 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
1637
1452
  value !== "" &&
1638
1453
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
1639
1454
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
1455
+ const _mR = "maxResults";
1456
+ const _nT = "nextToken";
1457
+ const _rTS = "resourceTagStatus";
1458
+ const _tK = "tagKeys";
1640
1459
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
1641
1460
  if (encoded.length) {
1642
1461
  return JSON.parse(encoded);