@aws-sdk/client-datazone 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 +689 -1468
  2. package/dist-es/protocols/Aws_restJson1.js +690 -1469
  3. package/package.json +5 -4
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,21 +1,20 @@
1
1
  import { awsExpectUnion as __expectUnion } from "@aws-sdk/core";
2
- import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
3
- import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, map, parseEpochTimestamp as __parseEpochTimestamp, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, resolvedPath as __resolvedPath, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
2
+ import { requestBuilder as rb } from "@smithy/core";
3
+ import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, map, parseEpochTimestamp as __parseEpochTimestamp, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
4
4
  import { v4 as generateIdempotencyToken } from "uuid";
5
5
  import { DataZoneServiceException as __BaseException } from "../models/DataZoneServiceException";
6
6
  import { AccessDeniedException, ConflictException, InternalServerException, ResourceNotFoundException, ServiceQuotaExceededException, ThrottlingException, UnauthorizedException, ValidationException, } from "../models/models_0";
7
7
  import { FilterClause, } from "../models/models_1";
8
8
  export const se_AcceptPredictionsCommand = async (input, context) => {
9
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
9
+ const b = rb(input, context);
10
10
  const headers = {
11
11
  "content-type": "application/json",
12
12
  };
13
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
14
- "/v2/domains/{domainIdentifier}/assets/{identifier}/accept-predictions";
15
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
16
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
13
+ b.bp("/v2/domains/{domainIdentifier}/assets/{identifier}/accept-predictions");
14
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
15
+ b.p("identifier", () => input.identifier, "{identifier}", false);
17
16
  const query = map({
18
- revision: [, input.revision],
17
+ [_r]: [, input[_r]],
19
18
  });
20
19
  let body;
21
20
  body = JSON.stringify(take(input, {
@@ -23,65 +22,41 @@ export const se_AcceptPredictionsCommand = async (input, context) => {
23
22
  acceptRule: (_) => se_AcceptRule(_, context),
24
23
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
25
24
  }));
26
- return new __HttpRequest({
27
- protocol,
28
- hostname,
29
- port,
30
- method: "PUT",
31
- headers,
32
- path: resolvedPath,
33
- query,
34
- body,
35
- });
25
+ b.m("PUT").h(headers).q(query).b(body);
26
+ return b.build();
36
27
  };
37
28
  export const se_AcceptSubscriptionRequestCommand = async (input, context) => {
38
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
29
+ const b = rb(input, context);
39
30
  const headers = {
40
31
  "content-type": "application/json",
41
32
  };
42
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
43
- "/v2/domains/{domainIdentifier}/subscription-requests/{identifier}/accept";
44
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
45
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
33
+ b.bp("/v2/domains/{domainIdentifier}/subscription-requests/{identifier}/accept");
34
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
35
+ b.p("identifier", () => input.identifier, "{identifier}", false);
46
36
  let body;
47
37
  body = JSON.stringify(take(input, {
48
38
  decisionComment: [],
49
39
  }));
50
- return new __HttpRequest({
51
- protocol,
52
- hostname,
53
- port,
54
- method: "PUT",
55
- headers,
56
- path: resolvedPath,
57
- body,
58
- });
40
+ b.m("PUT").h(headers).b(body);
41
+ return b.build();
59
42
  };
60
43
  export const se_CancelSubscriptionCommand = async (input, context) => {
61
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
44
+ const b = rb(input, context);
62
45
  const headers = {};
63
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
64
- "/v2/domains/{domainIdentifier}/subscriptions/{identifier}/cancel";
65
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
66
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
46
+ b.bp("/v2/domains/{domainIdentifier}/subscriptions/{identifier}/cancel");
47
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
48
+ b.p("identifier", () => input.identifier, "{identifier}", false);
67
49
  let body;
68
- return new __HttpRequest({
69
- protocol,
70
- hostname,
71
- port,
72
- method: "PUT",
73
- headers,
74
- path: resolvedPath,
75
- body,
76
- });
50
+ b.m("PUT").h(headers).b(body);
51
+ return b.build();
77
52
  };
78
53
  export const se_CreateAssetCommand = async (input, context) => {
79
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
54
+ const b = rb(input, context);
80
55
  const headers = {
81
56
  "content-type": "application/json",
82
57
  };
83
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/domains/{domainIdentifier}/assets";
84
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
58
+ b.bp("/v2/domains/{domainIdentifier}/assets");
59
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
85
60
  let body;
86
61
  body = JSON.stringify(take(input, {
87
62
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -95,25 +70,17 @@ export const se_CreateAssetCommand = async (input, context) => {
95
70
  typeIdentifier: [],
96
71
  typeRevision: [],
97
72
  }));
98
- return new __HttpRequest({
99
- protocol,
100
- hostname,
101
- port,
102
- method: "POST",
103
- headers,
104
- path: resolvedPath,
105
- body,
106
- });
73
+ b.m("POST").h(headers).b(body);
74
+ return b.build();
107
75
  };
108
76
  export const se_CreateAssetRevisionCommand = async (input, context) => {
109
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
77
+ const b = rb(input, context);
110
78
  const headers = {
111
79
  "content-type": "application/json",
112
80
  };
113
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
114
- "/v2/domains/{domainIdentifier}/assets/{identifier}/revisions";
115
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
116
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
81
+ b.bp("/v2/domains/{domainIdentifier}/assets/{identifier}/revisions");
82
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
83
+ b.p("identifier", () => input.identifier, "{identifier}", false);
117
84
  let body;
118
85
  body = JSON.stringify(take(input, {
119
86
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -124,24 +91,16 @@ export const se_CreateAssetRevisionCommand = async (input, context) => {
124
91
  predictionConfiguration: (_) => _json(_),
125
92
  typeRevision: [],
126
93
  }));
127
- return new __HttpRequest({
128
- protocol,
129
- hostname,
130
- port,
131
- method: "POST",
132
- headers,
133
- path: resolvedPath,
134
- body,
135
- });
94
+ b.m("POST").h(headers).b(body);
95
+ return b.build();
136
96
  };
137
97
  export const se_CreateAssetTypeCommand = async (input, context) => {
138
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
98
+ const b = rb(input, context);
139
99
  const headers = {
140
100
  "content-type": "application/json",
141
101
  };
142
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
143
- "/v2/domains/{domainIdentifier}/asset-types";
144
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
102
+ b.bp("/v2/domains/{domainIdentifier}/asset-types");
103
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
145
104
  let body;
146
105
  body = JSON.stringify(take(input, {
147
106
  description: [],
@@ -149,24 +108,16 @@ export const se_CreateAssetTypeCommand = async (input, context) => {
149
108
  name: [],
150
109
  owningProjectIdentifier: [],
151
110
  }));
152
- return new __HttpRequest({
153
- protocol,
154
- hostname,
155
- port,
156
- method: "POST",
157
- headers,
158
- path: resolvedPath,
159
- body,
160
- });
111
+ b.m("POST").h(headers).b(body);
112
+ return b.build();
161
113
  };
162
114
  export const se_CreateDataSourceCommand = async (input, context) => {
163
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
115
+ const b = rb(input, context);
164
116
  const headers = {
165
117
  "content-type": "application/json",
166
118
  };
167
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
168
- "/v2/domains/{domainIdentifier}/data-sources";
169
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
119
+ b.bp("/v2/domains/{domainIdentifier}/data-sources");
120
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
170
121
  let body;
171
122
  body = JSON.stringify(take(input, {
172
123
  assetFormsInput: (_) => _json(_),
@@ -182,22 +133,15 @@ export const se_CreateDataSourceCommand = async (input, context) => {
182
133
  schedule: (_) => _json(_),
183
134
  type: [],
184
135
  }));
185
- return new __HttpRequest({
186
- protocol,
187
- hostname,
188
- port,
189
- method: "POST",
190
- headers,
191
- path: resolvedPath,
192
- body,
193
- });
136
+ b.m("POST").h(headers).b(body);
137
+ return b.build();
194
138
  };
195
139
  export const se_CreateDomainCommand = async (input, context) => {
196
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
140
+ const b = rb(input, context);
197
141
  const headers = {
198
142
  "content-type": "application/json",
199
143
  };
200
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/domains";
144
+ b.bp("/v2/domains");
201
145
  let body;
202
146
  body = JSON.stringify(take(input, {
203
147
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -208,24 +152,16 @@ export const se_CreateDomainCommand = async (input, context) => {
208
152
  singleSignOn: (_) => _json(_),
209
153
  tags: (_) => _json(_),
210
154
  }));
211
- return new __HttpRequest({
212
- protocol,
213
- hostname,
214
- port,
215
- method: "POST",
216
- headers,
217
- path: resolvedPath,
218
- body,
219
- });
155
+ b.m("POST").h(headers).b(body);
156
+ return b.build();
220
157
  };
221
158
  export const se_CreateEnvironmentCommand = async (input, context) => {
222
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
159
+ const b = rb(input, context);
223
160
  const headers = {
224
161
  "content-type": "application/json",
225
162
  };
226
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
227
- "/v2/domains/{domainIdentifier}/environments";
228
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
163
+ b.bp("/v2/domains/{domainIdentifier}/environments");
164
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
229
165
  let body;
230
166
  body = JSON.stringify(take(input, {
231
167
  description: [],
@@ -235,24 +171,16 @@ export const se_CreateEnvironmentCommand = async (input, context) => {
235
171
  projectIdentifier: [],
236
172
  userParameters: (_) => _json(_),
237
173
  }));
238
- return new __HttpRequest({
239
- protocol,
240
- hostname,
241
- port,
242
- method: "POST",
243
- headers,
244
- path: resolvedPath,
245
- body,
246
- });
174
+ b.m("POST").h(headers).b(body);
175
+ return b.build();
247
176
  };
248
177
  export const se_CreateEnvironmentProfileCommand = async (input, context) => {
249
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
178
+ const b = rb(input, context);
250
179
  const headers = {
251
180
  "content-type": "application/json",
252
181
  };
253
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
254
- "/v2/domains/{domainIdentifier}/environment-profiles";
255
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
182
+ b.bp("/v2/domains/{domainIdentifier}/environment-profiles");
183
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
256
184
  let body;
257
185
  body = JSON.stringify(take(input, {
258
186
  awsAccountId: [],
@@ -263,23 +191,16 @@ export const se_CreateEnvironmentProfileCommand = async (input, context) => {
263
191
  projectIdentifier: [],
264
192
  userParameters: (_) => _json(_),
265
193
  }));
266
- return new __HttpRequest({
267
- protocol,
268
- hostname,
269
- port,
270
- method: "POST",
271
- headers,
272
- path: resolvedPath,
273
- body,
274
- });
194
+ b.m("POST").h(headers).b(body);
195
+ return b.build();
275
196
  };
276
197
  export const se_CreateFormTypeCommand = async (input, context) => {
277
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
198
+ const b = rb(input, context);
278
199
  const headers = {
279
200
  "content-type": "application/json",
280
201
  };
281
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/domains/{domainIdentifier}/form-types";
282
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
202
+ b.bp("/v2/domains/{domainIdentifier}/form-types");
203
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
283
204
  let body;
284
205
  body = JSON.stringify(take(input, {
285
206
  description: [],
@@ -288,23 +209,16 @@ export const se_CreateFormTypeCommand = async (input, context) => {
288
209
  owningProjectIdentifier: [],
289
210
  status: [],
290
211
  }));
291
- return new __HttpRequest({
292
- protocol,
293
- hostname,
294
- port,
295
- method: "POST",
296
- headers,
297
- path: resolvedPath,
298
- body,
299
- });
212
+ b.m("POST").h(headers).b(body);
213
+ return b.build();
300
214
  };
301
215
  export const se_CreateGlossaryCommand = async (input, context) => {
302
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
216
+ const b = rb(input, context);
303
217
  const headers = {
304
218
  "content-type": "application/json",
305
219
  };
306
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/domains/{domainIdentifier}/glossaries";
307
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
220
+ b.bp("/v2/domains/{domainIdentifier}/glossaries");
221
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
308
222
  let body;
309
223
  body = JSON.stringify(take(input, {
310
224
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -313,24 +227,16 @@ export const se_CreateGlossaryCommand = async (input, context) => {
313
227
  owningProjectIdentifier: [],
314
228
  status: [],
315
229
  }));
316
- return new __HttpRequest({
317
- protocol,
318
- hostname,
319
- port,
320
- method: "POST",
321
- headers,
322
- path: resolvedPath,
323
- body,
324
- });
230
+ b.m("POST").h(headers).b(body);
231
+ return b.build();
325
232
  };
326
233
  export const se_CreateGlossaryTermCommand = async (input, context) => {
327
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
234
+ const b = rb(input, context);
328
235
  const headers = {
329
236
  "content-type": "application/json",
330
237
  };
331
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
332
- "/v2/domains/{domainIdentifier}/glossary-terms";
333
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
238
+ b.bp("/v2/domains/{domainIdentifier}/glossary-terms");
239
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
334
240
  let body;
335
241
  body = JSON.stringify(take(input, {
336
242
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -341,47 +247,31 @@ export const se_CreateGlossaryTermCommand = async (input, context) => {
341
247
  status: [],
342
248
  termRelations: (_) => _json(_),
343
249
  }));
344
- return new __HttpRequest({
345
- protocol,
346
- hostname,
347
- port,
348
- method: "POST",
349
- headers,
350
- path: resolvedPath,
351
- body,
352
- });
250
+ b.m("POST").h(headers).b(body);
251
+ return b.build();
353
252
  };
354
253
  export const se_CreateGroupProfileCommand = async (input, context) => {
355
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
254
+ const b = rb(input, context);
356
255
  const headers = {
357
256
  "content-type": "application/json",
358
257
  };
359
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
360
- "/v2/domains/{domainIdentifier}/group-profiles";
361
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
258
+ b.bp("/v2/domains/{domainIdentifier}/group-profiles");
259
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
362
260
  let body;
363
261
  body = JSON.stringify(take(input, {
364
262
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
365
263
  groupIdentifier: [],
366
264
  }));
367
- return new __HttpRequest({
368
- protocol,
369
- hostname,
370
- port,
371
- method: "POST",
372
- headers,
373
- path: resolvedPath,
374
- body,
375
- });
265
+ b.m("POST").h(headers).b(body);
266
+ return b.build();
376
267
  };
377
268
  export const se_CreateListingChangeSetCommand = async (input, context) => {
378
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
269
+ const b = rb(input, context);
379
270
  const headers = {
380
271
  "content-type": "application/json",
381
272
  };
382
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
383
- "/v2/domains/{domainIdentifier}/listings/change-set";
384
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
273
+ b.bp("/v2/domains/{domainIdentifier}/listings/change-set");
274
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
385
275
  let body;
386
276
  body = JSON.stringify(take(input, {
387
277
  action: [],
@@ -390,71 +280,48 @@ export const se_CreateListingChangeSetCommand = async (input, context) => {
390
280
  entityRevision: [],
391
281
  entityType: [],
392
282
  }));
393
- return new __HttpRequest({
394
- protocol,
395
- hostname,
396
- port,
397
- method: "POST",
398
- headers,
399
- path: resolvedPath,
400
- body,
401
- });
283
+ b.m("POST").h(headers).b(body);
284
+ return b.build();
402
285
  };
403
286
  export const se_CreateProjectCommand = async (input, context) => {
404
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
287
+ const b = rb(input, context);
405
288
  const headers = {
406
289
  "content-type": "application/json",
407
290
  };
408
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/domains/{domainIdentifier}/projects";
409
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
291
+ b.bp("/v2/domains/{domainIdentifier}/projects");
292
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
410
293
  let body;
411
294
  body = JSON.stringify(take(input, {
412
295
  description: [],
413
296
  glossaryTerms: (_) => _json(_),
414
297
  name: [],
415
298
  }));
416
- return new __HttpRequest({
417
- protocol,
418
- hostname,
419
- port,
420
- method: "POST",
421
- headers,
422
- path: resolvedPath,
423
- body,
424
- });
299
+ b.m("POST").h(headers).b(body);
300
+ return b.build();
425
301
  };
426
302
  export const se_CreateProjectMembershipCommand = async (input, context) => {
427
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
303
+ const b = rb(input, context);
428
304
  const headers = {
429
305
  "content-type": "application/json",
430
306
  };
431
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
432
- "/v2/domains/{domainIdentifier}/projects/{projectIdentifier}/createMembership";
433
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
434
- resolvedPath = __resolvedPath(resolvedPath, input, "projectIdentifier", () => input.projectIdentifier, "{projectIdentifier}", false);
307
+ b.bp("/v2/domains/{domainIdentifier}/projects/{projectIdentifier}/createMembership");
308
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
309
+ b.p("projectIdentifier", () => input.projectIdentifier, "{projectIdentifier}", false);
435
310
  let body;
436
311
  body = JSON.stringify(take(input, {
437
312
  designation: [],
438
313
  member: (_) => _json(_),
439
314
  }));
440
- return new __HttpRequest({
441
- protocol,
442
- hostname,
443
- port,
444
- method: "POST",
445
- headers,
446
- path: resolvedPath,
447
- body,
448
- });
315
+ b.m("POST").h(headers).b(body);
316
+ return b.build();
449
317
  };
450
318
  export const se_CreateSubscriptionGrantCommand = async (input, context) => {
451
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
319
+ const b = rb(input, context);
452
320
  const headers = {
453
321
  "content-type": "application/json",
454
322
  };
455
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
456
- "/v2/domains/{domainIdentifier}/subscription-grants";
457
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
323
+ b.bp("/v2/domains/{domainIdentifier}/subscription-grants");
324
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
458
325
  let body;
459
326
  body = JSON.stringify(take(input, {
460
327
  assetTargetNames: (_) => _json(_),
@@ -463,24 +330,16 @@ export const se_CreateSubscriptionGrantCommand = async (input, context) => {
463
330
  grantedEntity: (_) => _json(_),
464
331
  subscriptionTargetIdentifier: [],
465
332
  }));
466
- return new __HttpRequest({
467
- protocol,
468
- hostname,
469
- port,
470
- method: "POST",
471
- headers,
472
- path: resolvedPath,
473
- body,
474
- });
333
+ b.m("POST").h(headers).b(body);
334
+ return b.build();
475
335
  };
476
336
  export const se_CreateSubscriptionRequestCommand = async (input, context) => {
477
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
337
+ const b = rb(input, context);
478
338
  const headers = {
479
339
  "content-type": "application/json",
480
340
  };
481
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
482
- "/v2/domains/{domainIdentifier}/subscription-requests";
483
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
341
+ b.bp("/v2/domains/{domainIdentifier}/subscription-requests");
342
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
484
343
  let body;
485
344
  body = JSON.stringify(take(input, {
486
345
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -488,25 +347,17 @@ export const se_CreateSubscriptionRequestCommand = async (input, context) => {
488
347
  subscribedListings: (_) => _json(_),
489
348
  subscribedPrincipals: (_) => _json(_),
490
349
  }));
491
- return new __HttpRequest({
492
- protocol,
493
- hostname,
494
- port,
495
- method: "POST",
496
- headers,
497
- path: resolvedPath,
498
- body,
499
- });
350
+ b.m("POST").h(headers).b(body);
351
+ return b.build();
500
352
  };
501
353
  export const se_CreateSubscriptionTargetCommand = async (input, context) => {
502
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
354
+ const b = rb(input, context);
503
355
  const headers = {
504
356
  "content-type": "application/json",
505
357
  };
506
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
507
- "/v2/domains/{domainIdentifier}/environments/{environmentIdentifier}/subscription-targets";
508
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
509
- resolvedPath = __resolvedPath(resolvedPath, input, "environmentIdentifier", () => input.environmentIdentifier, "{environmentIdentifier}", false);
358
+ b.bp("/v2/domains/{domainIdentifier}/environments/{environmentIdentifier}/subscription-targets");
359
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
360
+ b.p("environmentIdentifier", () => input.environmentIdentifier, "{environmentIdentifier}", false);
510
361
  let body;
511
362
  body = JSON.stringify(take(input, {
512
363
  applicableAssetTypes: (_) => _json(_),
@@ -518,1175 +369,703 @@ export const se_CreateSubscriptionTargetCommand = async (input, context) => {
518
369
  subscriptionTargetConfig: (_) => _json(_),
519
370
  type: [],
520
371
  }));
521
- return new __HttpRequest({
522
- protocol,
523
- hostname,
524
- port,
525
- method: "POST",
526
- headers,
527
- path: resolvedPath,
528
- body,
529
- });
372
+ b.m("POST").h(headers).b(body);
373
+ return b.build();
530
374
  };
531
375
  export const se_CreateUserProfileCommand = async (input, context) => {
532
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
376
+ const b = rb(input, context);
533
377
  const headers = {
534
378
  "content-type": "application/json",
535
379
  };
536
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
537
- "/v2/domains/{domainIdentifier}/user-profiles";
538
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
380
+ b.bp("/v2/domains/{domainIdentifier}/user-profiles");
381
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
539
382
  let body;
540
383
  body = JSON.stringify(take(input, {
541
384
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
542
385
  userIdentifier: [],
543
386
  userType: [],
544
387
  }));
545
- return new __HttpRequest({
546
- protocol,
547
- hostname,
548
- port,
549
- method: "POST",
550
- headers,
551
- path: resolvedPath,
552
- body,
553
- });
388
+ b.m("POST").h(headers).b(body);
389
+ return b.build();
554
390
  };
555
391
  export const se_DeleteAssetCommand = async (input, context) => {
556
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
392
+ const b = rb(input, context);
557
393
  const headers = {};
558
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
559
- "/v2/domains/{domainIdentifier}/assets/{identifier}";
560
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
561
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
394
+ b.bp("/v2/domains/{domainIdentifier}/assets/{identifier}");
395
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
396
+ b.p("identifier", () => input.identifier, "{identifier}", false);
562
397
  let body;
563
- return new __HttpRequest({
564
- protocol,
565
- hostname,
566
- port,
567
- method: "DELETE",
568
- headers,
569
- path: resolvedPath,
570
- body,
571
- });
398
+ b.m("DELETE").h(headers).b(body);
399
+ return b.build();
572
400
  };
573
401
  export const se_DeleteAssetTypeCommand = async (input, context) => {
574
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
402
+ const b = rb(input, context);
575
403
  const headers = {};
576
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
577
- "/v2/domains/{domainIdentifier}/asset-types/{identifier}";
578
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
579
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
404
+ b.bp("/v2/domains/{domainIdentifier}/asset-types/{identifier}");
405
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
406
+ b.p("identifier", () => input.identifier, "{identifier}", false);
580
407
  let body;
581
- return new __HttpRequest({
582
- protocol,
583
- hostname,
584
- port,
585
- method: "DELETE",
586
- headers,
587
- path: resolvedPath,
588
- body,
589
- });
408
+ b.m("DELETE").h(headers).b(body);
409
+ return b.build();
590
410
  };
591
411
  export const se_DeleteDataSourceCommand = async (input, context) => {
592
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
412
+ const b = rb(input, context);
593
413
  const headers = {};
594
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
595
- "/v2/domains/{domainIdentifier}/data-sources/{identifier}";
596
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
597
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
414
+ b.bp("/v2/domains/{domainIdentifier}/data-sources/{identifier}");
415
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
416
+ b.p("identifier", () => input.identifier, "{identifier}", false);
598
417
  const query = map({
599
- clientToken: [, input.clientToken ?? generateIdempotencyToken()],
418
+ [_cT]: [, input[_cT] ?? generateIdempotencyToken()],
600
419
  });
601
420
  let body;
602
- return new __HttpRequest({
603
- protocol,
604
- hostname,
605
- port,
606
- method: "DELETE",
607
- headers,
608
- path: resolvedPath,
609
- query,
610
- body,
611
- });
421
+ b.m("DELETE").h(headers).q(query).b(body);
422
+ return b.build();
612
423
  };
613
424
  export const se_DeleteDomainCommand = async (input, context) => {
614
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
425
+ const b = rb(input, context);
615
426
  const headers = {};
616
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/domains/{identifier}";
617
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
427
+ b.bp("/v2/domains/{identifier}");
428
+ b.p("identifier", () => input.identifier, "{identifier}", false);
618
429
  const query = map({
619
- clientToken: [, input.clientToken ?? generateIdempotencyToken()],
430
+ [_cT]: [, input[_cT] ?? generateIdempotencyToken()],
620
431
  });
621
432
  let body;
622
- return new __HttpRequest({
623
- protocol,
624
- hostname,
625
- port,
626
- method: "DELETE",
627
- headers,
628
- path: resolvedPath,
629
- query,
630
- body,
631
- });
433
+ b.m("DELETE").h(headers).q(query).b(body);
434
+ return b.build();
632
435
  };
633
436
  export const se_DeleteEnvironmentCommand = async (input, context) => {
634
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
437
+ const b = rb(input, context);
635
438
  const headers = {};
636
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
637
- "/v2/domains/{domainIdentifier}/environments/{identifier}";
638
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
639
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
439
+ b.bp("/v2/domains/{domainIdentifier}/environments/{identifier}");
440
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
441
+ b.p("identifier", () => input.identifier, "{identifier}", false);
640
442
  let body;
641
- return new __HttpRequest({
642
- protocol,
643
- hostname,
644
- port,
645
- method: "DELETE",
646
- headers,
647
- path: resolvedPath,
648
- body,
649
- });
443
+ b.m("DELETE").h(headers).b(body);
444
+ return b.build();
650
445
  };
651
446
  export const se_DeleteEnvironmentBlueprintConfigurationCommand = async (input, context) => {
652
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
447
+ const b = rb(input, context);
653
448
  const headers = {};
654
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
655
- "/v2/domains/{domainIdentifier}/environment-blueprint-configurations/{environmentBlueprintIdentifier}";
656
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
657
- resolvedPath = __resolvedPath(resolvedPath, input, "environmentBlueprintIdentifier", () => input.environmentBlueprintIdentifier, "{environmentBlueprintIdentifier}", false);
449
+ b.bp("/v2/domains/{domainIdentifier}/environment-blueprint-configurations/{environmentBlueprintIdentifier}");
450
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
451
+ b.p("environmentBlueprintIdentifier", () => input.environmentBlueprintIdentifier, "{environmentBlueprintIdentifier}", false);
658
452
  let body;
659
- return new __HttpRequest({
660
- protocol,
661
- hostname,
662
- port,
663
- method: "DELETE",
664
- headers,
665
- path: resolvedPath,
666
- body,
667
- });
453
+ b.m("DELETE").h(headers).b(body);
454
+ return b.build();
668
455
  };
669
456
  export const se_DeleteEnvironmentProfileCommand = async (input, context) => {
670
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
457
+ const b = rb(input, context);
671
458
  const headers = {};
672
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
673
- "/v2/domains/{domainIdentifier}/environment-profiles/{identifier}";
674
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
675
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
459
+ b.bp("/v2/domains/{domainIdentifier}/environment-profiles/{identifier}");
460
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
461
+ b.p("identifier", () => input.identifier, "{identifier}", false);
676
462
  let body;
677
- return new __HttpRequest({
678
- protocol,
679
- hostname,
680
- port,
681
- method: "DELETE",
682
- headers,
683
- path: resolvedPath,
684
- body,
685
- });
463
+ b.m("DELETE").h(headers).b(body);
464
+ return b.build();
686
465
  };
687
466
  export const se_DeleteFormTypeCommand = async (input, context) => {
688
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
467
+ const b = rb(input, context);
689
468
  const headers = {};
690
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
691
- "/v2/domains/{domainIdentifier}/form-types/{formTypeIdentifier}";
692
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
693
- resolvedPath = __resolvedPath(resolvedPath, input, "formTypeIdentifier", () => input.formTypeIdentifier, "{formTypeIdentifier}", false);
469
+ b.bp("/v2/domains/{domainIdentifier}/form-types/{formTypeIdentifier}");
470
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
471
+ b.p("formTypeIdentifier", () => input.formTypeIdentifier, "{formTypeIdentifier}", false);
694
472
  let body;
695
- return new __HttpRequest({
696
- protocol,
697
- hostname,
698
- port,
699
- method: "DELETE",
700
- headers,
701
- path: resolvedPath,
702
- body,
703
- });
473
+ b.m("DELETE").h(headers).b(body);
474
+ return b.build();
704
475
  };
705
476
  export const se_DeleteGlossaryCommand = async (input, context) => {
706
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
477
+ const b = rb(input, context);
707
478
  const headers = {};
708
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
709
- "/v2/domains/{domainIdentifier}/glossaries/{identifier}";
710
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
711
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
479
+ b.bp("/v2/domains/{domainIdentifier}/glossaries/{identifier}");
480
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
481
+ b.p("identifier", () => input.identifier, "{identifier}", false);
712
482
  let body;
713
- return new __HttpRequest({
714
- protocol,
715
- hostname,
716
- port,
717
- method: "DELETE",
718
- headers,
719
- path: resolvedPath,
720
- body,
721
- });
483
+ b.m("DELETE").h(headers).b(body);
484
+ return b.build();
722
485
  };
723
486
  export const se_DeleteGlossaryTermCommand = async (input, context) => {
724
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
487
+ const b = rb(input, context);
725
488
  const headers = {};
726
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
727
- "/v2/domains/{domainIdentifier}/glossary-terms/{identifier}";
728
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
729
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
489
+ b.bp("/v2/domains/{domainIdentifier}/glossary-terms/{identifier}");
490
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
491
+ b.p("identifier", () => input.identifier, "{identifier}", false);
730
492
  let body;
731
- return new __HttpRequest({
732
- protocol,
733
- hostname,
734
- port,
735
- method: "DELETE",
736
- headers,
737
- path: resolvedPath,
738
- body,
739
- });
493
+ b.m("DELETE").h(headers).b(body);
494
+ return b.build();
740
495
  };
741
496
  export const se_DeleteListingCommand = async (input, context) => {
742
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
497
+ const b = rb(input, context);
743
498
  const headers = {};
744
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
745
- "/v2/domains/{domainIdentifier}/listings/{identifier}";
746
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
747
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
499
+ b.bp("/v2/domains/{domainIdentifier}/listings/{identifier}");
500
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
501
+ b.p("identifier", () => input.identifier, "{identifier}", false);
748
502
  let body;
749
- return new __HttpRequest({
750
- protocol,
751
- hostname,
752
- port,
753
- method: "DELETE",
754
- headers,
755
- path: resolvedPath,
756
- body,
757
- });
503
+ b.m("DELETE").h(headers).b(body);
504
+ return b.build();
758
505
  };
759
506
  export const se_DeleteProjectCommand = async (input, context) => {
760
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
507
+ const b = rb(input, context);
761
508
  const headers = {};
762
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
763
- "/v2/domains/{domainIdentifier}/projects/{identifier}";
764
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
765
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
509
+ b.bp("/v2/domains/{domainIdentifier}/projects/{identifier}");
510
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
511
+ b.p("identifier", () => input.identifier, "{identifier}", false);
766
512
  let body;
767
- return new __HttpRequest({
768
- protocol,
769
- hostname,
770
- port,
771
- method: "DELETE",
772
- headers,
773
- path: resolvedPath,
774
- body,
775
- });
513
+ b.m("DELETE").h(headers).b(body);
514
+ return b.build();
776
515
  };
777
516
  export const se_DeleteProjectMembershipCommand = async (input, context) => {
778
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
517
+ const b = rb(input, context);
779
518
  const headers = {
780
519
  "content-type": "application/json",
781
520
  };
782
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
783
- "/v2/domains/{domainIdentifier}/projects/{projectIdentifier}/deleteMembership";
784
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
785
- resolvedPath = __resolvedPath(resolvedPath, input, "projectIdentifier", () => input.projectIdentifier, "{projectIdentifier}", false);
521
+ b.bp("/v2/domains/{domainIdentifier}/projects/{projectIdentifier}/deleteMembership");
522
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
523
+ b.p("projectIdentifier", () => input.projectIdentifier, "{projectIdentifier}", false);
786
524
  let body;
787
525
  body = JSON.stringify(take(input, {
788
526
  member: (_) => _json(_),
789
527
  }));
790
- return new __HttpRequest({
791
- protocol,
792
- hostname,
793
- port,
794
- method: "POST",
795
- headers,
796
- path: resolvedPath,
797
- body,
798
- });
528
+ b.m("POST").h(headers).b(body);
529
+ return b.build();
799
530
  };
800
531
  export const se_DeleteSubscriptionGrantCommand = async (input, context) => {
801
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
532
+ const b = rb(input, context);
802
533
  const headers = {};
803
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
804
- "/v2/domains/{domainIdentifier}/subscription-grants/{identifier}";
805
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
806
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
534
+ b.bp("/v2/domains/{domainIdentifier}/subscription-grants/{identifier}");
535
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
536
+ b.p("identifier", () => input.identifier, "{identifier}", false);
807
537
  let body;
808
- return new __HttpRequest({
809
- protocol,
810
- hostname,
811
- port,
812
- method: "DELETE",
813
- headers,
814
- path: resolvedPath,
815
- body,
816
- });
538
+ b.m("DELETE").h(headers).b(body);
539
+ return b.build();
817
540
  };
818
541
  export const se_DeleteSubscriptionRequestCommand = async (input, context) => {
819
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
542
+ const b = rb(input, context);
820
543
  const headers = {};
821
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
822
- "/v2/domains/{domainIdentifier}/subscription-requests/{identifier}";
823
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
824
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
544
+ b.bp("/v2/domains/{domainIdentifier}/subscription-requests/{identifier}");
545
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
546
+ b.p("identifier", () => input.identifier, "{identifier}", false);
825
547
  let body;
826
- return new __HttpRequest({
827
- protocol,
828
- hostname,
829
- port,
830
- method: "DELETE",
831
- headers,
832
- path: resolvedPath,
833
- body,
834
- });
548
+ b.m("DELETE").h(headers).b(body);
549
+ return b.build();
835
550
  };
836
551
  export const se_DeleteSubscriptionTargetCommand = async (input, context) => {
837
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
552
+ const b = rb(input, context);
838
553
  const headers = {};
839
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
840
- "/v2/domains/{domainIdentifier}/environments/{environmentIdentifier}/subscription-targets/{identifier}";
841
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
842
- resolvedPath = __resolvedPath(resolvedPath, input, "environmentIdentifier", () => input.environmentIdentifier, "{environmentIdentifier}", false);
843
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
554
+ b.bp("/v2/domains/{domainIdentifier}/environments/{environmentIdentifier}/subscription-targets/{identifier}");
555
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
556
+ b.p("environmentIdentifier", () => input.environmentIdentifier, "{environmentIdentifier}", false);
557
+ b.p("identifier", () => input.identifier, "{identifier}", false);
844
558
  let body;
845
- return new __HttpRequest({
846
- protocol,
847
- hostname,
848
- port,
849
- method: "DELETE",
850
- headers,
851
- path: resolvedPath,
852
- body,
853
- });
559
+ b.m("DELETE").h(headers).b(body);
560
+ return b.build();
854
561
  };
855
562
  export const se_GetAssetCommand = async (input, context) => {
856
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
563
+ const b = rb(input, context);
857
564
  const headers = {};
858
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
859
- "/v2/domains/{domainIdentifier}/assets/{identifier}";
860
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
861
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
565
+ b.bp("/v2/domains/{domainIdentifier}/assets/{identifier}");
566
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
567
+ b.p("identifier", () => input.identifier, "{identifier}", false);
862
568
  const query = map({
863
- revision: [, input.revision],
569
+ [_r]: [, input[_r]],
864
570
  });
865
571
  let body;
866
- return new __HttpRequest({
867
- protocol,
868
- hostname,
869
- port,
870
- method: "GET",
871
- headers,
872
- path: resolvedPath,
873
- query,
874
- body,
875
- });
572
+ b.m("GET").h(headers).q(query).b(body);
573
+ return b.build();
876
574
  };
877
575
  export const se_GetAssetTypeCommand = async (input, context) => {
878
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
576
+ const b = rb(input, context);
879
577
  const headers = {};
880
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
881
- "/v2/domains/{domainIdentifier}/asset-types/{identifier}";
882
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
883
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
578
+ b.bp("/v2/domains/{domainIdentifier}/asset-types/{identifier}");
579
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
580
+ b.p("identifier", () => input.identifier, "{identifier}", false);
884
581
  const query = map({
885
- revision: [, input.revision],
582
+ [_r]: [, input[_r]],
886
583
  });
887
584
  let body;
888
- return new __HttpRequest({
889
- protocol,
890
- hostname,
891
- port,
892
- method: "GET",
893
- headers,
894
- path: resolvedPath,
895
- query,
896
- body,
897
- });
585
+ b.m("GET").h(headers).q(query).b(body);
586
+ return b.build();
898
587
  };
899
588
  export const se_GetDataSourceCommand = async (input, context) => {
900
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
589
+ const b = rb(input, context);
901
590
  const headers = {};
902
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
903
- "/v2/domains/{domainIdentifier}/data-sources/{identifier}";
904
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
905
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
591
+ b.bp("/v2/domains/{domainIdentifier}/data-sources/{identifier}");
592
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
593
+ b.p("identifier", () => input.identifier, "{identifier}", false);
906
594
  let body;
907
- return new __HttpRequest({
908
- protocol,
909
- hostname,
910
- port,
911
- method: "GET",
912
- headers,
913
- path: resolvedPath,
914
- body,
915
- });
595
+ b.m("GET").h(headers).b(body);
596
+ return b.build();
916
597
  };
917
598
  export const se_GetDataSourceRunCommand = async (input, context) => {
918
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
599
+ const b = rb(input, context);
919
600
  const headers = {};
920
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
921
- "/v2/domains/{domainIdentifier}/data-source-runs/{identifier}";
922
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
923
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
601
+ b.bp("/v2/domains/{domainIdentifier}/data-source-runs/{identifier}");
602
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
603
+ b.p("identifier", () => input.identifier, "{identifier}", false);
924
604
  let body;
925
- return new __HttpRequest({
926
- protocol,
927
- hostname,
928
- port,
929
- method: "GET",
930
- headers,
931
- path: resolvedPath,
932
- body,
933
- });
605
+ b.m("GET").h(headers).b(body);
606
+ return b.build();
934
607
  };
935
608
  export const se_GetDomainCommand = async (input, context) => {
936
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
609
+ const b = rb(input, context);
937
610
  const headers = {};
938
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/domains/{identifier}";
939
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
611
+ b.bp("/v2/domains/{identifier}");
612
+ b.p("identifier", () => input.identifier, "{identifier}", false);
940
613
  let body;
941
- return new __HttpRequest({
942
- protocol,
943
- hostname,
944
- port,
945
- method: "GET",
946
- headers,
947
- path: resolvedPath,
948
- body,
949
- });
614
+ b.m("GET").h(headers).b(body);
615
+ return b.build();
950
616
  };
951
617
  export const se_GetEnvironmentCommand = async (input, context) => {
952
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
618
+ const b = rb(input, context);
953
619
  const headers = {};
954
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
955
- "/v2/domains/{domainIdentifier}/environments/{identifier}";
956
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
957
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
620
+ b.bp("/v2/domains/{domainIdentifier}/environments/{identifier}");
621
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
622
+ b.p("identifier", () => input.identifier, "{identifier}", false);
958
623
  let body;
959
- return new __HttpRequest({
960
- protocol,
961
- hostname,
962
- port,
963
- method: "GET",
964
- headers,
965
- path: resolvedPath,
966
- body,
967
- });
624
+ b.m("GET").h(headers).b(body);
625
+ return b.build();
968
626
  };
969
627
  export const se_GetEnvironmentBlueprintCommand = async (input, context) => {
970
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
628
+ const b = rb(input, context);
971
629
  const headers = {};
972
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
973
- "/v2/domains/{domainIdentifier}/environment-blueprints/{identifier}";
974
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
975
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
630
+ b.bp("/v2/domains/{domainIdentifier}/environment-blueprints/{identifier}");
631
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
632
+ b.p("identifier", () => input.identifier, "{identifier}", false);
976
633
  let body;
977
- return new __HttpRequest({
978
- protocol,
979
- hostname,
980
- port,
981
- method: "GET",
982
- headers,
983
- path: resolvedPath,
984
- body,
985
- });
634
+ b.m("GET").h(headers).b(body);
635
+ return b.build();
986
636
  };
987
637
  export const se_GetEnvironmentBlueprintConfigurationCommand = async (input, context) => {
988
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
638
+ const b = rb(input, context);
989
639
  const headers = {};
990
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
991
- "/v2/domains/{domainIdentifier}/environment-blueprint-configurations/{environmentBlueprintIdentifier}";
992
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
993
- resolvedPath = __resolvedPath(resolvedPath, input, "environmentBlueprintIdentifier", () => input.environmentBlueprintIdentifier, "{environmentBlueprintIdentifier}", false);
640
+ b.bp("/v2/domains/{domainIdentifier}/environment-blueprint-configurations/{environmentBlueprintIdentifier}");
641
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
642
+ b.p("environmentBlueprintIdentifier", () => input.environmentBlueprintIdentifier, "{environmentBlueprintIdentifier}", false);
994
643
  let body;
995
- return new __HttpRequest({
996
- protocol,
997
- hostname,
998
- port,
999
- method: "GET",
1000
- headers,
1001
- path: resolvedPath,
1002
- body,
1003
- });
644
+ b.m("GET").h(headers).b(body);
645
+ return b.build();
1004
646
  };
1005
647
  export const se_GetEnvironmentProfileCommand = async (input, context) => {
1006
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
648
+ const b = rb(input, context);
1007
649
  const headers = {};
1008
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1009
- "/v2/domains/{domainIdentifier}/environment-profiles/{identifier}";
1010
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1011
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
650
+ b.bp("/v2/domains/{domainIdentifier}/environment-profiles/{identifier}");
651
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
652
+ b.p("identifier", () => input.identifier, "{identifier}", false);
1012
653
  let body;
1013
- return new __HttpRequest({
1014
- protocol,
1015
- hostname,
1016
- port,
1017
- method: "GET",
1018
- headers,
1019
- path: resolvedPath,
1020
- body,
1021
- });
654
+ b.m("GET").h(headers).b(body);
655
+ return b.build();
1022
656
  };
1023
657
  export const se_GetFormTypeCommand = async (input, context) => {
1024
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
658
+ const b = rb(input, context);
1025
659
  const headers = {};
1026
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1027
- "/v2/domains/{domainIdentifier}/form-types/{formTypeIdentifier}";
1028
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1029
- resolvedPath = __resolvedPath(resolvedPath, input, "formTypeIdentifier", () => input.formTypeIdentifier, "{formTypeIdentifier}", false);
660
+ b.bp("/v2/domains/{domainIdentifier}/form-types/{formTypeIdentifier}");
661
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
662
+ b.p("formTypeIdentifier", () => input.formTypeIdentifier, "{formTypeIdentifier}", false);
1030
663
  const query = map({
1031
- revision: [, input.revision],
664
+ [_r]: [, input[_r]],
1032
665
  });
1033
666
  let body;
1034
- return new __HttpRequest({
1035
- protocol,
1036
- hostname,
1037
- port,
1038
- method: "GET",
1039
- headers,
1040
- path: resolvedPath,
1041
- query,
1042
- body,
1043
- });
667
+ b.m("GET").h(headers).q(query).b(body);
668
+ return b.build();
1044
669
  };
1045
670
  export const se_GetGlossaryCommand = async (input, context) => {
1046
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
671
+ const b = rb(input, context);
1047
672
  const headers = {};
1048
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1049
- "/v2/domains/{domainIdentifier}/glossaries/{identifier}";
1050
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1051
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
673
+ b.bp("/v2/domains/{domainIdentifier}/glossaries/{identifier}");
674
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
675
+ b.p("identifier", () => input.identifier, "{identifier}", false);
1052
676
  let body;
1053
- return new __HttpRequest({
1054
- protocol,
1055
- hostname,
1056
- port,
1057
- method: "GET",
1058
- headers,
1059
- path: resolvedPath,
1060
- body,
1061
- });
677
+ b.m("GET").h(headers).b(body);
678
+ return b.build();
1062
679
  };
1063
680
  export const se_GetGlossaryTermCommand = async (input, context) => {
1064
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
681
+ const b = rb(input, context);
1065
682
  const headers = {};
1066
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1067
- "/v2/domains/{domainIdentifier}/glossary-terms/{identifier}";
1068
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1069
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
683
+ b.bp("/v2/domains/{domainIdentifier}/glossary-terms/{identifier}");
684
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
685
+ b.p("identifier", () => input.identifier, "{identifier}", false);
1070
686
  let body;
1071
- return new __HttpRequest({
1072
- protocol,
1073
- hostname,
1074
- port,
1075
- method: "GET",
1076
- headers,
1077
- path: resolvedPath,
1078
- body,
1079
- });
687
+ b.m("GET").h(headers).b(body);
688
+ return b.build();
1080
689
  };
1081
690
  export const se_GetGroupProfileCommand = async (input, context) => {
1082
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
691
+ const b = rb(input, context);
1083
692
  const headers = {};
1084
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1085
- "/v2/domains/{domainIdentifier}/group-profiles/{groupIdentifier}";
1086
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1087
- resolvedPath = __resolvedPath(resolvedPath, input, "groupIdentifier", () => input.groupIdentifier, "{groupIdentifier}", false);
693
+ b.bp("/v2/domains/{domainIdentifier}/group-profiles/{groupIdentifier}");
694
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
695
+ b.p("groupIdentifier", () => input.groupIdentifier, "{groupIdentifier}", false);
1088
696
  let body;
1089
- return new __HttpRequest({
1090
- protocol,
1091
- hostname,
1092
- port,
1093
- method: "GET",
1094
- headers,
1095
- path: resolvedPath,
1096
- body,
1097
- });
697
+ b.m("GET").h(headers).b(body);
698
+ return b.build();
1098
699
  };
1099
700
  export const se_GetIamPortalLoginUrlCommand = async (input, context) => {
1100
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
701
+ const b = rb(input, context);
1101
702
  const headers = {};
1102
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1103
- "/v2/domains/{domainIdentifier}/get-portal-login-url";
1104
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
703
+ b.bp("/v2/domains/{domainIdentifier}/get-portal-login-url");
704
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1105
705
  let body;
1106
- return new __HttpRequest({
1107
- protocol,
1108
- hostname,
1109
- port,
1110
- method: "POST",
1111
- headers,
1112
- path: resolvedPath,
1113
- body,
1114
- });
706
+ b.m("POST").h(headers).b(body);
707
+ return b.build();
1115
708
  };
1116
709
  export const se_GetListingCommand = async (input, context) => {
1117
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
710
+ const b = rb(input, context);
1118
711
  const headers = {};
1119
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1120
- "/v2/domains/{domainIdentifier}/listings/{identifier}";
1121
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1122
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
712
+ b.bp("/v2/domains/{domainIdentifier}/listings/{identifier}");
713
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
714
+ b.p("identifier", () => input.identifier, "{identifier}", false);
1123
715
  const query = map({
1124
- listingRevision: [, input.listingRevision],
716
+ [_lR]: [, input[_lR]],
1125
717
  });
1126
718
  let body;
1127
- return new __HttpRequest({
1128
- protocol,
1129
- hostname,
1130
- port,
1131
- method: "GET",
1132
- headers,
1133
- path: resolvedPath,
1134
- query,
1135
- body,
1136
- });
719
+ b.m("GET").h(headers).q(query).b(body);
720
+ return b.build();
1137
721
  };
1138
722
  export const se_GetProjectCommand = async (input, context) => {
1139
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
723
+ const b = rb(input, context);
1140
724
  const headers = {};
1141
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1142
- "/v2/domains/{domainIdentifier}/projects/{identifier}";
1143
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1144
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
725
+ b.bp("/v2/domains/{domainIdentifier}/projects/{identifier}");
726
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
727
+ b.p("identifier", () => input.identifier, "{identifier}", false);
1145
728
  let body;
1146
- return new __HttpRequest({
1147
- protocol,
1148
- hostname,
1149
- port,
1150
- method: "GET",
1151
- headers,
1152
- path: resolvedPath,
1153
- body,
1154
- });
729
+ b.m("GET").h(headers).b(body);
730
+ return b.build();
1155
731
  };
1156
732
  export const se_GetSubscriptionCommand = async (input, context) => {
1157
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
733
+ const b = rb(input, context);
1158
734
  const headers = {};
1159
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1160
- "/v2/domains/{domainIdentifier}/subscriptions/{identifier}";
1161
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1162
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
735
+ b.bp("/v2/domains/{domainIdentifier}/subscriptions/{identifier}");
736
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
737
+ b.p("identifier", () => input.identifier, "{identifier}", false);
1163
738
  let body;
1164
- return new __HttpRequest({
1165
- protocol,
1166
- hostname,
1167
- port,
1168
- method: "GET",
1169
- headers,
1170
- path: resolvedPath,
1171
- body,
1172
- });
739
+ b.m("GET").h(headers).b(body);
740
+ return b.build();
1173
741
  };
1174
742
  export const se_GetSubscriptionGrantCommand = async (input, context) => {
1175
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
743
+ const b = rb(input, context);
1176
744
  const headers = {};
1177
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1178
- "/v2/domains/{domainIdentifier}/subscription-grants/{identifier}";
1179
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1180
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
745
+ b.bp("/v2/domains/{domainIdentifier}/subscription-grants/{identifier}");
746
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
747
+ b.p("identifier", () => input.identifier, "{identifier}", false);
1181
748
  let body;
1182
- return new __HttpRequest({
1183
- protocol,
1184
- hostname,
1185
- port,
1186
- method: "GET",
1187
- headers,
1188
- path: resolvedPath,
1189
- body,
1190
- });
749
+ b.m("GET").h(headers).b(body);
750
+ return b.build();
1191
751
  };
1192
752
  export const se_GetSubscriptionRequestDetailsCommand = async (input, context) => {
1193
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
753
+ const b = rb(input, context);
1194
754
  const headers = {};
1195
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1196
- "/v2/domains/{domainIdentifier}/subscription-requests/{identifier}";
1197
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1198
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
755
+ b.bp("/v2/domains/{domainIdentifier}/subscription-requests/{identifier}");
756
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
757
+ b.p("identifier", () => input.identifier, "{identifier}", false);
1199
758
  let body;
1200
- return new __HttpRequest({
1201
- protocol,
1202
- hostname,
1203
- port,
1204
- method: "GET",
1205
- headers,
1206
- path: resolvedPath,
1207
- body,
1208
- });
759
+ b.m("GET").h(headers).b(body);
760
+ return b.build();
1209
761
  };
1210
762
  export const se_GetSubscriptionTargetCommand = async (input, context) => {
1211
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
763
+ const b = rb(input, context);
1212
764
  const headers = {};
1213
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1214
- "/v2/domains/{domainIdentifier}/environments/{environmentIdentifier}/subscription-targets/{identifier}";
1215
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1216
- resolvedPath = __resolvedPath(resolvedPath, input, "environmentIdentifier", () => input.environmentIdentifier, "{environmentIdentifier}", false);
1217
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
765
+ b.bp("/v2/domains/{domainIdentifier}/environments/{environmentIdentifier}/subscription-targets/{identifier}");
766
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
767
+ b.p("environmentIdentifier", () => input.environmentIdentifier, "{environmentIdentifier}", false);
768
+ b.p("identifier", () => input.identifier, "{identifier}", false);
1218
769
  let body;
1219
- return new __HttpRequest({
1220
- protocol,
1221
- hostname,
1222
- port,
1223
- method: "GET",
1224
- headers,
1225
- path: resolvedPath,
1226
- body,
1227
- });
770
+ b.m("GET").h(headers).b(body);
771
+ return b.build();
1228
772
  };
1229
773
  export const se_GetUserProfileCommand = async (input, context) => {
1230
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
774
+ const b = rb(input, context);
1231
775
  const headers = {};
1232
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1233
- "/v2/domains/{domainIdentifier}/user-profiles/{userIdentifier}";
1234
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1235
- resolvedPath = __resolvedPath(resolvedPath, input, "userIdentifier", () => input.userIdentifier, "{userIdentifier}", false);
776
+ b.bp("/v2/domains/{domainIdentifier}/user-profiles/{userIdentifier}");
777
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
778
+ b.p("userIdentifier", () => input.userIdentifier, "{userIdentifier}", false);
1236
779
  const query = map({
1237
- type: [, input.type],
780
+ [_t]: [, input[_t]],
1238
781
  });
1239
782
  let body;
1240
- return new __HttpRequest({
1241
- protocol,
1242
- hostname,
1243
- port,
1244
- method: "GET",
1245
- headers,
1246
- path: resolvedPath,
1247
- query,
1248
- body,
1249
- });
783
+ b.m("GET").h(headers).q(query).b(body);
784
+ return b.build();
1250
785
  };
1251
786
  export const se_ListAssetRevisionsCommand = async (input, context) => {
1252
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
787
+ const b = rb(input, context);
1253
788
  const headers = {};
1254
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1255
- "/v2/domains/{domainIdentifier}/assets/{identifier}/revisions";
1256
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1257
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
789
+ b.bp("/v2/domains/{domainIdentifier}/assets/{identifier}/revisions");
790
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
791
+ b.p("identifier", () => input.identifier, "{identifier}", false);
1258
792
  const query = map({
1259
- nextToken: [, input.nextToken],
1260
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
793
+ [_nT]: [, input[_nT]],
794
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
1261
795
  });
1262
796
  let body;
1263
- return new __HttpRequest({
1264
- protocol,
1265
- hostname,
1266
- port,
1267
- method: "GET",
1268
- headers,
1269
- path: resolvedPath,
1270
- query,
1271
- body,
1272
- });
797
+ b.m("GET").h(headers).q(query).b(body);
798
+ return b.build();
1273
799
  };
1274
800
  export const se_ListDataSourceRunActivitiesCommand = async (input, context) => {
1275
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
801
+ const b = rb(input, context);
1276
802
  const headers = {};
1277
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1278
- "/v2/domains/{domainIdentifier}/data-source-runs/{identifier}/activities";
1279
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1280
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
803
+ b.bp("/v2/domains/{domainIdentifier}/data-source-runs/{identifier}/activities");
804
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
805
+ b.p("identifier", () => input.identifier, "{identifier}", false);
1281
806
  const query = map({
1282
- status: [, input.status],
1283
- nextToken: [, input.nextToken],
1284
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
807
+ [_s]: [, input[_s]],
808
+ [_nT]: [, input[_nT]],
809
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
1285
810
  });
1286
811
  let body;
1287
- return new __HttpRequest({
1288
- protocol,
1289
- hostname,
1290
- port,
1291
- method: "GET",
1292
- headers,
1293
- path: resolvedPath,
1294
- query,
1295
- body,
1296
- });
812
+ b.m("GET").h(headers).q(query).b(body);
813
+ return b.build();
1297
814
  };
1298
815
  export const se_ListDataSourceRunsCommand = async (input, context) => {
1299
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
816
+ const b = rb(input, context);
1300
817
  const headers = {};
1301
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1302
- "/v2/domains/{domainIdentifier}/data-sources/{dataSourceIdentifier}/runs";
1303
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1304
- resolvedPath = __resolvedPath(resolvedPath, input, "dataSourceIdentifier", () => input.dataSourceIdentifier, "{dataSourceIdentifier}", false);
818
+ b.bp("/v2/domains/{domainIdentifier}/data-sources/{dataSourceIdentifier}/runs");
819
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
820
+ b.p("dataSourceIdentifier", () => input.dataSourceIdentifier, "{dataSourceIdentifier}", false);
1305
821
  const query = map({
1306
- status: [, input.status],
1307
- nextToken: [, input.nextToken],
1308
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
822
+ [_s]: [, input[_s]],
823
+ [_nT]: [, input[_nT]],
824
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
1309
825
  });
1310
826
  let body;
1311
- return new __HttpRequest({
1312
- protocol,
1313
- hostname,
1314
- port,
1315
- method: "GET",
1316
- headers,
1317
- path: resolvedPath,
1318
- query,
1319
- body,
1320
- });
827
+ b.m("GET").h(headers).q(query).b(body);
828
+ return b.build();
1321
829
  };
1322
830
  export const se_ListDataSourcesCommand = async (input, context) => {
1323
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
831
+ const b = rb(input, context);
1324
832
  const headers = {};
1325
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1326
- "/v2/domains/{domainIdentifier}/data-sources";
1327
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
833
+ b.bp("/v2/domains/{domainIdentifier}/data-sources");
834
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1328
835
  const query = map({
1329
- projectIdentifier: [, __expectNonNull(input.projectIdentifier, `projectIdentifier`)],
1330
- environmentIdentifier: [, input.environmentIdentifier],
1331
- type: [, input.type],
1332
- status: [, input.status],
1333
- name: [, input.name],
1334
- nextToken: [, input.nextToken],
1335
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
836
+ [_pI]: [, __expectNonNull(input[_pI], `projectIdentifier`)],
837
+ [_eI]: [, input[_eI]],
838
+ [_t]: [, input[_t]],
839
+ [_s]: [, input[_s]],
840
+ [_n]: [, input[_n]],
841
+ [_nT]: [, input[_nT]],
842
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
1336
843
  });
1337
844
  let body;
1338
- return new __HttpRequest({
1339
- protocol,
1340
- hostname,
1341
- port,
1342
- method: "GET",
1343
- headers,
1344
- path: resolvedPath,
1345
- query,
1346
- body,
1347
- });
845
+ b.m("GET").h(headers).q(query).b(body);
846
+ return b.build();
1348
847
  };
1349
848
  export const se_ListDomainsCommand = async (input, context) => {
1350
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
849
+ const b = rb(input, context);
1351
850
  const headers = {};
1352
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/domains";
851
+ b.bp("/v2/domains");
1353
852
  const query = map({
1354
- status: [, input.status],
1355
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1356
- nextToken: [, input.nextToken],
853
+ [_s]: [, input[_s]],
854
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
855
+ [_nT]: [, input[_nT]],
1357
856
  });
1358
857
  let body;
1359
- return new __HttpRequest({
1360
- protocol,
1361
- hostname,
1362
- port,
1363
- method: "GET",
1364
- headers,
1365
- path: resolvedPath,
1366
- query,
1367
- body,
1368
- });
858
+ b.m("GET").h(headers).q(query).b(body);
859
+ return b.build();
1369
860
  };
1370
861
  export const se_ListEnvironmentBlueprintConfigurationsCommand = async (input, context) => {
1371
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
862
+ const b = rb(input, context);
1372
863
  const headers = {};
1373
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1374
- "/v2/domains/{domainIdentifier}/environment-blueprint-configurations";
1375
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
864
+ b.bp("/v2/domains/{domainIdentifier}/environment-blueprint-configurations");
865
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1376
866
  const query = map({
1377
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1378
- nextToken: [, input.nextToken],
867
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
868
+ [_nT]: [, input[_nT]],
1379
869
  });
1380
870
  let body;
1381
- return new __HttpRequest({
1382
- protocol,
1383
- hostname,
1384
- port,
1385
- method: "GET",
1386
- headers,
1387
- path: resolvedPath,
1388
- query,
1389
- body,
1390
- });
871
+ b.m("GET").h(headers).q(query).b(body);
872
+ return b.build();
1391
873
  };
1392
874
  export const se_ListEnvironmentBlueprintsCommand = async (input, context) => {
1393
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
875
+ const b = rb(input, context);
1394
876
  const headers = {};
1395
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1396
- "/v2/domains/{domainIdentifier}/environment-blueprints";
1397
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
877
+ b.bp("/v2/domains/{domainIdentifier}/environment-blueprints");
878
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1398
879
  const query = map({
1399
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1400
- nextToken: [, input.nextToken],
1401
- name: [, input.name],
1402
- managed: [() => input.managed !== void 0, () => input.managed.toString()],
880
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
881
+ [_nT]: [, input[_nT]],
882
+ [_n]: [, input[_n]],
883
+ [_m]: [() => input.managed !== void 0, () => input[_m].toString()],
1403
884
  });
1404
885
  let body;
1405
- return new __HttpRequest({
1406
- protocol,
1407
- hostname,
1408
- port,
1409
- method: "GET",
1410
- headers,
1411
- path: resolvedPath,
1412
- query,
1413
- body,
1414
- });
886
+ b.m("GET").h(headers).q(query).b(body);
887
+ return b.build();
1415
888
  };
1416
889
  export const se_ListEnvironmentProfilesCommand = async (input, context) => {
1417
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
890
+ const b = rb(input, context);
1418
891
  const headers = {};
1419
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1420
- "/v2/domains/{domainIdentifier}/environment-profiles";
1421
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
892
+ b.bp("/v2/domains/{domainIdentifier}/environment-profiles");
893
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1422
894
  const query = map({
1423
- awsAccountId: [, input.awsAccountId],
1424
- awsAccountRegion: [, input.awsAccountRegion],
1425
- environmentBlueprintIdentifier: [, input.environmentBlueprintIdentifier],
1426
- projectIdentifier: [, input.projectIdentifier],
1427
- name: [, input.name],
1428
- nextToken: [, input.nextToken],
1429
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
895
+ [_aAI]: [, input[_aAI]],
896
+ [_aAR]: [, input[_aAR]],
897
+ [_eBI]: [, input[_eBI]],
898
+ [_pI]: [, input[_pI]],
899
+ [_n]: [, input[_n]],
900
+ [_nT]: [, input[_nT]],
901
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
1430
902
  });
1431
903
  let body;
1432
- return new __HttpRequest({
1433
- protocol,
1434
- hostname,
1435
- port,
1436
- method: "GET",
1437
- headers,
1438
- path: resolvedPath,
1439
- query,
1440
- body,
1441
- });
904
+ b.m("GET").h(headers).q(query).b(body);
905
+ return b.build();
1442
906
  };
1443
907
  export const se_ListEnvironmentsCommand = async (input, context) => {
1444
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
908
+ const b = rb(input, context);
1445
909
  const headers = {};
1446
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1447
- "/v2/domains/{domainIdentifier}/environments";
1448
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
910
+ b.bp("/v2/domains/{domainIdentifier}/environments");
911
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1449
912
  const query = map({
1450
- awsAccountId: [, input.awsAccountId],
1451
- status: [, input.status],
1452
- awsAccountRegion: [, input.awsAccountRegion],
1453
- projectIdentifier: [, __expectNonNull(input.projectIdentifier, `projectIdentifier`)],
1454
- environmentProfileIdentifier: [, input.environmentProfileIdentifier],
1455
- environmentBlueprintIdentifier: [, input.environmentBlueprintIdentifier],
1456
- provider: [, input.provider],
1457
- name: [, input.name],
1458
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1459
- nextToken: [, input.nextToken],
913
+ [_aAI]: [, input[_aAI]],
914
+ [_s]: [, input[_s]],
915
+ [_aAR]: [, input[_aAR]],
916
+ [_pI]: [, __expectNonNull(input[_pI], `projectIdentifier`)],
917
+ [_ePI]: [, input[_ePI]],
918
+ [_eBI]: [, input[_eBI]],
919
+ [_p]: [, input[_p]],
920
+ [_n]: [, input[_n]],
921
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
922
+ [_nT]: [, input[_nT]],
1460
923
  });
1461
924
  let body;
1462
- return new __HttpRequest({
1463
- protocol,
1464
- hostname,
1465
- port,
1466
- method: "GET",
1467
- headers,
1468
- path: resolvedPath,
1469
- query,
1470
- body,
1471
- });
925
+ b.m("GET").h(headers).q(query).b(body);
926
+ return b.build();
1472
927
  };
1473
928
  export const se_ListNotificationsCommand = async (input, context) => {
1474
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
929
+ const b = rb(input, context);
1475
930
  const headers = {};
1476
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1477
- "/v2/domains/{domainIdentifier}/notifications";
1478
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
931
+ b.bp("/v2/domains/{domainIdentifier}/notifications");
932
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1479
933
  const query = map({
1480
- type: [, __expectNonNull(input.type, `type`)],
1481
- afterTimestamp: [
1482
- () => input.afterTimestamp !== void 0,
1483
- () => (input.afterTimestamp.toISOString().split(".")[0] + "Z").toString(),
1484
- ],
1485
- beforeTimestamp: [
1486
- () => input.beforeTimestamp !== void 0,
1487
- () => (input.beforeTimestamp.toISOString().split(".")[0] + "Z").toString(),
1488
- ],
1489
- subjects: [() => input.subjects !== void 0, () => (input.subjects || []).map((_entry) => _entry)],
1490
- taskStatus: [, input.taskStatus],
1491
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1492
- nextToken: [, input.nextToken],
934
+ [_t]: [, __expectNonNull(input[_t], `type`)],
935
+ [_aT]: [() => input.afterTimestamp !== void 0, () => (input[_aT].toISOString().split(".")[0] + "Z").toString()],
936
+ [_bT]: [() => input.beforeTimestamp !== void 0, () => (input[_bT].toISOString().split(".")[0] + "Z").toString()],
937
+ [_su]: [() => input.subjects !== void 0, () => (input[_su] || []).map((_entry) => _entry)],
938
+ [_tS]: [, input[_tS]],
939
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
940
+ [_nT]: [, input[_nT]],
1493
941
  });
1494
942
  let body;
1495
- return new __HttpRequest({
1496
- protocol,
1497
- hostname,
1498
- port,
1499
- method: "GET",
1500
- headers,
1501
- path: resolvedPath,
1502
- query,
1503
- body,
1504
- });
943
+ b.m("GET").h(headers).q(query).b(body);
944
+ return b.build();
1505
945
  };
1506
946
  export const se_ListProjectMembershipsCommand = async (input, context) => {
1507
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
947
+ const b = rb(input, context);
1508
948
  const headers = {};
1509
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1510
- "/v2/domains/{domainIdentifier}/projects/{projectIdentifier}/memberships";
1511
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1512
- resolvedPath = __resolvedPath(resolvedPath, input, "projectIdentifier", () => input.projectIdentifier, "{projectIdentifier}", false);
949
+ b.bp("/v2/domains/{domainIdentifier}/projects/{projectIdentifier}/memberships");
950
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
951
+ b.p("projectIdentifier", () => input.projectIdentifier, "{projectIdentifier}", false);
1513
952
  const query = map({
1514
- sortBy: [, input.sortBy],
1515
- sortOrder: [, input.sortOrder],
1516
- nextToken: [, input.nextToken],
1517
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
953
+ [_sB]: [, input[_sB]],
954
+ [_sO]: [, input[_sO]],
955
+ [_nT]: [, input[_nT]],
956
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
1518
957
  });
1519
958
  let body;
1520
- return new __HttpRequest({
1521
- protocol,
1522
- hostname,
1523
- port,
1524
- method: "GET",
1525
- headers,
1526
- path: resolvedPath,
1527
- query,
1528
- body,
1529
- });
959
+ b.m("GET").h(headers).q(query).b(body);
960
+ return b.build();
1530
961
  };
1531
962
  export const se_ListProjectsCommand = async (input, context) => {
1532
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
963
+ const b = rb(input, context);
1533
964
  const headers = {};
1534
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/domains/{domainIdentifier}/projects";
1535
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
965
+ b.bp("/v2/domains/{domainIdentifier}/projects");
966
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1536
967
  const query = map({
1537
- userIdentifier: [, input.userIdentifier],
1538
- groupIdentifier: [, input.groupIdentifier],
1539
- name: [, input.name],
1540
- nextToken: [, input.nextToken],
1541
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
968
+ [_uI]: [, input[_uI]],
969
+ [_gI]: [, input[_gI]],
970
+ [_n]: [, input[_n]],
971
+ [_nT]: [, input[_nT]],
972
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
1542
973
  });
1543
974
  let body;
1544
- return new __HttpRequest({
1545
- protocol,
1546
- hostname,
1547
- port,
1548
- method: "GET",
1549
- headers,
1550
- path: resolvedPath,
1551
- query,
1552
- body,
1553
- });
975
+ b.m("GET").h(headers).q(query).b(body);
976
+ return b.build();
1554
977
  };
1555
978
  export const se_ListSubscriptionGrantsCommand = async (input, context) => {
1556
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
979
+ const b = rb(input, context);
1557
980
  const headers = {};
1558
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1559
- "/v2/domains/{domainIdentifier}/subscription-grants";
1560
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
981
+ b.bp("/v2/domains/{domainIdentifier}/subscription-grants");
982
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1561
983
  const query = map({
1562
- environmentId: [, input.environmentId],
1563
- subscriptionTargetId: [, input.subscriptionTargetId],
1564
- subscribedListingId: [, input.subscribedListingId],
1565
- subscriptionId: [, input.subscriptionId],
1566
- sortBy: [, input.sortBy],
1567
- sortOrder: [, input.sortOrder],
1568
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1569
- nextToken: [, input.nextToken],
984
+ [_eIn]: [, input[_eIn]],
985
+ [_sTI]: [, input[_sTI]],
986
+ [_sLI]: [, input[_sLI]],
987
+ [_sI]: [, input[_sI]],
988
+ [_sB]: [, input[_sB]],
989
+ [_sO]: [, input[_sO]],
990
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
991
+ [_nT]: [, input[_nT]],
1570
992
  });
1571
993
  let body;
1572
- return new __HttpRequest({
1573
- protocol,
1574
- hostname,
1575
- port,
1576
- method: "GET",
1577
- headers,
1578
- path: resolvedPath,
1579
- query,
1580
- body,
1581
- });
994
+ b.m("GET").h(headers).q(query).b(body);
995
+ return b.build();
1582
996
  };
1583
997
  export const se_ListSubscriptionRequestsCommand = async (input, context) => {
1584
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
998
+ const b = rb(input, context);
1585
999
  const headers = {};
1586
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1587
- "/v2/domains/{domainIdentifier}/subscription-requests";
1588
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1000
+ b.bp("/v2/domains/{domainIdentifier}/subscription-requests");
1001
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1589
1002
  const query = map({
1590
- status: [, input.status],
1591
- subscribedListingId: [, input.subscribedListingId],
1592
- owningProjectId: [, input.owningProjectId],
1593
- approverProjectId: [, input.approverProjectId],
1594
- sortBy: [, input.sortBy],
1595
- sortOrder: [, input.sortOrder],
1596
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1597
- nextToken: [, input.nextToken],
1003
+ [_s]: [, input[_s]],
1004
+ [_sLI]: [, input[_sLI]],
1005
+ [_oPI]: [, input[_oPI]],
1006
+ [_aPI]: [, input[_aPI]],
1007
+ [_sB]: [, input[_sB]],
1008
+ [_sO]: [, input[_sO]],
1009
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
1010
+ [_nT]: [, input[_nT]],
1598
1011
  });
1599
1012
  let body;
1600
- return new __HttpRequest({
1601
- protocol,
1602
- hostname,
1603
- port,
1604
- method: "GET",
1605
- headers,
1606
- path: resolvedPath,
1607
- query,
1608
- body,
1609
- });
1013
+ b.m("GET").h(headers).q(query).b(body);
1014
+ return b.build();
1610
1015
  };
1611
1016
  export const se_ListSubscriptionsCommand = async (input, context) => {
1612
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1017
+ const b = rb(input, context);
1613
1018
  const headers = {};
1614
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1615
- "/v2/domains/{domainIdentifier}/subscriptions";
1616
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1019
+ b.bp("/v2/domains/{domainIdentifier}/subscriptions");
1020
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1617
1021
  const query = map({
1618
- subscriptionRequestIdentifier: [, input.subscriptionRequestIdentifier],
1619
- status: [, input.status],
1620
- subscribedListingId: [, input.subscribedListingId],
1621
- owningProjectId: [, input.owningProjectId],
1622
- approverProjectId: [, input.approverProjectId],
1623
- sortBy: [, input.sortBy],
1624
- sortOrder: [, input.sortOrder],
1625
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1626
- nextToken: [, input.nextToken],
1022
+ [_sRI]: [, input[_sRI]],
1023
+ [_s]: [, input[_s]],
1024
+ [_sLI]: [, input[_sLI]],
1025
+ [_oPI]: [, input[_oPI]],
1026
+ [_aPI]: [, input[_aPI]],
1027
+ [_sB]: [, input[_sB]],
1028
+ [_sO]: [, input[_sO]],
1029
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
1030
+ [_nT]: [, input[_nT]],
1627
1031
  });
1628
1032
  let body;
1629
- return new __HttpRequest({
1630
- protocol,
1631
- hostname,
1632
- port,
1633
- method: "GET",
1634
- headers,
1635
- path: resolvedPath,
1636
- query,
1637
- body,
1638
- });
1033
+ b.m("GET").h(headers).q(query).b(body);
1034
+ return b.build();
1639
1035
  };
1640
1036
  export const se_ListSubscriptionTargetsCommand = async (input, context) => {
1641
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1037
+ const b = rb(input, context);
1642
1038
  const headers = {};
1643
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1644
- "/v2/domains/{domainIdentifier}/environments/{environmentIdentifier}/subscription-targets";
1645
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1646
- resolvedPath = __resolvedPath(resolvedPath, input, "environmentIdentifier", () => input.environmentIdentifier, "{environmentIdentifier}", false);
1039
+ b.bp("/v2/domains/{domainIdentifier}/environments/{environmentIdentifier}/subscription-targets");
1040
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1041
+ b.p("environmentIdentifier", () => input.environmentIdentifier, "{environmentIdentifier}", false);
1647
1042
  const query = map({
1648
- sortBy: [, input.sortBy],
1649
- sortOrder: [, input.sortOrder],
1650
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1651
- nextToken: [, input.nextToken],
1043
+ [_sB]: [, input[_sB]],
1044
+ [_sO]: [, input[_sO]],
1045
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
1046
+ [_nT]: [, input[_nT]],
1652
1047
  });
1653
1048
  let body;
1654
- return new __HttpRequest({
1655
- protocol,
1656
- hostname,
1657
- port,
1658
- method: "GET",
1659
- headers,
1660
- path: resolvedPath,
1661
- query,
1662
- body,
1663
- });
1049
+ b.m("GET").h(headers).q(query).b(body);
1050
+ return b.build();
1664
1051
  };
1665
1052
  export const se_ListTagsForResourceCommand = async (input, context) => {
1666
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1053
+ const b = rb(input, context);
1667
1054
  const headers = {};
1668
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
1669
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
1055
+ b.bp("/tags/{resourceArn}");
1056
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
1670
1057
  let body;
1671
- return new __HttpRequest({
1672
- protocol,
1673
- hostname,
1674
- port,
1675
- method: "GET",
1676
- headers,
1677
- path: resolvedPath,
1678
- body,
1679
- });
1058
+ b.m("GET").h(headers).b(body);
1059
+ return b.build();
1680
1060
  };
1681
1061
  export const se_PutEnvironmentBlueprintConfigurationCommand = async (input, context) => {
1682
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1062
+ const b = rb(input, context);
1683
1063
  const headers = {
1684
1064
  "content-type": "application/json",
1685
1065
  };
1686
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1687
- "/v2/domains/{domainIdentifier}/environment-blueprint-configurations/{environmentBlueprintIdentifier}";
1688
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1689
- resolvedPath = __resolvedPath(resolvedPath, input, "environmentBlueprintIdentifier", () => input.environmentBlueprintIdentifier, "{environmentBlueprintIdentifier}", false);
1066
+ b.bp("/v2/domains/{domainIdentifier}/environment-blueprint-configurations/{environmentBlueprintIdentifier}");
1067
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1068
+ b.p("environmentBlueprintIdentifier", () => input.environmentBlueprintIdentifier, "{environmentBlueprintIdentifier}", false);
1690
1069
  let body;
1691
1070
  body = JSON.stringify(take(input, {
1692
1071
  enabledRegions: (_) => _json(_),
@@ -1694,27 +1073,19 @@ export const se_PutEnvironmentBlueprintConfigurationCommand = async (input, cont
1694
1073
  provisioningRoleArn: [],
1695
1074
  regionalParameters: (_) => _json(_),
1696
1075
  }));
1697
- return new __HttpRequest({
1698
- protocol,
1699
- hostname,
1700
- port,
1701
- method: "PUT",
1702
- headers,
1703
- path: resolvedPath,
1704
- body,
1705
- });
1076
+ b.m("PUT").h(headers).b(body);
1077
+ return b.build();
1706
1078
  };
1707
1079
  export const se_RejectPredictionsCommand = async (input, context) => {
1708
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1080
+ const b = rb(input, context);
1709
1081
  const headers = {
1710
1082
  "content-type": "application/json",
1711
1083
  };
1712
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1713
- "/v2/domains/{domainIdentifier}/assets/{identifier}/reject-predictions";
1714
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1715
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
1084
+ b.bp("/v2/domains/{domainIdentifier}/assets/{identifier}/reject-predictions");
1085
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1086
+ b.p("identifier", () => input.identifier, "{identifier}", false);
1716
1087
  const query = map({
1717
- revision: [, input.revision],
1088
+ [_r]: [, input[_r]],
1718
1089
  });
1719
1090
  let body;
1720
1091
  body = JSON.stringify(take(input, {
@@ -1722,70 +1093,46 @@ export const se_RejectPredictionsCommand = async (input, context) => {
1722
1093
  rejectChoices: (_) => _json(_),
1723
1094
  rejectRule: (_) => se_RejectRule(_, context),
1724
1095
  }));
1725
- return new __HttpRequest({
1726
- protocol,
1727
- hostname,
1728
- port,
1729
- method: "PUT",
1730
- headers,
1731
- path: resolvedPath,
1732
- query,
1733
- body,
1734
- });
1096
+ b.m("PUT").h(headers).q(query).b(body);
1097
+ return b.build();
1735
1098
  };
1736
1099
  export const se_RejectSubscriptionRequestCommand = async (input, context) => {
1737
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1100
+ const b = rb(input, context);
1738
1101
  const headers = {
1739
1102
  "content-type": "application/json",
1740
1103
  };
1741
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1742
- "/v2/domains/{domainIdentifier}/subscription-requests/{identifier}/reject";
1743
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1744
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
1104
+ b.bp("/v2/domains/{domainIdentifier}/subscription-requests/{identifier}/reject");
1105
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1106
+ b.p("identifier", () => input.identifier, "{identifier}", false);
1745
1107
  let body;
1746
1108
  body = JSON.stringify(take(input, {
1747
1109
  decisionComment: [],
1748
1110
  }));
1749
- return new __HttpRequest({
1750
- protocol,
1751
- hostname,
1752
- port,
1753
- method: "PUT",
1754
- headers,
1755
- path: resolvedPath,
1756
- body,
1757
- });
1111
+ b.m("PUT").h(headers).b(body);
1112
+ return b.build();
1758
1113
  };
1759
1114
  export const se_RevokeSubscriptionCommand = async (input, context) => {
1760
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1115
+ const b = rb(input, context);
1761
1116
  const headers = {
1762
1117
  "content-type": "application/json",
1763
1118
  };
1764
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1765
- "/v2/domains/{domainIdentifier}/subscriptions/{identifier}/revoke";
1766
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1767
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
1119
+ b.bp("/v2/domains/{domainIdentifier}/subscriptions/{identifier}/revoke");
1120
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1121
+ b.p("identifier", () => input.identifier, "{identifier}", false);
1768
1122
  let body;
1769
1123
  body = JSON.stringify(take(input, {
1770
1124
  retainPermissions: [],
1771
1125
  }));
1772
- return new __HttpRequest({
1773
- protocol,
1774
- hostname,
1775
- port,
1776
- method: "PUT",
1777
- headers,
1778
- path: resolvedPath,
1779
- body,
1780
- });
1126
+ b.m("PUT").h(headers).b(body);
1127
+ return b.build();
1781
1128
  };
1782
1129
  export const se_SearchCommand = async (input, context) => {
1783
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1130
+ const b = rb(input, context);
1784
1131
  const headers = {
1785
1132
  "content-type": "application/json",
1786
1133
  };
1787
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/domains/{domainIdentifier}/search";
1788
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1134
+ b.bp("/v2/domains/{domainIdentifier}/search");
1135
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1789
1136
  let body;
1790
1137
  body = JSON.stringify(take(input, {
1791
1138
  additionalAttributes: (_) => _json(_),
@@ -1798,24 +1145,16 @@ export const se_SearchCommand = async (input, context) => {
1798
1145
  searchText: [],
1799
1146
  sort: (_) => _json(_),
1800
1147
  }));
1801
- return new __HttpRequest({
1802
- protocol,
1803
- hostname,
1804
- port,
1805
- method: "POST",
1806
- headers,
1807
- path: resolvedPath,
1808
- body,
1809
- });
1148
+ b.m("POST").h(headers).b(body);
1149
+ return b.build();
1810
1150
  };
1811
1151
  export const se_SearchGroupProfilesCommand = async (input, context) => {
1812
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1152
+ const b = rb(input, context);
1813
1153
  const headers = {
1814
1154
  "content-type": "application/json",
1815
1155
  };
1816
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1817
- "/v2/domains/{domainIdentifier}/search-group-profiles";
1818
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1156
+ b.bp("/v2/domains/{domainIdentifier}/search-group-profiles");
1157
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1819
1158
  let body;
1820
1159
  body = JSON.stringify(take(input, {
1821
1160
  groupType: [],
@@ -1823,24 +1162,16 @@ export const se_SearchGroupProfilesCommand = async (input, context) => {
1823
1162
  nextToken: [],
1824
1163
  searchText: [],
1825
1164
  }));
1826
- return new __HttpRequest({
1827
- protocol,
1828
- hostname,
1829
- port,
1830
- method: "POST",
1831
- headers,
1832
- path: resolvedPath,
1833
- body,
1834
- });
1165
+ b.m("POST").h(headers).b(body);
1166
+ return b.build();
1835
1167
  };
1836
1168
  export const se_SearchListingsCommand = async (input, context) => {
1837
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1169
+ const b = rb(input, context);
1838
1170
  const headers = {
1839
1171
  "content-type": "application/json",
1840
1172
  };
1841
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1842
- "/v2/domains/{domainIdentifier}/listings/search";
1843
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1173
+ b.bp("/v2/domains/{domainIdentifier}/listings/search");
1174
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1844
1175
  let body;
1845
1176
  body = JSON.stringify(take(input, {
1846
1177
  additionalAttributes: (_) => _json(_),
@@ -1851,24 +1182,16 @@ export const se_SearchListingsCommand = async (input, context) => {
1851
1182
  searchText: [],
1852
1183
  sort: (_) => _json(_),
1853
1184
  }));
1854
- return new __HttpRequest({
1855
- protocol,
1856
- hostname,
1857
- port,
1858
- method: "POST",
1859
- headers,
1860
- path: resolvedPath,
1861
- body,
1862
- });
1185
+ b.m("POST").h(headers).b(body);
1186
+ return b.build();
1863
1187
  };
1864
1188
  export const se_SearchTypesCommand = async (input, context) => {
1865
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1189
+ const b = rb(input, context);
1866
1190
  const headers = {
1867
1191
  "content-type": "application/json",
1868
1192
  };
1869
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1870
- "/v2/domains/{domainIdentifier}/types-search";
1871
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1193
+ b.bp("/v2/domains/{domainIdentifier}/types-search");
1194
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1872
1195
  let body;
1873
1196
  body = JSON.stringify(take(input, {
1874
1197
  filters: (_) => se_FilterClause(_, context),
@@ -1880,24 +1203,16 @@ export const se_SearchTypesCommand = async (input, context) => {
1880
1203
  searchText: [],
1881
1204
  sort: (_) => _json(_),
1882
1205
  }));
1883
- return new __HttpRequest({
1884
- protocol,
1885
- hostname,
1886
- port,
1887
- method: "POST",
1888
- headers,
1889
- path: resolvedPath,
1890
- body,
1891
- });
1206
+ b.m("POST").h(headers).b(body);
1207
+ return b.build();
1892
1208
  };
1893
1209
  export const se_SearchUserProfilesCommand = async (input, context) => {
1894
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1210
+ const b = rb(input, context);
1895
1211
  const headers = {
1896
1212
  "content-type": "application/json",
1897
1213
  };
1898
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1899
- "/v2/domains/{domainIdentifier}/search-user-profiles";
1900
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1214
+ b.bp("/v2/domains/{domainIdentifier}/search-user-profiles");
1215
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1901
1216
  let body;
1902
1217
  body = JSON.stringify(take(input, {
1903
1218
  maxResults: [],
@@ -1905,92 +1220,61 @@ export const se_SearchUserProfilesCommand = async (input, context) => {
1905
1220
  searchText: [],
1906
1221
  userType: [],
1907
1222
  }));
1908
- return new __HttpRequest({
1909
- protocol,
1910
- hostname,
1911
- port,
1912
- method: "POST",
1913
- headers,
1914
- path: resolvedPath,
1915
- body,
1916
- });
1223
+ b.m("POST").h(headers).b(body);
1224
+ return b.build();
1917
1225
  };
1918
1226
  export const se_StartDataSourceRunCommand = async (input, context) => {
1919
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1227
+ const b = rb(input, context);
1920
1228
  const headers = {
1921
1229
  "content-type": "application/json",
1922
1230
  };
1923
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1924
- "/v2/domains/{domainIdentifier}/data-sources/{dataSourceIdentifier}/runs";
1925
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1926
- resolvedPath = __resolvedPath(resolvedPath, input, "dataSourceIdentifier", () => input.dataSourceIdentifier, "{dataSourceIdentifier}", false);
1231
+ b.bp("/v2/domains/{domainIdentifier}/data-sources/{dataSourceIdentifier}/runs");
1232
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1233
+ b.p("dataSourceIdentifier", () => input.dataSourceIdentifier, "{dataSourceIdentifier}", false);
1927
1234
  let body;
1928
1235
  body = JSON.stringify(take(input, {
1929
1236
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
1930
1237
  }));
1931
- return new __HttpRequest({
1932
- protocol,
1933
- hostname,
1934
- port,
1935
- method: "POST",
1936
- headers,
1937
- path: resolvedPath,
1938
- body,
1939
- });
1238
+ b.m("POST").h(headers).b(body);
1239
+ return b.build();
1940
1240
  };
1941
1241
  export const se_TagResourceCommand = async (input, context) => {
1942
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1242
+ const b = rb(input, context);
1943
1243
  const headers = {
1944
1244
  "content-type": "application/json",
1945
1245
  };
1946
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
1947
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
1246
+ b.bp("/tags/{resourceArn}");
1247
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
1948
1248
  let body;
1949
1249
  body = JSON.stringify(take(input, {
1950
1250
  tags: (_) => _json(_),
1951
1251
  }));
1952
- return new __HttpRequest({
1953
- protocol,
1954
- hostname,
1955
- port,
1956
- method: "POST",
1957
- headers,
1958
- path: resolvedPath,
1959
- body,
1960
- });
1252
+ b.m("POST").h(headers).b(body);
1253
+ return b.build();
1961
1254
  };
1962
1255
  export const se_UntagResourceCommand = async (input, context) => {
1963
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1256
+ const b = rb(input, context);
1964
1257
  const headers = {};
1965
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
1966
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
1258
+ b.bp("/tags/{resourceArn}");
1259
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
1967
1260
  const query = map({
1968
- tagKeys: [
1261
+ [_tK]: [
1969
1262
  __expectNonNull(input.tagKeys, `tagKeys`) != null,
1970
- () => (input.tagKeys || []).map((_entry) => _entry),
1263
+ () => (input[_tK] || []).map((_entry) => _entry),
1971
1264
  ],
1972
1265
  });
1973
1266
  let body;
1974
- return new __HttpRequest({
1975
- protocol,
1976
- hostname,
1977
- port,
1978
- method: "DELETE",
1979
- headers,
1980
- path: resolvedPath,
1981
- query,
1982
- body,
1983
- });
1267
+ b.m("DELETE").h(headers).q(query).b(body);
1268
+ return b.build();
1984
1269
  };
1985
1270
  export const se_UpdateDataSourceCommand = async (input, context) => {
1986
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1271
+ const b = rb(input, context);
1987
1272
  const headers = {
1988
1273
  "content-type": "application/json",
1989
1274
  };
1990
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1991
- "/v2/domains/{domainIdentifier}/data-sources/{identifier}";
1992
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1993
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
1275
+ b.bp("/v2/domains/{domainIdentifier}/data-sources/{identifier}");
1276
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1277
+ b.p("identifier", () => input.identifier, "{identifier}", false);
1994
1278
  let body;
1995
1279
  body = JSON.stringify(take(input, {
1996
1280
  assetFormsInput: (_) => _json(_),
@@ -2002,25 +1286,18 @@ export const se_UpdateDataSourceCommand = async (input, context) => {
2002
1286
  recommendation: (_) => _json(_),
2003
1287
  schedule: (_) => _json(_),
2004
1288
  }));
2005
- return new __HttpRequest({
2006
- protocol,
2007
- hostname,
2008
- port,
2009
- method: "PATCH",
2010
- headers,
2011
- path: resolvedPath,
2012
- body,
2013
- });
1289
+ b.m("PATCH").h(headers).b(body);
1290
+ return b.build();
2014
1291
  };
2015
1292
  export const se_UpdateDomainCommand = async (input, context) => {
2016
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1293
+ const b = rb(input, context);
2017
1294
  const headers = {
2018
1295
  "content-type": "application/json",
2019
1296
  };
2020
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/domains/{identifier}";
2021
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
1297
+ b.bp("/v2/domains/{identifier}");
1298
+ b.p("identifier", () => input.identifier, "{identifier}", false);
2022
1299
  const query = map({
2023
- clientToken: [, input.clientToken ?? generateIdempotencyToken()],
1300
+ [_cT]: [, input[_cT] ?? generateIdempotencyToken()],
2024
1301
  });
2025
1302
  let body;
2026
1303
  body = JSON.stringify(take(input, {
@@ -2029,51 +1306,34 @@ export const se_UpdateDomainCommand = async (input, context) => {
2029
1306
  name: [],
2030
1307
  singleSignOn: (_) => _json(_),
2031
1308
  }));
2032
- return new __HttpRequest({
2033
- protocol,
2034
- hostname,
2035
- port,
2036
- method: "PUT",
2037
- headers,
2038
- path: resolvedPath,
2039
- query,
2040
- body,
2041
- });
1309
+ b.m("PUT").h(headers).q(query).b(body);
1310
+ return b.build();
2042
1311
  };
2043
1312
  export const se_UpdateEnvironmentCommand = async (input, context) => {
2044
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1313
+ const b = rb(input, context);
2045
1314
  const headers = {
2046
1315
  "content-type": "application/json",
2047
1316
  };
2048
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2049
- "/v2/domains/{domainIdentifier}/environments/{identifier}";
2050
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
2051
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
1317
+ b.bp("/v2/domains/{domainIdentifier}/environments/{identifier}");
1318
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1319
+ b.p("identifier", () => input.identifier, "{identifier}", false);
2052
1320
  let body;
2053
1321
  body = JSON.stringify(take(input, {
2054
1322
  description: [],
2055
1323
  glossaryTerms: (_) => _json(_),
2056
1324
  name: [],
2057
1325
  }));
2058
- return new __HttpRequest({
2059
- protocol,
2060
- hostname,
2061
- port,
2062
- method: "PATCH",
2063
- headers,
2064
- path: resolvedPath,
2065
- body,
2066
- });
1326
+ b.m("PATCH").h(headers).b(body);
1327
+ return b.build();
2067
1328
  };
2068
1329
  export const se_UpdateEnvironmentProfileCommand = async (input, context) => {
2069
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1330
+ const b = rb(input, context);
2070
1331
  const headers = {
2071
1332
  "content-type": "application/json",
2072
1333
  };
2073
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2074
- "/v2/domains/{domainIdentifier}/environment-profiles/{identifier}";
2075
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
2076
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
1334
+ b.bp("/v2/domains/{domainIdentifier}/environment-profiles/{identifier}");
1335
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1336
+ b.p("identifier", () => input.identifier, "{identifier}", false);
2077
1337
  let body;
2078
1338
  body = JSON.stringify(take(input, {
2079
1339
  awsAccountId: [],
@@ -2082,25 +1342,17 @@ export const se_UpdateEnvironmentProfileCommand = async (input, context) => {
2082
1342
  name: [],
2083
1343
  userParameters: (_) => _json(_),
2084
1344
  }));
2085
- return new __HttpRequest({
2086
- protocol,
2087
- hostname,
2088
- port,
2089
- method: "PATCH",
2090
- headers,
2091
- path: resolvedPath,
2092
- body,
2093
- });
1345
+ b.m("PATCH").h(headers).b(body);
1346
+ return b.build();
2094
1347
  };
2095
1348
  export const se_UpdateGlossaryCommand = async (input, context) => {
2096
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1349
+ const b = rb(input, context);
2097
1350
  const headers = {
2098
1351
  "content-type": "application/json",
2099
1352
  };
2100
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2101
- "/v2/domains/{domainIdentifier}/glossaries/{identifier}";
2102
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
2103
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
1353
+ b.bp("/v2/domains/{domainIdentifier}/glossaries/{identifier}");
1354
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1355
+ b.p("identifier", () => input.identifier, "{identifier}", false);
2104
1356
  let body;
2105
1357
  body = JSON.stringify(take(input, {
2106
1358
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -2108,25 +1360,17 @@ export const se_UpdateGlossaryCommand = async (input, context) => {
2108
1360
  name: [],
2109
1361
  status: [],
2110
1362
  }));
2111
- return new __HttpRequest({
2112
- protocol,
2113
- hostname,
2114
- port,
2115
- method: "PATCH",
2116
- headers,
2117
- path: resolvedPath,
2118
- body,
2119
- });
1363
+ b.m("PATCH").h(headers).b(body);
1364
+ return b.build();
2120
1365
  };
2121
1366
  export const se_UpdateGlossaryTermCommand = async (input, context) => {
2122
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1367
+ const b = rb(input, context);
2123
1368
  const headers = {
2124
1369
  "content-type": "application/json",
2125
1370
  };
2126
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2127
- "/v2/domains/{domainIdentifier}/glossary-terms/{identifier}";
2128
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
2129
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
1371
+ b.bp("/v2/domains/{domainIdentifier}/glossary-terms/{identifier}");
1372
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1373
+ b.p("identifier", () => input.identifier, "{identifier}", false);
2130
1374
  let body;
2131
1375
  body = JSON.stringify(take(input, {
2132
1376
  glossaryIdentifier: [],
@@ -2136,123 +1380,83 @@ export const se_UpdateGlossaryTermCommand = async (input, context) => {
2136
1380
  status: [],
2137
1381
  termRelations: (_) => _json(_),
2138
1382
  }));
2139
- return new __HttpRequest({
2140
- protocol,
2141
- hostname,
2142
- port,
2143
- method: "PATCH",
2144
- headers,
2145
- path: resolvedPath,
2146
- body,
2147
- });
1383
+ b.m("PATCH").h(headers).b(body);
1384
+ return b.build();
2148
1385
  };
2149
1386
  export const se_UpdateGroupProfileCommand = async (input, context) => {
2150
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1387
+ const b = rb(input, context);
2151
1388
  const headers = {
2152
1389
  "content-type": "application/json",
2153
1390
  };
2154
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2155
- "/v2/domains/{domainIdentifier}/group-profiles/{groupIdentifier}";
2156
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
2157
- resolvedPath = __resolvedPath(resolvedPath, input, "groupIdentifier", () => input.groupIdentifier, "{groupIdentifier}", false);
1391
+ b.bp("/v2/domains/{domainIdentifier}/group-profiles/{groupIdentifier}");
1392
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1393
+ b.p("groupIdentifier", () => input.groupIdentifier, "{groupIdentifier}", false);
2158
1394
  let body;
2159
1395
  body = JSON.stringify(take(input, {
2160
1396
  status: [],
2161
1397
  }));
2162
- return new __HttpRequest({
2163
- protocol,
2164
- hostname,
2165
- port,
2166
- method: "PUT",
2167
- headers,
2168
- path: resolvedPath,
2169
- body,
2170
- });
1398
+ b.m("PUT").h(headers).b(body);
1399
+ return b.build();
2171
1400
  };
2172
1401
  export const se_UpdateProjectCommand = async (input, context) => {
2173
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1402
+ const b = rb(input, context);
2174
1403
  const headers = {
2175
1404
  "content-type": "application/json",
2176
1405
  };
2177
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2178
- "/v2/domains/{domainIdentifier}/projects/{identifier}";
2179
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
2180
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
1406
+ b.bp("/v2/domains/{domainIdentifier}/projects/{identifier}");
1407
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1408
+ b.p("identifier", () => input.identifier, "{identifier}", false);
2181
1409
  let body;
2182
1410
  body = JSON.stringify(take(input, {
2183
1411
  description: [],
2184
1412
  glossaryTerms: (_) => _json(_),
2185
1413
  name: [],
2186
1414
  }));
2187
- return new __HttpRequest({
2188
- protocol,
2189
- hostname,
2190
- port,
2191
- method: "PATCH",
2192
- headers,
2193
- path: resolvedPath,
2194
- body,
2195
- });
1415
+ b.m("PATCH").h(headers).b(body);
1416
+ return b.build();
2196
1417
  };
2197
1418
  export const se_UpdateSubscriptionGrantStatusCommand = async (input, context) => {
2198
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1419
+ const b = rb(input, context);
2199
1420
  const headers = {
2200
1421
  "content-type": "application/json",
2201
1422
  };
2202
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2203
- "/v2/domains/{domainIdentifier}/subscription-grants/{identifier}/status/{assetIdentifier}";
2204
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
2205
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
2206
- resolvedPath = __resolvedPath(resolvedPath, input, "assetIdentifier", () => input.assetIdentifier, "{assetIdentifier}", false);
1423
+ b.bp("/v2/domains/{domainIdentifier}/subscription-grants/{identifier}/status/{assetIdentifier}");
1424
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1425
+ b.p("identifier", () => input.identifier, "{identifier}", false);
1426
+ b.p("assetIdentifier", () => input.assetIdentifier, "{assetIdentifier}", false);
2207
1427
  let body;
2208
1428
  body = JSON.stringify(take(input, {
2209
1429
  failureCause: (_) => _json(_),
2210
1430
  status: [],
2211
1431
  targetName: [],
2212
1432
  }));
2213
- return new __HttpRequest({
2214
- protocol,
2215
- hostname,
2216
- port,
2217
- method: "PATCH",
2218
- headers,
2219
- path: resolvedPath,
2220
- body,
2221
- });
1433
+ b.m("PATCH").h(headers).b(body);
1434
+ return b.build();
2222
1435
  };
2223
1436
  export const se_UpdateSubscriptionRequestCommand = async (input, context) => {
2224
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1437
+ const b = rb(input, context);
2225
1438
  const headers = {
2226
1439
  "content-type": "application/json",
2227
1440
  };
2228
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2229
- "/v2/domains/{domainIdentifier}/subscription-requests/{identifier}";
2230
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
2231
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
1441
+ b.bp("/v2/domains/{domainIdentifier}/subscription-requests/{identifier}");
1442
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1443
+ b.p("identifier", () => input.identifier, "{identifier}", false);
2232
1444
  let body;
2233
1445
  body = JSON.stringify(take(input, {
2234
1446
  requestReason: [],
2235
1447
  }));
2236
- return new __HttpRequest({
2237
- protocol,
2238
- hostname,
2239
- port,
2240
- method: "PATCH",
2241
- headers,
2242
- path: resolvedPath,
2243
- body,
2244
- });
1448
+ b.m("PATCH").h(headers).b(body);
1449
+ return b.build();
2245
1450
  };
2246
1451
  export const se_UpdateSubscriptionTargetCommand = async (input, context) => {
2247
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1452
+ const b = rb(input, context);
2248
1453
  const headers = {
2249
1454
  "content-type": "application/json",
2250
1455
  };
2251
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2252
- "/v2/domains/{domainIdentifier}/environments/{environmentIdentifier}/subscription-targets/{identifier}";
2253
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
2254
- resolvedPath = __resolvedPath(resolvedPath, input, "environmentIdentifier", () => input.environmentIdentifier, "{environmentIdentifier}", false);
2255
- resolvedPath = __resolvedPath(resolvedPath, input, "identifier", () => input.identifier, "{identifier}", false);
1456
+ b.bp("/v2/domains/{domainIdentifier}/environments/{environmentIdentifier}/subscription-targets/{identifier}");
1457
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1458
+ b.p("environmentIdentifier", () => input.environmentIdentifier, "{environmentIdentifier}", false);
1459
+ b.p("identifier", () => input.identifier, "{identifier}", false);
2256
1460
  let body;
2257
1461
  body = JSON.stringify(take(input, {
2258
1462
  applicableAssetTypes: (_) => _json(_),
@@ -2262,39 +1466,24 @@ export const se_UpdateSubscriptionTargetCommand = async (input, context) => {
2262
1466
  provider: [],
2263
1467
  subscriptionTargetConfig: (_) => _json(_),
2264
1468
  }));
2265
- return new __HttpRequest({
2266
- protocol,
2267
- hostname,
2268
- port,
2269
- method: "PATCH",
2270
- headers,
2271
- path: resolvedPath,
2272
- body,
2273
- });
1469
+ b.m("PATCH").h(headers).b(body);
1470
+ return b.build();
2274
1471
  };
2275
1472
  export const se_UpdateUserProfileCommand = async (input, context) => {
2276
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1473
+ const b = rb(input, context);
2277
1474
  const headers = {
2278
1475
  "content-type": "application/json",
2279
1476
  };
2280
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2281
- "/v2/domains/{domainIdentifier}/user-profiles/{userIdentifier}";
2282
- resolvedPath = __resolvedPath(resolvedPath, input, "domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
2283
- resolvedPath = __resolvedPath(resolvedPath, input, "userIdentifier", () => input.userIdentifier, "{userIdentifier}", false);
1477
+ b.bp("/v2/domains/{domainIdentifier}/user-profiles/{userIdentifier}");
1478
+ b.p("domainIdentifier", () => input.domainIdentifier, "{domainIdentifier}", false);
1479
+ b.p("userIdentifier", () => input.userIdentifier, "{userIdentifier}", false);
2284
1480
  let body;
2285
1481
  body = JSON.stringify(take(input, {
2286
1482
  status: [],
2287
1483
  type: [],
2288
1484
  }));
2289
- return new __HttpRequest({
2290
- protocol,
2291
- hostname,
2292
- port,
2293
- method: "PUT",
2294
- headers,
2295
- path: resolvedPath,
2296
- body,
2297
- });
1485
+ b.m("PUT").h(headers).b(body);
1486
+ return b.build();
2298
1487
  };
2299
1488
  export const de_AcceptPredictionsCommand = async (output, context) => {
2300
1489
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -8491,6 +7680,38 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
8491
7680
  value !== "" &&
8492
7681
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
8493
7682
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
7683
+ const _aAI = "awsAccountId";
7684
+ const _aAR = "awsAccountRegion";
7685
+ const _aPI = "approverProjectId";
7686
+ const _aT = "afterTimestamp";
7687
+ const _bT = "beforeTimestamp";
7688
+ const _cT = "clientToken";
7689
+ const _eBI = "environmentBlueprintIdentifier";
7690
+ const _eI = "environmentIdentifier";
7691
+ const _eIn = "environmentId";
7692
+ const _ePI = "environmentProfileIdentifier";
7693
+ const _gI = "groupIdentifier";
7694
+ const _lR = "listingRevision";
7695
+ const _m = "managed";
7696
+ const _mR = "maxResults";
7697
+ const _n = "name";
7698
+ const _nT = "nextToken";
7699
+ const _oPI = "owningProjectId";
7700
+ const _p = "provider";
7701
+ const _pI = "projectIdentifier";
7702
+ const _r = "revision";
7703
+ const _s = "status";
7704
+ const _sB = "sortBy";
7705
+ const _sI = "subscriptionId";
7706
+ const _sLI = "subscribedListingId";
7707
+ const _sO = "sortOrder";
7708
+ const _sRI = "subscriptionRequestIdentifier";
7709
+ const _sTI = "subscriptionTargetId";
7710
+ const _su = "subjects";
7711
+ const _t = "type";
7712
+ const _tK = "tagKeys";
7713
+ const _tS = "taskStatus";
7714
+ const _uI = "userIdentifier";
8494
7715
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
8495
7716
  if (encoded.length) {
8496
7717
  return JSON.parse(encoded);