@aws-sdk/client-databrew 3.476.0 → 3.477.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist-cjs/protocols/Aws_restJson1.js +253 -554
  2. package/dist-es/protocols/Aws_restJson1.js +254 -555
  3. package/package.json +5 -4
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,34 +1,27 @@
1
- import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
2
- import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
1
+ import { requestBuilder as rb } from "@smithy/core";
2
+ import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseEpochTimestamp as __parseEpochTimestamp, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
3
3
  import { DataBrewServiceException as __BaseException } from "../models/DataBrewServiceException";
4
4
  import { AccessDeniedException, ConflictException, InternalServerException, ResourceNotFoundException, ServiceQuotaExceededException, ValidationException, } from "../models/models_0";
5
5
  export const se_BatchDeleteRecipeVersionCommand = async (input, context) => {
6
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
6
+ const b = rb(input, context);
7
7
  const headers = {
8
8
  "content-type": "application/json",
9
9
  };
10
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/recipes/{Name}/batchDeleteRecipeVersion";
11
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
10
+ b.bp("/recipes/{Name}/batchDeleteRecipeVersion");
11
+ b.p("Name", () => input.Name, "{Name}", false);
12
12
  let body;
13
13
  body = JSON.stringify(take(input, {
14
14
  RecipeVersions: (_) => _json(_),
15
15
  }));
16
- return new __HttpRequest({
17
- protocol,
18
- hostname,
19
- port,
20
- method: "POST",
21
- headers,
22
- path: resolvedPath,
23
- body,
24
- });
16
+ b.m("POST").h(headers).b(body);
17
+ return b.build();
25
18
  };
26
19
  export const se_CreateDatasetCommand = async (input, context) => {
27
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
20
+ const b = rb(input, context);
28
21
  const headers = {
29
22
  "content-type": "application/json",
30
23
  };
31
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/datasets";
24
+ b.bp("/datasets");
32
25
  let body;
33
26
  body = JSON.stringify(take(input, {
34
27
  Format: [],
@@ -38,22 +31,15 @@ export const se_CreateDatasetCommand = async (input, context) => {
38
31
  PathOptions: (_) => _json(_),
39
32
  Tags: (_) => _json(_),
40
33
  }));
41
- return new __HttpRequest({
42
- protocol,
43
- hostname,
44
- port,
45
- method: "POST",
46
- headers,
47
- path: resolvedPath,
48
- body,
49
- });
34
+ b.m("POST").h(headers).b(body);
35
+ return b.build();
50
36
  };
51
37
  export const se_CreateProfileJobCommand = async (input, context) => {
52
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
38
+ const b = rb(input, context);
53
39
  const headers = {
54
40
  "content-type": "application/json",
55
41
  };
56
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/profileJobs";
42
+ b.bp("/profileJobs");
57
43
  let body;
58
44
  body = JSON.stringify(take(input, {
59
45
  Configuration: (_) => _json(_),
@@ -71,22 +57,15 @@ export const se_CreateProfileJobCommand = async (input, context) => {
71
57
  Timeout: [],
72
58
  ValidationConfigurations: (_) => _json(_),
73
59
  }));
74
- return new __HttpRequest({
75
- protocol,
76
- hostname,
77
- port,
78
- method: "POST",
79
- headers,
80
- path: resolvedPath,
81
- body,
82
- });
60
+ b.m("POST").h(headers).b(body);
61
+ return b.build();
83
62
  };
84
63
  export const se_CreateProjectCommand = async (input, context) => {
85
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
64
+ const b = rb(input, context);
86
65
  const headers = {
87
66
  "content-type": "application/json",
88
67
  };
89
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/projects";
68
+ b.bp("/projects");
90
69
  let body;
91
70
  body = JSON.stringify(take(input, {
92
71
  DatasetName: [],
@@ -96,22 +75,15 @@ export const se_CreateProjectCommand = async (input, context) => {
96
75
  Sample: (_) => _json(_),
97
76
  Tags: (_) => _json(_),
98
77
  }));
99
- return new __HttpRequest({
100
- protocol,
101
- hostname,
102
- port,
103
- method: "POST",
104
- headers,
105
- path: resolvedPath,
106
- body,
107
- });
78
+ b.m("POST").h(headers).b(body);
79
+ return b.build();
108
80
  };
109
81
  export const se_CreateRecipeCommand = async (input, context) => {
110
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
82
+ const b = rb(input, context);
111
83
  const headers = {
112
84
  "content-type": "application/json",
113
85
  };
114
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/recipes";
86
+ b.bp("/recipes");
115
87
  let body;
116
88
  body = JSON.stringify(take(input, {
117
89
  Description: [],
@@ -119,22 +91,15 @@ export const se_CreateRecipeCommand = async (input, context) => {
119
91
  Steps: (_) => _json(_),
120
92
  Tags: (_) => _json(_),
121
93
  }));
122
- return new __HttpRequest({
123
- protocol,
124
- hostname,
125
- port,
126
- method: "POST",
127
- headers,
128
- path: resolvedPath,
129
- body,
130
- });
94
+ b.m("POST").h(headers).b(body);
95
+ return b.build();
131
96
  };
132
97
  export const se_CreateRecipeJobCommand = async (input, context) => {
133
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
98
+ const b = rb(input, context);
134
99
  const headers = {
135
100
  "content-type": "application/json",
136
101
  };
137
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/recipeJobs";
102
+ b.bp("/recipeJobs");
138
103
  let body;
139
104
  body = JSON.stringify(take(input, {
140
105
  DataCatalogOutputs: (_) => _json(_),
@@ -153,22 +118,15 @@ export const se_CreateRecipeJobCommand = async (input, context) => {
153
118
  Tags: (_) => _json(_),
154
119
  Timeout: [],
155
120
  }));
156
- return new __HttpRequest({
157
- protocol,
158
- hostname,
159
- port,
160
- method: "POST",
161
- headers,
162
- path: resolvedPath,
163
- body,
164
- });
121
+ b.m("POST").h(headers).b(body);
122
+ return b.build();
165
123
  };
166
124
  export const se_CreateRulesetCommand = async (input, context) => {
167
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
125
+ const b = rb(input, context);
168
126
  const headers = {
169
127
  "content-type": "application/json",
170
128
  };
171
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/rulesets";
129
+ b.bp("/rulesets");
172
130
  let body;
173
131
  body = JSON.stringify(take(input, {
174
132
  Description: [],
@@ -177,22 +135,15 @@ export const se_CreateRulesetCommand = async (input, context) => {
177
135
  Tags: (_) => _json(_),
178
136
  TargetArn: [],
179
137
  }));
180
- return new __HttpRequest({
181
- protocol,
182
- hostname,
183
- port,
184
- method: "POST",
185
- headers,
186
- path: resolvedPath,
187
- body,
188
- });
138
+ b.m("POST").h(headers).b(body);
139
+ return b.build();
189
140
  };
190
141
  export const se_CreateScheduleCommand = async (input, context) => {
191
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
142
+ const b = rb(input, context);
192
143
  const headers = {
193
144
  "content-type": "application/json",
194
145
  };
195
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/schedules";
146
+ b.bp("/schedules");
196
147
  let body;
197
148
  body = JSON.stringify(take(input, {
198
149
  CronExpression: [],
@@ -200,442 +151,264 @@ export const se_CreateScheduleCommand = async (input, context) => {
200
151
  Name: [],
201
152
  Tags: (_) => _json(_),
202
153
  }));
203
- return new __HttpRequest({
204
- protocol,
205
- hostname,
206
- port,
207
- method: "POST",
208
- headers,
209
- path: resolvedPath,
210
- body,
211
- });
154
+ b.m("POST").h(headers).b(body);
155
+ return b.build();
212
156
  };
213
157
  export const se_DeleteDatasetCommand = async (input, context) => {
214
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
158
+ const b = rb(input, context);
215
159
  const headers = {};
216
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/datasets/{Name}";
217
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
160
+ b.bp("/datasets/{Name}");
161
+ b.p("Name", () => input.Name, "{Name}", false);
218
162
  let body;
219
- return new __HttpRequest({
220
- protocol,
221
- hostname,
222
- port,
223
- method: "DELETE",
224
- headers,
225
- path: resolvedPath,
226
- body,
227
- });
163
+ b.m("DELETE").h(headers).b(body);
164
+ return b.build();
228
165
  };
229
166
  export const se_DeleteJobCommand = async (input, context) => {
230
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
167
+ const b = rb(input, context);
231
168
  const headers = {};
232
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/jobs/{Name}";
233
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
169
+ b.bp("/jobs/{Name}");
170
+ b.p("Name", () => input.Name, "{Name}", false);
234
171
  let body;
235
- return new __HttpRequest({
236
- protocol,
237
- hostname,
238
- port,
239
- method: "DELETE",
240
- headers,
241
- path: resolvedPath,
242
- body,
243
- });
172
+ b.m("DELETE").h(headers).b(body);
173
+ return b.build();
244
174
  };
245
175
  export const se_DeleteProjectCommand = async (input, context) => {
246
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
176
+ const b = rb(input, context);
247
177
  const headers = {};
248
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/projects/{Name}";
249
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
178
+ b.bp("/projects/{Name}");
179
+ b.p("Name", () => input.Name, "{Name}", false);
250
180
  let body;
251
- return new __HttpRequest({
252
- protocol,
253
- hostname,
254
- port,
255
- method: "DELETE",
256
- headers,
257
- path: resolvedPath,
258
- body,
259
- });
181
+ b.m("DELETE").h(headers).b(body);
182
+ return b.build();
260
183
  };
261
184
  export const se_DeleteRecipeVersionCommand = async (input, context) => {
262
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
185
+ const b = rb(input, context);
263
186
  const headers = {};
264
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
265
- "/recipes/{Name}/recipeVersion/{RecipeVersion}";
266
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
267
- resolvedPath = __resolvedPath(resolvedPath, input, "RecipeVersion", () => input.RecipeVersion, "{RecipeVersion}", false);
187
+ b.bp("/recipes/{Name}/recipeVersion/{RecipeVersion}");
188
+ b.p("Name", () => input.Name, "{Name}", false);
189
+ b.p("RecipeVersion", () => input.RecipeVersion, "{RecipeVersion}", false);
268
190
  let body;
269
- return new __HttpRequest({
270
- protocol,
271
- hostname,
272
- port,
273
- method: "DELETE",
274
- headers,
275
- path: resolvedPath,
276
- body,
277
- });
191
+ b.m("DELETE").h(headers).b(body);
192
+ return b.build();
278
193
  };
279
194
  export const se_DeleteRulesetCommand = async (input, context) => {
280
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
195
+ const b = rb(input, context);
281
196
  const headers = {};
282
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/rulesets/{Name}";
283
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
197
+ b.bp("/rulesets/{Name}");
198
+ b.p("Name", () => input.Name, "{Name}", false);
284
199
  let body;
285
- return new __HttpRequest({
286
- protocol,
287
- hostname,
288
- port,
289
- method: "DELETE",
290
- headers,
291
- path: resolvedPath,
292
- body,
293
- });
200
+ b.m("DELETE").h(headers).b(body);
201
+ return b.build();
294
202
  };
295
203
  export const se_DeleteScheduleCommand = async (input, context) => {
296
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
204
+ const b = rb(input, context);
297
205
  const headers = {};
298
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/schedules/{Name}";
299
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
206
+ b.bp("/schedules/{Name}");
207
+ b.p("Name", () => input.Name, "{Name}", false);
300
208
  let body;
301
- return new __HttpRequest({
302
- protocol,
303
- hostname,
304
- port,
305
- method: "DELETE",
306
- headers,
307
- path: resolvedPath,
308
- body,
309
- });
209
+ b.m("DELETE").h(headers).b(body);
210
+ return b.build();
310
211
  };
311
212
  export const se_DescribeDatasetCommand = async (input, context) => {
312
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
213
+ const b = rb(input, context);
313
214
  const headers = {};
314
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/datasets/{Name}";
315
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
215
+ b.bp("/datasets/{Name}");
216
+ b.p("Name", () => input.Name, "{Name}", false);
316
217
  let body;
317
- return new __HttpRequest({
318
- protocol,
319
- hostname,
320
- port,
321
- method: "GET",
322
- headers,
323
- path: resolvedPath,
324
- body,
325
- });
218
+ b.m("GET").h(headers).b(body);
219
+ return b.build();
326
220
  };
327
221
  export const se_DescribeJobCommand = async (input, context) => {
328
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
222
+ const b = rb(input, context);
329
223
  const headers = {};
330
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/jobs/{Name}";
331
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
224
+ b.bp("/jobs/{Name}");
225
+ b.p("Name", () => input.Name, "{Name}", false);
332
226
  let body;
333
- return new __HttpRequest({
334
- protocol,
335
- hostname,
336
- port,
337
- method: "GET",
338
- headers,
339
- path: resolvedPath,
340
- body,
341
- });
227
+ b.m("GET").h(headers).b(body);
228
+ return b.build();
342
229
  };
343
230
  export const se_DescribeJobRunCommand = async (input, context) => {
344
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
231
+ const b = rb(input, context);
345
232
  const headers = {};
346
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/jobs/{Name}/jobRun/{RunId}";
347
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
348
- resolvedPath = __resolvedPath(resolvedPath, input, "RunId", () => input.RunId, "{RunId}", false);
233
+ b.bp("/jobs/{Name}/jobRun/{RunId}");
234
+ b.p("Name", () => input.Name, "{Name}", false);
235
+ b.p("RunId", () => input.RunId, "{RunId}", false);
349
236
  let body;
350
- return new __HttpRequest({
351
- protocol,
352
- hostname,
353
- port,
354
- method: "GET",
355
- headers,
356
- path: resolvedPath,
357
- body,
358
- });
237
+ b.m("GET").h(headers).b(body);
238
+ return b.build();
359
239
  };
360
240
  export const se_DescribeProjectCommand = async (input, context) => {
361
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
241
+ const b = rb(input, context);
362
242
  const headers = {};
363
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/projects/{Name}";
364
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
243
+ b.bp("/projects/{Name}");
244
+ b.p("Name", () => input.Name, "{Name}", false);
365
245
  let body;
366
- return new __HttpRequest({
367
- protocol,
368
- hostname,
369
- port,
370
- method: "GET",
371
- headers,
372
- path: resolvedPath,
373
- body,
374
- });
246
+ b.m("GET").h(headers).b(body);
247
+ return b.build();
375
248
  };
376
249
  export const se_DescribeRecipeCommand = async (input, context) => {
377
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
250
+ const b = rb(input, context);
378
251
  const headers = {};
379
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/recipes/{Name}";
380
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
252
+ b.bp("/recipes/{Name}");
253
+ b.p("Name", () => input.Name, "{Name}", false);
381
254
  const query = map({
382
- recipeVersion: [, input.RecipeVersion],
255
+ [_rV]: [, input[_RV]],
383
256
  });
384
257
  let body;
385
- return new __HttpRequest({
386
- protocol,
387
- hostname,
388
- port,
389
- method: "GET",
390
- headers,
391
- path: resolvedPath,
392
- query,
393
- body,
394
- });
258
+ b.m("GET").h(headers).q(query).b(body);
259
+ return b.build();
395
260
  };
396
261
  export const se_DescribeRulesetCommand = async (input, context) => {
397
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
262
+ const b = rb(input, context);
398
263
  const headers = {};
399
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/rulesets/{Name}";
400
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
264
+ b.bp("/rulesets/{Name}");
265
+ b.p("Name", () => input.Name, "{Name}", false);
401
266
  let body;
402
- return new __HttpRequest({
403
- protocol,
404
- hostname,
405
- port,
406
- method: "GET",
407
- headers,
408
- path: resolvedPath,
409
- body,
410
- });
267
+ b.m("GET").h(headers).b(body);
268
+ return b.build();
411
269
  };
412
270
  export const se_DescribeScheduleCommand = async (input, context) => {
413
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
271
+ const b = rb(input, context);
414
272
  const headers = {};
415
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/schedules/{Name}";
416
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
273
+ b.bp("/schedules/{Name}");
274
+ b.p("Name", () => input.Name, "{Name}", false);
417
275
  let body;
418
- return new __HttpRequest({
419
- protocol,
420
- hostname,
421
- port,
422
- method: "GET",
423
- headers,
424
- path: resolvedPath,
425
- body,
426
- });
276
+ b.m("GET").h(headers).b(body);
277
+ return b.build();
427
278
  };
428
279
  export const se_ListDatasetsCommand = async (input, context) => {
429
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
280
+ const b = rb(input, context);
430
281
  const headers = {};
431
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/datasets";
282
+ b.bp("/datasets");
432
283
  const query = map({
433
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
434
- nextToken: [, input.NextToken],
284
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
285
+ [_nT]: [, input[_NT]],
435
286
  });
436
287
  let body;
437
- return new __HttpRequest({
438
- protocol,
439
- hostname,
440
- port,
441
- method: "GET",
442
- headers,
443
- path: resolvedPath,
444
- query,
445
- body,
446
- });
288
+ b.m("GET").h(headers).q(query).b(body);
289
+ return b.build();
447
290
  };
448
291
  export const se_ListJobRunsCommand = async (input, context) => {
449
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
292
+ const b = rb(input, context);
450
293
  const headers = {};
451
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/jobs/{Name}/jobRuns";
452
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
294
+ b.bp("/jobs/{Name}/jobRuns");
295
+ b.p("Name", () => input.Name, "{Name}", false);
453
296
  const query = map({
454
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
455
- nextToken: [, input.NextToken],
297
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
298
+ [_nT]: [, input[_NT]],
456
299
  });
457
300
  let body;
458
- return new __HttpRequest({
459
- protocol,
460
- hostname,
461
- port,
462
- method: "GET",
463
- headers,
464
- path: resolvedPath,
465
- query,
466
- body,
467
- });
301
+ b.m("GET").h(headers).q(query).b(body);
302
+ return b.build();
468
303
  };
469
304
  export const se_ListJobsCommand = async (input, context) => {
470
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
305
+ const b = rb(input, context);
471
306
  const headers = {};
472
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/jobs";
307
+ b.bp("/jobs");
473
308
  const query = map({
474
- datasetName: [, input.DatasetName],
475
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
476
- nextToken: [, input.NextToken],
477
- projectName: [, input.ProjectName],
309
+ [_dN]: [, input[_DN]],
310
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
311
+ [_nT]: [, input[_NT]],
312
+ [_pN]: [, input[_PN]],
478
313
  });
479
314
  let body;
480
- return new __HttpRequest({
481
- protocol,
482
- hostname,
483
- port,
484
- method: "GET",
485
- headers,
486
- path: resolvedPath,
487
- query,
488
- body,
489
- });
315
+ b.m("GET").h(headers).q(query).b(body);
316
+ return b.build();
490
317
  };
491
318
  export const se_ListProjectsCommand = async (input, context) => {
492
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
319
+ const b = rb(input, context);
493
320
  const headers = {};
494
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/projects";
321
+ b.bp("/projects");
495
322
  const query = map({
496
- nextToken: [, input.NextToken],
497
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
323
+ [_nT]: [, input[_NT]],
324
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
498
325
  });
499
326
  let body;
500
- return new __HttpRequest({
501
- protocol,
502
- hostname,
503
- port,
504
- method: "GET",
505
- headers,
506
- path: resolvedPath,
507
- query,
508
- body,
509
- });
327
+ b.m("GET").h(headers).q(query).b(body);
328
+ return b.build();
510
329
  };
511
330
  export const se_ListRecipesCommand = async (input, context) => {
512
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
331
+ const b = rb(input, context);
513
332
  const headers = {};
514
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/recipes";
333
+ b.bp("/recipes");
515
334
  const query = map({
516
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
517
- nextToken: [, input.NextToken],
518
- recipeVersion: [, input.RecipeVersion],
335
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
336
+ [_nT]: [, input[_NT]],
337
+ [_rV]: [, input[_RV]],
519
338
  });
520
339
  let body;
521
- return new __HttpRequest({
522
- protocol,
523
- hostname,
524
- port,
525
- method: "GET",
526
- headers,
527
- path: resolvedPath,
528
- query,
529
- body,
530
- });
340
+ b.m("GET").h(headers).q(query).b(body);
341
+ return b.build();
531
342
  };
532
343
  export const se_ListRecipeVersionsCommand = async (input, context) => {
533
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
344
+ const b = rb(input, context);
534
345
  const headers = {};
535
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/recipeVersions";
346
+ b.bp("/recipeVersions");
536
347
  const query = map({
537
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
538
- nextToken: [, input.NextToken],
539
- name: [, __expectNonNull(input.Name, `Name`)],
348
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
349
+ [_nT]: [, input[_NT]],
350
+ [_n]: [, __expectNonNull(input[_N], `Name`)],
540
351
  });
541
352
  let body;
542
- return new __HttpRequest({
543
- protocol,
544
- hostname,
545
- port,
546
- method: "GET",
547
- headers,
548
- path: resolvedPath,
549
- query,
550
- body,
551
- });
353
+ b.m("GET").h(headers).q(query).b(body);
354
+ return b.build();
552
355
  };
553
356
  export const se_ListRulesetsCommand = async (input, context) => {
554
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
357
+ const b = rb(input, context);
555
358
  const headers = {};
556
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/rulesets";
359
+ b.bp("/rulesets");
557
360
  const query = map({
558
- targetArn: [, input.TargetArn],
559
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
560
- nextToken: [, input.NextToken],
361
+ [_tA]: [, input[_TA]],
362
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
363
+ [_nT]: [, input[_NT]],
561
364
  });
562
365
  let body;
563
- return new __HttpRequest({
564
- protocol,
565
- hostname,
566
- port,
567
- method: "GET",
568
- headers,
569
- path: resolvedPath,
570
- query,
571
- body,
572
- });
366
+ b.m("GET").h(headers).q(query).b(body);
367
+ return b.build();
573
368
  };
574
369
  export const se_ListSchedulesCommand = async (input, context) => {
575
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
370
+ const b = rb(input, context);
576
371
  const headers = {};
577
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/schedules";
372
+ b.bp("/schedules");
578
373
  const query = map({
579
- jobName: [, input.JobName],
580
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
581
- nextToken: [, input.NextToken],
374
+ [_jN]: [, input[_JN]],
375
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
376
+ [_nT]: [, input[_NT]],
582
377
  });
583
378
  let body;
584
- return new __HttpRequest({
585
- protocol,
586
- hostname,
587
- port,
588
- method: "GET",
589
- headers,
590
- path: resolvedPath,
591
- query,
592
- body,
593
- });
379
+ b.m("GET").h(headers).q(query).b(body);
380
+ return b.build();
594
381
  };
595
382
  export const se_ListTagsForResourceCommand = async (input, context) => {
596
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
383
+ const b = rb(input, context);
597
384
  const headers = {};
598
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{ResourceArn}";
599
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
385
+ b.bp("/tags/{ResourceArn}");
386
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
600
387
  let body;
601
- return new __HttpRequest({
602
- protocol,
603
- hostname,
604
- port,
605
- method: "GET",
606
- headers,
607
- path: resolvedPath,
608
- body,
609
- });
388
+ b.m("GET").h(headers).b(body);
389
+ return b.build();
610
390
  };
611
391
  export const se_PublishRecipeCommand = async (input, context) => {
612
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
392
+ const b = rb(input, context);
613
393
  const headers = {
614
394
  "content-type": "application/json",
615
395
  };
616
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/recipes/{Name}/publishRecipe";
617
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
396
+ b.bp("/recipes/{Name}/publishRecipe");
397
+ b.p("Name", () => input.Name, "{Name}", false);
618
398
  let body;
619
399
  body = JSON.stringify(take(input, {
620
400
  Description: [],
621
401
  }));
622
- return new __HttpRequest({
623
- protocol,
624
- hostname,
625
- port,
626
- method: "POST",
627
- headers,
628
- path: resolvedPath,
629
- body,
630
- });
402
+ b.m("POST").h(headers).b(body);
403
+ return b.build();
631
404
  };
632
405
  export const se_SendProjectSessionActionCommand = async (input, context) => {
633
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
406
+ const b = rb(input, context);
634
407
  const headers = {
635
408
  "content-type": "application/json",
636
409
  };
637
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/projects/{Name}/sendProjectSessionAction";
638
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
410
+ b.bp("/projects/{Name}/sendProjectSessionAction");
411
+ b.p("Name", () => input.Name, "{Name}", false);
639
412
  let body;
640
413
  body = JSON.stringify(take(input, {
641
414
  ClientSessionId: [],
@@ -644,121 +417,78 @@ export const se_SendProjectSessionActionCommand = async (input, context) => {
644
417
  StepIndex: [],
645
418
  ViewFrame: (_) => _json(_),
646
419
  }));
647
- return new __HttpRequest({
648
- protocol,
649
- hostname,
650
- port,
651
- method: "PUT",
652
- headers,
653
- path: resolvedPath,
654
- body,
655
- });
420
+ b.m("PUT").h(headers).b(body);
421
+ return b.build();
656
422
  };
657
423
  export const se_StartJobRunCommand = async (input, context) => {
658
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
424
+ const b = rb(input, context);
659
425
  const headers = {};
660
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/jobs/{Name}/startJobRun";
661
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
426
+ b.bp("/jobs/{Name}/startJobRun");
427
+ b.p("Name", () => input.Name, "{Name}", false);
662
428
  let body;
663
- return new __HttpRequest({
664
- protocol,
665
- hostname,
666
- port,
667
- method: "POST",
668
- headers,
669
- path: resolvedPath,
670
- body,
671
- });
429
+ b.m("POST").h(headers).b(body);
430
+ return b.build();
672
431
  };
673
432
  export const se_StartProjectSessionCommand = async (input, context) => {
674
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
433
+ const b = rb(input, context);
675
434
  const headers = {
676
435
  "content-type": "application/json",
677
436
  };
678
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/projects/{Name}/startProjectSession";
679
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
437
+ b.bp("/projects/{Name}/startProjectSession");
438
+ b.p("Name", () => input.Name, "{Name}", false);
680
439
  let body;
681
440
  body = JSON.stringify(take(input, {
682
441
  AssumeControl: [],
683
442
  }));
684
- return new __HttpRequest({
685
- protocol,
686
- hostname,
687
- port,
688
- method: "PUT",
689
- headers,
690
- path: resolvedPath,
691
- body,
692
- });
443
+ b.m("PUT").h(headers).b(body);
444
+ return b.build();
693
445
  };
694
446
  export const se_StopJobRunCommand = async (input, context) => {
695
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
447
+ const b = rb(input, context);
696
448
  const headers = {};
697
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/jobs/{Name}/jobRun/{RunId}/stopJobRun";
698
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
699
- resolvedPath = __resolvedPath(resolvedPath, input, "RunId", () => input.RunId, "{RunId}", false);
449
+ b.bp("/jobs/{Name}/jobRun/{RunId}/stopJobRun");
450
+ b.p("Name", () => input.Name, "{Name}", false);
451
+ b.p("RunId", () => input.RunId, "{RunId}", false);
700
452
  let body;
701
- return new __HttpRequest({
702
- protocol,
703
- hostname,
704
- port,
705
- method: "POST",
706
- headers,
707
- path: resolvedPath,
708
- body,
709
- });
453
+ b.m("POST").h(headers).b(body);
454
+ return b.build();
710
455
  };
711
456
  export const se_TagResourceCommand = async (input, context) => {
712
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
457
+ const b = rb(input, context);
713
458
  const headers = {
714
459
  "content-type": "application/json",
715
460
  };
716
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{ResourceArn}";
717
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
461
+ b.bp("/tags/{ResourceArn}");
462
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
718
463
  let body;
719
464
  body = JSON.stringify(take(input, {
720
465
  Tags: (_) => _json(_),
721
466
  }));
722
- return new __HttpRequest({
723
- protocol,
724
- hostname,
725
- port,
726
- method: "POST",
727
- headers,
728
- path: resolvedPath,
729
- body,
730
- });
467
+ b.m("POST").h(headers).b(body);
468
+ return b.build();
731
469
  };
732
470
  export const se_UntagResourceCommand = async (input, context) => {
733
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
471
+ const b = rb(input, context);
734
472
  const headers = {};
735
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{ResourceArn}";
736
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
473
+ b.bp("/tags/{ResourceArn}");
474
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
737
475
  const query = map({
738
- tagKeys: [
476
+ [_tK]: [
739
477
  __expectNonNull(input.TagKeys, `TagKeys`) != null,
740
- () => (input.TagKeys || []).map((_entry) => _entry),
478
+ () => (input[_TK] || []).map((_entry) => _entry),
741
479
  ],
742
480
  });
743
481
  let body;
744
- return new __HttpRequest({
745
- protocol,
746
- hostname,
747
- port,
748
- method: "DELETE",
749
- headers,
750
- path: resolvedPath,
751
- query,
752
- body,
753
- });
482
+ b.m("DELETE").h(headers).q(query).b(body);
483
+ return b.build();
754
484
  };
755
485
  export const se_UpdateDatasetCommand = async (input, context) => {
756
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
486
+ const b = rb(input, context);
757
487
  const headers = {
758
488
  "content-type": "application/json",
759
489
  };
760
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/datasets/{Name}";
761
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
490
+ b.bp("/datasets/{Name}");
491
+ b.p("Name", () => input.Name, "{Name}", false);
762
492
  let body;
763
493
  body = JSON.stringify(take(input, {
764
494
  Format: [],
@@ -766,23 +496,16 @@ export const se_UpdateDatasetCommand = async (input, context) => {
766
496
  Input: (_) => _json(_),
767
497
  PathOptions: (_) => _json(_),
768
498
  }));
769
- return new __HttpRequest({
770
- protocol,
771
- hostname,
772
- port,
773
- method: "PUT",
774
- headers,
775
- path: resolvedPath,
776
- body,
777
- });
499
+ b.m("PUT").h(headers).b(body);
500
+ return b.build();
778
501
  };
779
502
  export const se_UpdateProfileJobCommand = async (input, context) => {
780
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
503
+ const b = rb(input, context);
781
504
  const headers = {
782
505
  "content-type": "application/json",
783
506
  };
784
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/profileJobs/{Name}";
785
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
507
+ b.bp("/profileJobs/{Name}");
508
+ b.p("Name", () => input.Name, "{Name}", false);
786
509
  let body;
787
510
  body = JSON.stringify(take(input, {
788
511
  Configuration: (_) => _json(_),
@@ -797,67 +520,46 @@ export const se_UpdateProfileJobCommand = async (input, context) => {
797
520
  Timeout: [],
798
521
  ValidationConfigurations: (_) => _json(_),
799
522
  }));
800
- return new __HttpRequest({
801
- protocol,
802
- hostname,
803
- port,
804
- method: "PUT",
805
- headers,
806
- path: resolvedPath,
807
- body,
808
- });
523
+ b.m("PUT").h(headers).b(body);
524
+ return b.build();
809
525
  };
810
526
  export const se_UpdateProjectCommand = async (input, context) => {
811
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
527
+ const b = rb(input, context);
812
528
  const headers = {
813
529
  "content-type": "application/json",
814
530
  };
815
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/projects/{Name}";
816
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
531
+ b.bp("/projects/{Name}");
532
+ b.p("Name", () => input.Name, "{Name}", false);
817
533
  let body;
818
534
  body = JSON.stringify(take(input, {
819
535
  RoleArn: [],
820
536
  Sample: (_) => _json(_),
821
537
  }));
822
- return new __HttpRequest({
823
- protocol,
824
- hostname,
825
- port,
826
- method: "PUT",
827
- headers,
828
- path: resolvedPath,
829
- body,
830
- });
538
+ b.m("PUT").h(headers).b(body);
539
+ return b.build();
831
540
  };
832
541
  export const se_UpdateRecipeCommand = async (input, context) => {
833
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
542
+ const b = rb(input, context);
834
543
  const headers = {
835
544
  "content-type": "application/json",
836
545
  };
837
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/recipes/{Name}";
838
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
546
+ b.bp("/recipes/{Name}");
547
+ b.p("Name", () => input.Name, "{Name}", false);
839
548
  let body;
840
549
  body = JSON.stringify(take(input, {
841
550
  Description: [],
842
551
  Steps: (_) => _json(_),
843
552
  }));
844
- return new __HttpRequest({
845
- protocol,
846
- hostname,
847
- port,
848
- method: "PUT",
849
- headers,
850
- path: resolvedPath,
851
- body,
852
- });
553
+ b.m("PUT").h(headers).b(body);
554
+ return b.build();
853
555
  };
854
556
  export const se_UpdateRecipeJobCommand = async (input, context) => {
855
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
557
+ const b = rb(input, context);
856
558
  const headers = {
857
559
  "content-type": "application/json",
858
560
  };
859
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/recipeJobs/{Name}";
860
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
561
+ b.bp("/recipeJobs/{Name}");
562
+ b.p("Name", () => input.Name, "{Name}", false);
861
563
  let body;
862
564
  body = JSON.stringify(take(input, {
863
565
  DataCatalogOutputs: (_) => _json(_),
@@ -871,59 +573,38 @@ export const se_UpdateRecipeJobCommand = async (input, context) => {
871
573
  RoleArn: [],
872
574
  Timeout: [],
873
575
  }));
874
- return new __HttpRequest({
875
- protocol,
876
- hostname,
877
- port,
878
- method: "PUT",
879
- headers,
880
- path: resolvedPath,
881
- body,
882
- });
576
+ b.m("PUT").h(headers).b(body);
577
+ return b.build();
883
578
  };
884
579
  export const se_UpdateRulesetCommand = async (input, context) => {
885
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
580
+ const b = rb(input, context);
886
581
  const headers = {
887
582
  "content-type": "application/json",
888
583
  };
889
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/rulesets/{Name}";
890
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
584
+ b.bp("/rulesets/{Name}");
585
+ b.p("Name", () => input.Name, "{Name}", false);
891
586
  let body;
892
587
  body = JSON.stringify(take(input, {
893
588
  Description: [],
894
589
  Rules: (_) => se_RuleList(_, context),
895
590
  }));
896
- return new __HttpRequest({
897
- protocol,
898
- hostname,
899
- port,
900
- method: "PUT",
901
- headers,
902
- path: resolvedPath,
903
- body,
904
- });
591
+ b.m("PUT").h(headers).b(body);
592
+ return b.build();
905
593
  };
906
594
  export const se_UpdateScheduleCommand = async (input, context) => {
907
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
595
+ const b = rb(input, context);
908
596
  const headers = {
909
597
  "content-type": "application/json",
910
598
  };
911
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/schedules/{Name}";
912
- resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
599
+ b.bp("/schedules/{Name}");
600
+ b.p("Name", () => input.Name, "{Name}", false);
913
601
  let body;
914
602
  body = JSON.stringify(take(input, {
915
603
  CronExpression: [],
916
604
  JobNames: (_) => _json(_),
917
605
  }));
918
- return new __HttpRequest({
919
- protocol,
920
- hostname,
921
- port,
922
- method: "PUT",
923
- headers,
924
- path: resolvedPath,
925
- body,
926
- });
606
+ b.m("PUT").h(headers).b(body);
607
+ return b.build();
927
608
  };
928
609
  export const de_BatchDeleteRecipeVersionCommand = async (output, context) => {
929
610
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -3014,6 +2695,24 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
3014
2695
  value !== "" &&
3015
2696
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
3016
2697
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
2698
+ const _DN = "DatasetName";
2699
+ const _JN = "JobName";
2700
+ const _MR = "MaxResults";
2701
+ const _N = "Name";
2702
+ const _NT = "NextToken";
2703
+ const _PN = "ProjectName";
2704
+ const _RV = "RecipeVersion";
2705
+ const _TA = "TargetArn";
2706
+ const _TK = "TagKeys";
2707
+ const _dN = "datasetName";
2708
+ const _jN = "jobName";
2709
+ const _mR = "maxResults";
2710
+ const _n = "name";
2711
+ const _nT = "nextToken";
2712
+ const _pN = "projectName";
2713
+ const _rV = "recipeVersion";
2714
+ const _tA = "targetArn";
2715
+ const _tK = "tagKeys";
3017
2716
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
3018
2717
  if (encoded.length) {
3019
2718
  return JSON.parse(encoded);